home · contact · privacy
projects / plomrogue2-experiments / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Add ever-decreasing health to animate things, and death.
[plomrogue2-experiments] / new / plomrogue / game.py
diff --git a/new/plomrogue/game.py b/new/plomrogue/game.py
index 78ff6bd1904913486961447f31995d9844e610ae..2e780928cd073d6e23d2248ff30307abfcc2b40e 100755 (executable)
--- a/new/plomrogue/game.py
+++ b/new/plomrogue/game.py
@@ -1,163 +1,17 @@
-from plomrogue.tasks import Task_WAIT, Task_MOVE
-from plomrogue.errors import GameError, ArgError
-from plomrogue.commands import (cmd_GEN_WORLD, cmd_GET_GAMESTATE, cmd_MAP,
-                                cmd_MAP, cmd_THING_TYPE, cmd_THING_POS,
-                                cmd_TERRAIN_LINE, cmd_PLAYER_ID, cmd_TURN,
-                                cmd_SWITCH_PLAYER, cmd_SAVE)
+from plomrogue.tasks import Task_WAIT, Task_MOVE, Task_PICKUP, Task_DROP
+from plomrogue.errors import ArgError, GameError
+from plomrogue.commands import (cmd_GEN_WORLD, cmd_GET_GAMESTATE,
+                                cmd_MAP, cmd_MAP, cmd_THING_TYPE,
+                                cmd_THING_POS, cmd_THING_INVENTORY,
+                                cmd_THING_HEALTH,
+                                cmd_GET_PICKABLE_ITEMS,
+                                cmd_TERRAIN_LINE, cmd_PLAYER_ID,
+                                cmd_TURN, cmd_SWITCH_PLAYER, cmd_SAVE)
 from plomrogue.mapping import MapHex
 from plomrogue.parser import Parser
 from plomrogue.io import GameIO
 from plomrogue.misc import quote, stringify_yx
 from plomrogue.mapping import MapHex
 from plomrogue.parser import Parser
 from plomrogue.io import GameIO
 from plomrogue.misc import quote, stringify_yx
-
-
-
-class ThingBase:
-
-    def __init__(self, world, id_, type_='?', position=[0,0]):
-        self.world = world
-        self.id_ = id_
-        self.type_ = type_
-        self.position = position
-
-
-class Thing(ThingBase):
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.set_task('WAIT')
-        self._last_task_result = None
-        self._stencil = None
-
-    def move_towards_target(self, target):
-        dijkstra_map = type(self.world.map_)(self.world.map_.size)
-        n_max = 256
-        dijkstra_map.terrain = [n_max for i in range(dijkstra_map.size_i)]
-        dijkstra_map[target] = 0
-        shrunk = True
-        visible_map = self.get_visible_map()
-        while shrunk:
-            shrunk = False
-            for pos in dijkstra_map:
-                if visible_map[pos] != '.':
-                    continue
-                neighbors = dijkstra_map.get_neighbors(tuple(pos))
-                for direction in neighbors:
-                    yx = neighbors[direction]
-                    if yx is not None and dijkstra_map[yx] < dijkstra_map[pos] - 1:
-                        dijkstra_map[pos] = dijkstra_map[yx] + 1
-                        shrunk = True
-        #with open('log', 'a') as f:
-        #    f.write('---------------------------------\n')
-        #    for y, line in dijkstra_map.lines():
-        #        for val in line:
-        #            if val < 10:
-        #                f.write(str(val))
-        #            elif val == 256:
-        #                f.write('x')
-        #            else:
-        #                f.write('~')
-        #        f.write('\n')
-        neighbors = dijkstra_map.get_neighbors(tuple(self.position))
-        n = n_max
-        #print('DEBUG', self.position, neighbors)
-        #dirs = dijkstra_map.get_directions()
-        #print('DEBUG dirs', dirs)
-        #print('DEBUG neighbors', neighbors)
-        #debug_scores = []
-        #for pos in neighbors:
-        #    if pos is None:
-        #        debug_scores += [9000]
-        #    else:
-        #        debug_scores += [dijkstra_map[pos]]
-        #print('DEBUG debug_scores', debug_scores)
-        target_direction = None
-        for direction in neighbors:
-            yx = neighbors[direction]
-            if yx is not None:
-                n_new = dijkstra_map[yx]
-                if n_new < n:
-                    n = n_new
-                    target_direction = direction
-        #print('DEBUG result', direction)
-        if target_direction:
-            self.set_task('MOVE', (target_direction,))
-
-    def decide_task(self):
-        # TODO: Check if monster can follow player too well (even when they should lose them)
-        visible_things = self.get_visible_things()
-        target = None
-        for t in visible_things:
-            if t.type_ == 'human':
-                target = t.position
-                break
-        if target is not None:
-            try:
-                self.move_towards_target(target)
-                return
-            except GameError:
-                pass
-        self.set_task('WAIT')
-
-    def set_task(self, task_name, args=()):
-        task_class = self.world.game.tasks[task_name]
-        self.task = task_class(self, args)
-        self.task.check()  # will throw GameError if necessary
-
-    def proceed(self, is_AI=True):
-        """Further the thing in its tasks.
-
-        Decrements .task.todo; if it thus falls to <= 0, enacts method
-        whose name is 'task_' + self.task.name and sets .task =
-        None. If is_AI, calls .decide_task to decide a self.task.
-
-        Before doing anything, ensures an empty map visibility stencil
-        and checks that task is still possible, and aborts it
-        otherwise (for AI things, decides a new task).
-
-        """
-        self._stencil = None
-        try:
-            self.task.check()
-        except GameError as e:
-            self.task = None
-            self._last_task_result = e
-            if is_AI:
-                try:
-                    self.decide_task()
-                except GameError:
-                    self.set_task('WAIT')
-            return
-        self.task.todo -= 1
-        if self.task.todo <= 0:
-            self._last_task_result = self.task.do()
-            self.task = None
-        if is_AI and self.task is None:
-            try:
-                self.decide_task()
-            except GameError:
-                self.set_task('WAIT')
-
-    def get_stencil(self):
-        if self._stencil is not None:
-            return self._stencil
-        self._stencil = self.world.map_.get_fov_map(self.position)
-        return self._stencil
-
-    def get_visible_map(self):
-        stencil = self.get_stencil()
-        m = self.world.map_.new_from_shape(' ')
-        for pos in m:
-            if stencil[pos] == '.':
-                m[pos] = self.world.map_[pos]
-        return m
-
-    def get_visible_things(self):
-        stencil = self.get_stencil()
-        visible_things = []
-        for thing in self.world.things:
-            if stencil[thing.position] == '.':
-                visible_things += [thing]
-        return visible_things
+from plomrogue.things import Thing, ThingMonster, ThingHuman, ThingItem
 
 
 
 
 
 
@@ -185,6 +39,16 @@ class World(WorldBase):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.player_id = 0
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.player_id = 0
+        self.player_is_alive = True
+
+    @property
+    def player(self):
+        return self.get_thing(self.player_id)
+
+    def new_thing_id(self):
+        if len(self.things) == 0:
+            return 0
+        return self.things[-1].id_ + 1
 
     def new_map(self, yx):
         self.map_ = self.game.map_type(yx)
 
     def new_map(self, yx):
         self.map_ = self.game.map_type(yx)
@@ -199,25 +63,32 @@ class World(WorldBase):
         (after incrementing the world turn) all that come before the
         player; then the player's .proceed() is run, and if it does
         not finish his task, the loop starts at the beginning. Once
         (after incrementing the world turn) all that come before the
         player; then the player's .proceed() is run, and if it does
         not finish his task, the loop starts at the beginning. Once
-        the player's task is finished, the loop breaks.
+        the player's task is finished, or the player is dead, the loop
+        breaks.
+
         """
         while True:
         """
         while True:
-            player = self.get_player()
-            player_i = self.things.index(player)
+            player_i = self.things.index(self.player)
             for thing in self.things[player_i+1:]:
                 thing.proceed()
             self.turn += 1
             for thing in self.things[:player_i]:
                 thing.proceed()
             for thing in self.things[player_i+1:]:
                 thing.proceed()
             self.turn += 1
             for thing in self.things[:player_i]:
                 thing.proceed()
-            player.proceed(is_AI=False)
-            if player.task is None:
+            self.player.proceed(is_AI=False)
+            if self.player.task is None or not self.player_is_alive:
                 break
 
                 break
 
-    def get_player(self):
-        return self.get_thing(self.player_id)
-
     def make_new(self, yx, seed):
         import random
     def make_new(self, yx, seed):
         import random
+
+        def add_thing(type_):
+            t = self.game.thing_types[type_](self)
+            t.position = (random.randint(0, yx[0] -1),
+                          random.randint(0, yx[1] - 1))
+            self.things += [t]
+            return t
+
+        self.things = []
         random.seed(seed)
         self.turn = 0
         self.new_map(yx)
         random.seed(seed)
         self.turn = 0
         self.new_map(yx)
@@ -226,15 +97,13 @@ class World(WorldBase):
                 self.map_[pos] = '#'
                 continue
             self.map_[pos] = random.choice(('.', '.', '.', '.', 'x'))
                 self.map_[pos] = '#'
                 continue
             self.map_[pos] = random.choice(('.', '.', '.', '.', 'x'))
-        player = self.game.thing_type(self, 0)
-        player.type_ = 'human'
-        player.position = [random.randint(0, yx[0] -1),
-                           random.randint(0, yx[1] - 1)]
-        npc = self.game.thing_type(self, 1)
-        npc.type_ = 'monster'
-        npc.position = [random.randint(0, yx[0] -1),
-                        random.randint(0, yx[1] -1)]
-        self.things = [player, npc]
+
+        player = add_thing('human')
+        self.player_id = player.id_
+        add_thing('monster')
+        add_thing('monster')
+        add_thing('item')
+        add_thing('item')
         return 'success'
 
 
         return 'success'
 
 
@@ -244,13 +113,19 @@ class Game:
     def __init__(self, game_file_name):
         self.io = GameIO(game_file_name, self)
         self.map_type = MapHex
     def __init__(self, game_file_name):
         self.io = GameIO(game_file_name, self)
         self.map_type = MapHex
-        self.tasks = {'WAIT': Task_WAIT, 'MOVE': Task_MOVE}
+        self.tasks = {'WAIT': Task_WAIT,
+                      'MOVE': Task_MOVE,
+                      'PICKUP': Task_PICKUP,
+                      'DROP': Task_DROP}
         self.commands = {'GEN_WORLD': cmd_GEN_WORLD,
                          'GET_GAMESTATE': cmd_GET_GAMESTATE,
                          'MAP': cmd_MAP,
                          'THING_TYPE': cmd_THING_TYPE,
                          'THING_POS': cmd_THING_POS,
         self.commands = {'GEN_WORLD': cmd_GEN_WORLD,
                          'GET_GAMESTATE': cmd_GET_GAMESTATE,
                          'MAP': cmd_MAP,
                          'THING_TYPE': cmd_THING_TYPE,
                          'THING_POS': cmd_THING_POS,
+                         'THING_HEALTH': cmd_THING_HEALTH,
+                         'THING_INVENTORY': cmd_THING_INVENTORY,
                          'TERRAIN_LINE': cmd_TERRAIN_LINE,
                          'TERRAIN_LINE': cmd_TERRAIN_LINE,
+                         'GET_PICKABLE_ITEMS': cmd_GET_PICKABLE_ITEMS,
                          'PLAYER_ID': cmd_PLAYER_ID,
                          'TURN': cmd_TURN,
                          'SWITCH_PLAYER': cmd_SWITCH_PLAYER,
                          'PLAYER_ID': cmd_PLAYER_ID,
                          'TURN': cmd_TURN,
                          'SWITCH_PLAYER': cmd_SWITCH_PLAYER,
@@ -258,10 +133,15 @@ class Game:
         self.world_type = World
         self.world = self.world_type(self)
         self.thing_type = Thing
         self.world_type = World
         self.world = self.world_type(self)
         self.thing_type = Thing
+        self.thing_types = {'human': ThingHuman,
+                            'monster': ThingMonster,
+                            'item': ThingItem}
 
     def get_string_options(self, string_option_type):
         if string_option_type == 'direction':
             return self.world.map_.get_directions()
 
     def get_string_options(self, string_option_type):
         if string_option_type == 'direction':
             return self.world.map_.get_directions()
+        elif string_option_type == 'thingtype':
+            return list(self.thing_types.keys())
         return None
 
     def send_gamestate(self, connection_id=None):
         return None
 
     def send_gamestate(self, connection_id=None):
@@ -269,16 +149,27 @@ class Game:
 
         self.io.send('TURN ' + str(self.world.turn))
         self.io.send('MAP ' + stringify_yx(self.world.map_.size))
 
         self.io.send('TURN ' + str(self.world.turn))
         self.io.send('MAP ' + stringify_yx(self.world.map_.size))
-        visible_map = self.world.get_player().get_visible_map()
+        visible_map = self.world.player.get_visible_map()
         for y, line in visible_map.lines():
             self.io.send('VISIBLE_MAP_LINE %5s %s' % (y, quote(line)))
         for y, line in visible_map.lines():
             self.io.send('VISIBLE_MAP_LINE %5s %s' % (y, quote(line)))
-        visible_things = self.world.get_player().get_visible_things()
+        visible_things = self.world.player.get_visible_things()
         for thing in visible_things:
             self.io.send('THING_TYPE %s %s' % (thing.id_, thing.type_))
             self.io.send('THING_POS %s %s' % (thing.id_,
                                               stringify_yx(thing.position)))
         for thing in visible_things:
             self.io.send('THING_TYPE %s %s' % (thing.id_, thing.type_))
             self.io.send('THING_POS %s %s' % (thing.id_,
                                               stringify_yx(thing.position)))
-        player = self.world.get_player()
-        self.io.send('PLAYER_POS %s' % (stringify_yx(player.position)))
+            if hasattr(thing, 'health'):
+                self.io.send('THING_HEALTH %s %s' % (thing.id_,
+                                                     thing.health))
+        if len(self.world.player.inventory) > 0:
+            self.io.send('PLAYER_INVENTORY %s' %
+                         ','.join([str(i) for i in self.world.player.inventory]))
+        else:
+            self.io.send('PLAYER_INVENTORY ,')
+        for id_ in self.world.player.inventory:
+            thing = self.world.get_thing(id_)
+            self.io.send('THING_TYPE %s %s' % (thing.id_, thing.type_))
+            self.io.send('THING_POS %s %s' % (thing.id_,
+                                              stringify_yx(thing.position)))
         self.io.send('GAME_STATE_COMPLETE')
 
     def proceed(self):
         self.io.send('GAME_STATE_COMPLETE')
 
     def proceed(self):
@@ -289,7 +180,7 @@ class Game:
         """
         self.io.send('TURN_FINISHED ' + str(self.world.turn))
         self.world.proceed_to_next_player_turn()
         """
         self.io.send('TURN_FINISHED ' + str(self.world.turn))
         self.world.proceed_to_next_player_turn()
-        msg = str(self.world.get_player()._last_task_result)
+        msg = str(self.world.player._last_task_result)
         self.io.send('LAST_PLAYER_TASK_RESULT ' + quote(msg))
         self.send_gamestate()
 
         self.io.send('LAST_PLAYER_TASK_RESULT ' + quote(msg))
         self.send_gamestate()
 
@@ -302,7 +193,9 @@ class Game:
             return p
 
         def cmd_TASK_colon(task_name, game, *args):
             return p
 
         def cmd_TASK_colon(task_name, game, *args):
-            game.world.get_player().set_task(task_name, args)
+            if not game.world.player_is_alive:
+                raise GameError('You are dead.')
+            game.world.player.set_task(task_name, args)
             game.proceed()
 
         def cmd_SET_TASK_colon(task_name, game, thing_id, todo, *args):
             game.proceed()
 
         def cmd_SET_TASK_colon(task_name, game, thing_id, todo, *args):
preliminary study for new roguelike engine