More refactoring.

diff --git a/new/example_client.py b/new/example_client.py
index 7a9902708a60cf36140ae2024fd1e9c21cbb00d6..a877da84f603bc0de3e69cfbc2beca7439aaf1c5 100755 (executable)
--- a/new/example_client.py
+++ b/new/example_client.py
@@ -4,9 +4,10 @@ import socket
 import threading
 from plomrogue.parser import ArgError, Parser
 from plomrogue.commands import cmd_MAP, cmd_THING_TYPE, cmd_THING_POS
 import threading
 from plomrogue.parser import ArgError, Parser
 from plomrogue.commands import cmd_MAP, cmd_THING_TYPE, cmd_THING_POS

-from plomrogue.game import Game, WorldBase, ThingBase
+from plomrogue.game import Game, WorldBase

 from plomrogue.mapping import MapBase
 from plomrogue.io import PlomSocket
 from plomrogue.mapping import MapBase
 from plomrogue.io import PlomSocket

+from plomrogue.things import ThingBase

 import types
 
 
 import types
 
 

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.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,
 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
 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

 
 
 
 
 
 

diff --git a/new/plomrogue/things.py b/new/plomrogue/things.py
new file mode 100644 (file)
index 0000000..a80e9e4
--- /dev/null
+++ b/new/plomrogue/things.py
@@ -0,0 +1,128 @@
+from plomrogue.errors import GameError
+
+
+
+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
+        neighbors = dijkstra_map.get_neighbors(tuple(self.position))
+        n = n_max
+        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
+        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