erdslangetjie/player.py

   1 # Player and Player-like objects
   2
   3 from erdslangetjie.data import load_image
   4
   5
   6 class GameSprite(object):
   7
   8     def __init__(self):
   9         self.pos = (0, 0)
  10         self.sprite = None
  11
  12     def get_image(self):
  13         return self.sprite
  14
  15     def get_texture(self):
  16         return self.sprite.texture
  17
  18
  19 class FigureSprite(GameSprite):
  20
  21     def can_move(self, direction, level):
  22         '''Check if we can move in the given direction'''
  23         cand_pos = (self.pos[0] + direction[0], self.pos[1] + direction[1])
  24         return not level.blocked(cand_pos)
  25
  26
  27 class ThePlayer(FigureSprite):
  28
  29     def __init__(self):
  30         super(ThePlayer, self).__init__()
  31         self.sprite = load_image('sprites/player.png')
  32
  33     def move(self, direction, level):
  34         if self.can_move(direction, level):
  35             self.pos = (self.pos[0] + direction[0], self.pos[1] + direction[1])
  36             return True
  37         return False
  38
  39
  40 class Nemesis(FigureSprite):
  41
  42     def __init__(self):
  43         super(Nemesis, self).__init__()
  44         self.sprite = load_image('sprites/nemesis.png')
  45         self.reset_pos()
  46         self._deadends = set([])
  47         self._been = {}
  48
  49     def move(self, level, player_pos):
  50         if not self.on_board():
  51             # Advance towards the map a step at a time
  52             self.pos = (self.pos[0] + 1, self.pos[1])
  53             if self.on_board():
  54                 self.pos = level.enter_pos
  55             return
  56         # AI goes here
  57         # First, if we're standing next to a gate, we attack it
  58         neighbours = [(self.pos[0] + 1, self.pos[1]),
  59                 (self.pos[0] - 1, self.pos[1]),
  60                 (self.pos[0], self.pos[1] + 1),
  61                 (self.pos[0], self.pos[1] - 1)]
  62         for cand in neighbours:
  63             if level.is_gate(cand) and level.blocked(cand):
  64                 level.damage_gate(cand)
  65                 return
  66         # check for dead-ends
  67         if self._in_dead_end(level):
  68             self._deadends.add(self.pos)
  69         self._been.setdefault(self.pos, 0)
  70         mindist = 999999
  71         best_pos = None
  72         for direction in [(1, 0), (-1, 0), (0, -1), (0, 1)]:
  73             new_pos = (self.pos[0] + direction[0], self.pos[1] + direction[1])
  74             if new_pos in self._deadends:
  75                 continue
  76             if self.can_move(direction, level):
  77                 # We weigh stuff by the number of times we've stepped there, to
  78                 # avoid certain types of loop
  79                 dist = (level.calc_dist(new_pos, player_pos)
  80                         + self._been.get(new_pos, 0))
  81                 if dist < mindist:
  82                     mindist = dist
  83                     best_pos = new_pos
  84         if best_pos:
  85             self._been[self.pos] += 1
  86             self.pos = best_pos
  87
  88     def reset_pos(self):
  89         self.pos = (-10, 0)
  90         self._deadends = set([])
  91         self._been = {}
  92
  93     def on_board(self):
  94         return self.pos[0] >= 0
  95
  96     def _in_dead_end(self, level):
  97         # Check if this is a dead end
  98         blocked = 0
  99         for direction in [(1, 0), (-1, 0), (0, -1), (0, 1)]:
 100             new_pos = (self.pos[0] + direction[0], self.pos[1] + direction[1])
 101             if level.is_wall(new_pos) or new_pos in self._deadends:
 102                 blocked += 1
 103         # A dead end has only 1 exit, and recurse back from there
 104         return blocked >= 3