implementing Custom Zone

Author: atupone

python/CustomZoneSample.py

@@ -0,0 +1,104 @@
+from bzfsItf import *
+
+# The custom zone we'll be making for this plug-in and we'll be extending a
+# class provided by the API.
+# The class provided in the API handles all of the logic handling rectangular
+# and circular zones.
+class MsgZone (bz_CustomZoneObject):
+    # Our custom constructor will call the parent constructor so we can setup
+    # default positions for the zone
+    flag    = 'US'
+
+    # Custom fields that are unique to our zone so we can build on top of the
+    # class we're extending
+    message = ''
+
+class CustomZoneSample (bz_Plugin, bz_CustomMapObjectHandler):
+    msgZones = []
+
+    def Name (self):
+        return 'Custom Zone Sample'
+
+    def Init (self, _):
+        self.Register(bz_ePlayerUpdateEvent)
+
+        # Whenever a player enters a zone and is carrying a specified flag,
+        # they will receive the specified message
+        bz_registerCustomMapObject('msgzone', self)
+
+
+    def Event (self, updateData):
+        if updateData.eventType != bz_ePlayerUpdateEvent:
+            return
+
+        # This event is called each time a player sends an update to the server
+        # Loop through all of our custom zones
+        for msgZone in self.msgZones:
+            # Use the pointInZone(float pos[3]) function provided by the
+            # bz_CustomZoneObject to check if the position
+            # of the player is inside of the zone. This function will
+            # automatically handle the logic if the zone is a
+            # rectangle (even if it's rotated) or a circle
+            if msgZone.pointInZone(updateData.state.pos) and \
+                    bz_getPlayerFlagID(updateData.playerID) >= 0:
+                # If the player has the flag specified in the zone, send them
+                # a message and remove their flag
+                if bz_getPlayerFlag(updateData.playerID) == msgZone.flag:
+                    bz_sendTextMessage(updateData.playerID, msgZone.message)
+                    bz_removePlayerFlag(updateData.playerID);
+
+    def Cleanup (self):
+        self.Flush();
+
+        bz_removeCustomMapObject('msgzone');
+
+    def MapObject (self, object, data):
+        if object != 'MSGZONE' or not data:
+            return False
+
+        # The new zone we just found and we'll be storing in our vector of
+        # zones
+        newZone = MsgZone()
+
+        # This function will parse the attributes that are handled by
+        # bz_CustomZoneObject which
+        # handles rectangular and circular zones
+        #
+        # For rectangular zones:
+        #   - position
+        #   - size
+        #   - rotation
+        #
+        # For circular zones:
+        #   - position
+        #   - height
+        #   - radius
+        #
+        # This also handles BBOX and CYLINDER fields but they have been
+        # deprecated and will be removed in the future
+        newZone.handleDefaultOptions(data)
+
+        # Loop through the object data
+        for line in data:
+            nubs = bz_tokenize(line)
+
+            if len(nubs) <= 1:
+                continue
+
+            if len(nubs[1]) >=2 and nubs[1][0] == '"':
+                nubs[1] = nubs[1][1:-1]
+
+            key = nubs[0].upper()
+
+            # These are our custom fields in the MsgZone class
+            if key == 'MESSAGE':
+                newZone.message = nubs[1]
+            elif key == 'FLAG':
+                newZone.flag = nubs[1]
+        print(newZone.__dict__)
+
+        self.msgZones.append(newZone)
+
+        return True
+
+plugin = CustomZoneSample()

python/bzfsItf.py

@@ -1,5 +1,7 @@
 import time
 from enum import Enum
+import math
+import re
 
 class Team(Enum):
     eNoTeam         = -1
@@ -73,6 +75,138 @@ def bz_getLocaltime():
     myTime.dow    = (now.tm_wday + 1) % 7
     return myTime
 
+class bz_CustomMapObjectHandler():
+    pass
+
+class bz_CustomZoneObject():
+    box      = False
+    radius2  = 25
+    cX       = 0
+    cY       = 0
+    cZ       = 0
+    hh       = 0
+    hw       = 0
+    height   = 5
+    sin_val  = 0
+    cos_val  = 1
+
+    def pointInZone(self, pos):
+        # Coordinates of player relative to the "fake" origin
+        px = pos[0] - self.cX;
+        py = pos[1] - self.cY;
+        pz = pos[2] - self.cZ;
+
+        if pos[2] < 0:
+            return False
+        if pos[2] > self.height:
+            return False
+
+        if self.box:
+            # Instead of rotating the box against (0,0)
+            # rotates the world in the opposite direction
+            px, py = \
+                    ( px * cos_val + py * sin_val), \
+                    (-px * sin_val + py * cos_val)
+            # As the world is now simmetric remove the sign
+            px = abs(px)
+            py = abs(py)
+
+            # Check now it the point is within the box
+            if px > hw:
+                return False
+            if py > hh:
+                return False
+        else:
+            dist2 = px * px + py * py
+
+            if dist2 > self.radius2:
+                return False
+        return True
+
+    def handleDefaultOptions(self, data):
+        # default values just in case
+        self.radius2  = 25 # Default radius 5
+        self.height   = 5
+        self.sin_val  = 0
+        self.cos_val  = 1
+
+        # parse all the chunks
+        for line in data:
+            nubs = line.split()
+
+            if len(nubs) <= 1:
+                continue
+
+            key = nubs[0].upper()
+
+            if key == 'BBOX' and len(nubs) > 6:
+                self.box = True
+
+                xMin = float(nubs[1])
+                xMax = float(nubs[2])
+                yMin = float(nubs[3])
+                yMax = float(nubs[4])
+
+                # Center of the rectangle, we can treat this as the "fake"
+                # origin
+                self.cX = (xMax + xMin) / 2
+                self.cY = (yMax + yMin) / 2
+
+                self.hh  = abs(yMax - yMin) / 2
+                self.hw  = abs(xMax - xMin) / 2
+
+                self.cZ     = float(nubs[5])
+                self.height = float(nubs[6]) - self.cZ
+
+                bz_debugMessage(0,
+                        'WARNING: The "BBOX" attribute has been deprecated.'\
+                                ' Please use the `position` and `size` '\
+                                'attributes instead:')
+                bz_debugMessage(0, '  position {f} {f} {f}'
+                        .format(self.cX, self.cY, self.cZ))
+                bz_debugMessage(0, '  size {} {} {}'
+                        .format(self.hw, self.hh, self.height))
+            elif key == 'CYLINDER' and len(nubs) > 5:
+                self.box = False
+                # Center of the cylinder
+                self.cX = float(nubs[1])
+                self.cY = float(nubs[2])
+                self.cZ = float(nubs[3])
+                self.height = float(nubs[4]) - self.cZ
+                self.radius = float(nubs[5])
+
+                bz_debugMessage(0,
+                        'WARNING: The "CYLINDER" attribute has been '\
+                                'deprecated. Please use `radius` and '\
+                                '`height` instead:')
+                bz_debugMessage(0, '  position {} {} {}'
+                        .format(self.cX, self.cY, self.cZ))
+                bz_debugMessage(0, '  radius {}'.format(self.radius))
+                bz_debugMessage(0, '  height {}'.format(self.height))
+            elif (key == 'POSITION' or key == 'POS') and len(nubs) > 3:
+                self.cX = float(nubs[1])
+                self.cY = float(nubs[2])
+                self.cZ = float(nubs[3])
+            elif key == 'SIZE' and len(nubs) > 3:
+                self.box = True
+                # Half Width and Half Heigth
+                self.hw     = float(nubs[1])
+                self.hh     = float(nubs[2])
+                self.height = float(nubs[3])
+            elif (key == 'ROTATION') or (key == 'ROT'):
+                rotation     = float(nubs[1])
+                if not 0 < rotation < 360:
+                    rotation = 0
+                rotRad       = rotation * math.pi / 180
+                self.cos_val = math.cos(rotRad)
+                self.sin_val = math.sin(rotRad)
+            elif (key == 'RADIUS') or (key == 'RAD'):
+                self.box     = False
+                self.radius  = float(nubs[1])
+                self.radius *= self.radius
+            elif key == 'HEIGHT':
+                self.height = float(nubs[1])
+
 bz_eGetPlayerSpawnPosEvent = 1
 bz_eTickEvent              = 2
 bz_eRawChatMessageEvent    = 3
@@ -81,7 +215,7 @@ def bz_getLocaltime():
 bz_eFlagDroppedEvent       = 6
 bz_eShotFiredEvent         = 7
 bz_ePlayerDieEvent         = 8
-
+bz_ePlayerUpdateEvent      = 9
 
 eGoodFlag        = 0
 eBadFlag         = 1
@@ -170,12 +304,18 @@ def bzShotFiredEvent(plugin, playerID):
     event.playerID = playerID
     callEvents(event)
 
-def bzDiedEvent(plugin, playerID, flagKilledWith):
+def bzDiedEvent(plugin):
     event = bz_EventData(bz_ePlayerDieEvent)
     event.playerID       = playerID
     event.flagKilledWith = flagKilledWith
     callEvents(event)
 
+def bzUpdateEvent(plugin, playerID, pos):
+    event = bz_EventData(bz_ePlayerUpdateEvent)
+    event.playerID = playerID;
+    event.pos      = pos;
+    callEvents(event)
+
 # Command Handler
 
 class bz_CustomSlashCommandHandler():
@@ -279,3 +419,31 @@ def bz_PollHelp(playerID):
     for k, v in customPollTypes.items():
         reply = '    or /poll ' + k + ' ' + v.pollParameters
         bz_sendTextMessage(playerID, reply)
+
+
+customObjectMap = {}
+
+def bz_registerCustomMapObject (objectName, handler):
+    if not objectName or not handler:
+        return False
+
+    customObjectMap[objectName.upper()] = handler;
+    return True
+
+def bz_removeCustomMapObject (objectName):
+    if not objectName:
+        return False
+
+    obj = objectName.upper()
+    if obj in customObjectMap:
+        del customObjectMap[obj]
+    return True
+
+def bz_CheckIfCustomMap(objectName):
+    return objectName in customObjectMap
+
+def bz_customZoneMapObject(customObject, customLines):
+    customObjectMap[customObject].MapObject(customObject, customLines);
+
+def bz_tokenize(line):
+    return re.findall(r'[^"\s]\S*|".+?"', line)

src/bzfs/BZWReader.cxx

@@ -53,6 +53,7 @@
 
 // bzfs specific headers
 #include "bzfs.h"
+#include "bzfsPython.h"
 
 
 BZWReader::BZWReader(std::string filename) : cURLManager(), location(filename),
@@ -203,6 +204,7 @@ bool BZWReader::readWorldStream(std::vector<WorldFileObject*>& wlist,
 
     std::string customObject;
     std::vector<std::string>  customLines;
+    bool fromPython = false;
 
     bool gotWorld = false;
 
@@ -217,7 +219,7 @@ bool BZWReader::readWorldStream(std::vector<WorldFileObject*>& wlist,
                     std::string("discarding incomplete object"), line);
                 if (object != fakeObject)
                     delete object;
-                else if (customObject.size())
+                else if (not customObject.empty())
                 {
                     customObject = "";
                     customLines.clear();
@@ -259,14 +261,20 @@ bool BZWReader::readWorldStream(std::vector<WorldFileObject*>& wlist,
                     else
                         wlist.push_back(object);
                 }
-                else if (customObject.size())
+                else if (not customObject.empty())
                 {
-                    bz_CustomMapObjectInfo data;
-                    data.name = bz_ApiString(customObject);
-                    for (unsigned int i = 0; i < customLines.size(); i++)
-                        data.data.push_back(customLines[i]);
-                    customObjectMap[customObject]->MapObject(bz_ApiString(customObject),&data);
-                    object = NULL;
+                    if (fromPython)
+                    {
+                        bzPython_customZoneMapObject(customObject, customLines);
+                    }
+                    else
+                    {
+                        bz_CustomMapObjectInfo data;
+                        data.name = bz_ApiString(customObject);
+                        for (unsigned int i = 0; i < customLines.size(); i++)
+                            data.data.push_back(customLines[i]);
+                        customObjectMap[customObject]->MapObject(bz_ApiString(customObject),&data);
+                    }
                 }
                 object = NULL;
             }
@@ -411,7 +419,7 @@ bool BZWReader::readWorldStream(std::vector<WorldFileObject*>& wlist,
                     // return false;
                 }
             }
-            else if (customObject.size())
+            else if (not customObject.empty())
             {
                 std::string thisline = buffer;
                 thisline += " ";
@@ -430,12 +438,21 @@ bool BZWReader::readWorldStream(std::vector<WorldFileObject*>& wlist,
         }
         else     // filling the current object
         {
+            std::string currObject = TextUtils::toupper(std::string(buffer));
             // unknown token
-            if (customObjectMap.find(TextUtils::toupper(std::string(buffer))) != customObjectMap.end())
+            if (customObjectMap.find(currObject) != customObjectMap.end())
+            {
+                customObject = currObject;
+                object = fakeObject;
+                customLines.clear();
+                fromPython = false;
+            }
+            else if (bzPython_CheckIfCustomMap(currObject))
             {
-                customObject = TextUtils::toupper(std::string(buffer));
+                customObject = currObject;
                 object = fakeObject;
                 customLines.clear();
+                fromPython = true;
             }
             else
             {