Changeset 21

Timestamp:

03/14/09 00:50:55 (18 months ago)

Author:

icelus_parpg

Message:

Apply ActionStack? patch from tie (ticket #1).
- queue actions for hero to perform (e.g. move to target, act)
- unit tests for ActionStack?
- new run_tests script
- kick added as an always present to allow queueing to be seen.

Location:

trunk/game

Files:

• run_tests.py (added)
• scripts/agents/ActionStack_test.py (added)
• scripts/agents/agent.py (modified) (2 diffs)
• scripts/agents/hero.py (modified) (2 diffs)
• scripts/world.py (modified) (4 diffs)

trunk/game/scripts/agents/agent.py

@@ -1 +1 @@
 import fife
 from scripts.common.common import ProgrammingError
+
+class ActionStack (object):
+        """ 
+    Class, which implements queueing of various user actions.
+    Each entry in the ActoinStack is a 6-item tuple consisting of
+    (action_func, action_func_args, action_func_kw_args,
+    (success_func, success_func_args, success_func_kw_args). 
+
+    Items are processed from index 0 upwards. New actions
+    are appended to the list. Successful actions are popped from the
+    bottom of the list. If the success function of the current
+    action returns True, the current action is popped out, and the
+    next action is processed.
+
+    IMPORTANT: To avoid the danger of endlessly pushing actions to the 
+    stack, it is automatically cleared when an action is added while 
+    the stack is in a running state.
+
+    Example:
+    To define something like "Kick him while he's down", you coud do:
+    .add_action (kick, (him,), isDown, (him,))
+
+    """
+        def __init__ (self):
+                
+                # This is the actual list that stores the entries
+                self.action_list = []
+                # A flag to track if the stack was ran after the last item was added
+                self.running = False
+
+        def add_kw_args_action (self, 
+                        action_func, action_args = (), action_kw_args = {},
+                        success_func = None, success_args = (),success_kw_args = {}):
+                """
+                Appends an action entry to the action_list. Supports both args and 
+                kwargs. If a previous batch of actions was inserted, and then ran, 
+                this will first empty the stack before adding the new entry.
+                """
+                # Basic checks to see if the action and success funcitons are callable 
+                if not callable (action_func):
+                        raise ValueError ("%s is not callable!" % action_func)
+                if success_func and not callable(success_func):
+                        raise ValueError ("%s is not callable!" % success_func)
+                if self.running:
+                        # We have a running queue; clean it up before adding anything new
+                        self.clear()
+                        self.running = False
+
+                self.action_list.append ( (action_func, action_args, action_kw_args, 
+                                           success_func, success_args, success_kw_args))
+
+        def add_action (self, action_func, action_args = (),
+                        success_func = None, success_args = ()):
+                """
+                Appends an action entry to the action_list. Shortcut to 
+                add_kw_args_action() without kwargs. Only supports positinal arguments 
+                for the action_func/success_func
+                """
+                self.add_kw_args_action (action_func, action_args, {}, 
+                                        success_func, success_args , {})
+
+        def remove_current_action (self):
+                """Removes an action from the bottom of the list"""
+                if self.action_list:
+                        self.action_list.pop(0)
+
+        def clear (self):
+                """Removes all actions from the stack"""
+                self.action_list = []
+        
+        def perform_action (self, action_item):
+                """Runs the provided action_item. It is a tuple following the same
+                format as the items in self.action_list """
+                a_func, a_args, a_kw_args = action_item[:3]
+                a_func (*a_args, **a_kw_args)
+                return True
+
+        def run (self):
+                """
+                Runs an action from the queue.
+
+                If there is no success function, just executes the current action 
+                and removes it from the queue. If the success function evaluates
+                to True, removes the current action and proceeds with the next one. 
+                If the success function evaluates to False, only performs 
+                the current action.
+                
+                Returns True if some action was executed, False otherwise.
+                """
+
+                if not self.action_list:
+                        return False
+                # We set the running flag
+                self.running = True
+                
+                # Loop that will go over the aciton_list and exit after performing an 
+                # action. Note that the loop iterates over a copy of the action_list
+                for action in self.action_list[:]:
+                        # Load the current entry success function details
+                        s_func, s_args, s_kw_args = self.action_list[0][3:6]
+
+                        if (not s_func):
+                                # No success function defined - meaning that the 
+                                # action will be popped form the queue and executed once.
+                                return self.perform_action(self.action_list.pop(0))
+                        elif not s_func (*s_args, **s_kw_args):
+                                # The current success conditions evaluated to False, keep 
+                                # performing the current action
+                                return self.perform_action(self.action_list[0])
+                        else:
+                                # The success condition is true - meaning that the current action is
+                                # popped out, and we proceed to the next item in the list
+                                self.action_list.pop(0)
+                
+                # We went through the entire action_list but no action was performed
+                return False
 
 class Agent(fife.InstanceActionListener):
@@ -8 +124 @@
                 self.agentName = agentName
                 self.layer = layer
+                self.action_stack = ActionStack()
                 if uniqInMap:
                         self.agent = layer.getInstance(agentName)

trunk/game/scripts/agents/hero.py

@@ -14 +14 @@
 
         def onInstanceActionFinished(self, instance, action):
+                if self.action_stack and self.action_stack.run():
+                        # The stack executed something, ignore state change
+                        return
                 self.idle()
                 if action.getId() != 'stand':
@@ -42 +45 @@
                 self.state = _STATE_TALK
                 self.agent.act('talk', target)
+        
+        def distance_to (self, target):
+                return self.agent.getLocationRef().getLayerDistanceTo(target.getLocationRef())

trunk/game/scripts/world.py

@@ -53 +53 @@
         def show_instancemenu(self, clickpoint, instance):
                 """Handles the display of the right-click context menu."""
-                # IMPORTANT: We assume that the ALWAYS_PRESENT_BUTTONS are _NEVER_ removed from the instancemenu
-                # IMPORTANT: World and Agent functions that handle different actions 
-                # must be named "buttonNameHandler", e.g. "talkButtonHandler"
-                # TODO: Add a range check; if we are out of range we should queue (get_in_range, perform_action)
+                # IMPORTANT: We assume that the ALWAYS_PRESENT_BUTTONS are 
+                # _NEVER_ removed from the instancemenu
+                # IMPORTANT: World and Agent functions that handle different 
+                # actions must be named "buttonNameHandler", e.g. 
+                # "talkButtonHandler"
                 
                 # no right-click menu for clicking on Hero
                 if instance.getFifeId() == self.hero.agent.getFifeId():
                         return
-                # buttons that will always be available, regardless of the instance type
-                ALWAYS_PRESENT_BTNS = ('moveButton', 'inspectButton')
+                # Buttons that will always be available, regardless of the 
+                # instance type.
+                # IMPORTANT: kickButton is listed here only to allow easier 
+                # testing of the range check/queueing code 
+                ALWAYS_PRESENT_BTNS = ('moveButton', 
+                                       'inspectButton', 
+                                       'kickButton'
+                                       )
+                # Pattern matching the name of the handler functions
                 NAME_PATTERN = "%sHandler"
                 
                 if self.instance_to_agent.has_key(instance.getFifeId()):
-                        # we got an agent here; remove any actions that the agent cannot handle
+                        # we got an agent here; remove any unhandled actions
                         for btn in self.all_btns:
                                 #do we have this button in the current menu?
@@ -75 +83 @@
                                 if btn_needed and not btn_present:
                                         self.instancemenu.addChild(btn)
-                                if not btn_needed and btn_present:
+                                elif not btn_needed and btn_present:
                                         self.instancemenu.removeChild(btn)
                 else:
-                        # we got some other kind of object, so only leave always_present actions
+                        # inst is not Agent; only leave always_present actions
                         for btn in self.instancemenu.children[:]:
                                 if not btn.name in ALWAYS_PRESENT_BTNS:
                                         self.instancemenu.removeChild(btn)
 
-                # map a dictionary of button names to their corresponding World fuctions
-                mapdict = dict([ (btn.name,getattr (self, NAME_PATTERN % btn.name)) for btn in self.instancemenu.children])
+                # map a dictionary of button names to the their World fuctions
+                mapdict = dict([ (btn.name,getattr(self, NAME_PATTERN % btn.name))
+                                 for btn in self.instancemenu.children])
                 self.instancemenu.mapEvents (mapdict)
                 
@@ -207 +216 @@
 
         def mousePressed(self, evt):
+                # quick and dirty way to clear queued actions
+                self.hero.action_stack.clear()
                 if evt.isConsumedByWidgets():
                         return
@@ -263 +274 @@
         def kickButtonHandler(self):
                 self.hide_instancemenu()
+                inst = self.instancemenu.instance
+                #proof-of-concept range checking + action queueing
+                if self.hero.distance_to (inst) > 3:
+                        self.hero.action_stack.add_action (self.hero.agent.follow, 
+                                                          ('run',inst,4 * float(TDS.readSetting("TestAgentSpeed"))), 
+                                                         lambda x: self.hero.distance_to(x) <= 3,
+                                                         (inst,)
+                                                         )
+                        self.hero.action_stack.add_action (self.kickButtonHandler)
+                        self.hero.action_stack.run()
+                        return
+                
                 self.hero.kick(self.instancemenu.instance.getLocationRef())
                 self.instancemenu.instance.say('Hey!', 1000)