More refactoring.

[plomrogue2-experiments] / new / plomrogue / game.py

diff --git a/new/plomrogue/game.py b/new/plomrogue/game.py
index 2c65f045f265679e2a3377e6e8c772df011e9f89..d244582deed90cb227bd5caa5cc7dc5e55f4d036 100755 (executable)
--- a/new/plomrogue/game.py
+++ b/new/plomrogue/game.py
@@ -1,5 +1,5 @@
 from plomrogue.tasks import Task_WAIT, Task_MOVE
-from plomrogue.errors import GameError, ArgError
+from plomrogue.errors import 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,
@@ -8,156 +8,7 @@ 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):
-        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