|
|
|
""" *==LICENSE==*
|
|
|
|
|
|
|
|
CyanWorlds.com Engine - MMOG client, server and tools
|
|
|
|
Copyright (C) 2011 Cyan Worlds, Inc.
|
|
|
|
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
|
|
Additional permissions under GNU GPL version 3 section 7
|
|
|
|
|
|
|
|
If you modify this Program, or any covered work, by linking or
|
|
|
|
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
|
|
|
|
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
|
|
|
|
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
|
|
|
|
(or a modified version of those libraries),
|
|
|
|
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
|
|
|
|
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
|
|
|
|
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
|
|
|
|
licensors of this Program grant you additional
|
|
|
|
permission to convey the resulting work. Corresponding Source for a
|
|
|
|
non-source form of such a combination shall include the source code for
|
|
|
|
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
|
|
|
|
work.
|
|
|
|
|
|
|
|
You can contact Cyan Worlds, Inc. by email legal@cyan.com
|
|
|
|
or by snail mail at:
|
|
|
|
Cyan Worlds, Inc.
|
|
|
|
14617 N Newport Hwy
|
|
|
|
Mead, WA 99021
|
|
|
|
|
|
|
|
*==LICENSE==* """
|
|
|
|
"""
|
|
|
|
This module is contains the datatypes and constants for
|
|
|
|
interfacing with the Plasma 2.0 engine.
|
|
|
|
"""
|
|
|
|
from Plasma import *
|
|
|
|
from PlasmaConstants import *
|
|
|
|
|
|
|
|
####################################
|
|
|
|
# Utility functions
|
|
|
|
####################################
|
|
|
|
false=0
|
|
|
|
true=1
|
|
|
|
|
|
|
|
# OnNotify Event enums
|
|
|
|
kCollisionEvent=PtEventType.kCollision # [1]=enter flag, [2]=hitter(probably avatar), [3]=hittee
|
|
|
|
kPickedEvent=PtEventType.kPicked # [1]=enter flag, [2]=picker(probably avatar), [3]=pickee, [4]=hitpoint(world) [5]=hitpoint(local)
|
|
|
|
kControlKeyEvent=PtEventType.kControlKey # [1]=key id, [2]=down flag
|
|
|
|
kVariableEvent=PtEventType.kVariable # [1]=name, [2]=data type, [3]=data
|
|
|
|
kFacingEvent=PtEventType.kFacing # [1]=enabled flag, [2]=facer(probably avatar), [3]=facee, [4]=dot product
|
|
|
|
kContainedEvent=PtEventType.kContained # [1]=entering flag, [2]=contained(probably avatar), [3]=container
|
|
|
|
kActivateEvent=PtEventType.kActivate # [1]=active flag, [2]=activate flag
|
|
|
|
kCallbackEvent=PtEventType.kCallback # [1]=callback id
|
|
|
|
kResponderStateEvent=PtEventType.kResponderState # [1]=state id
|
|
|
|
kMultiStageEvent=PtEventType.kMultiStage # [1]=what stage, [2]=event(see below), [3]=avatar
|
|
|
|
kSpawnedEvent=PtEventType.kSpawned # [1]=spawner, [2]=spawnee (usually avatar)
|
|
|
|
kClickDragEvent=PtEventType.kClickDrag # not used yet
|
|
|
|
kOfferLinkingBook=PtEventType.kOfferLinkingBook # [1]=offerer, [2]=link panel ID of age offered
|
|
|
|
|
|
|
|
|
|
|
|
# OnNotify Var Event Data Types
|
|
|
|
kVarNumberType=PtNotifyDataType.kFloat
|
|
|
|
kVarKeyType=PtNotifyDataType.kKey
|
|
|
|
# OnNotify MultiStageEvent - what event types
|
|
|
|
kEnterStage=PtMultiStageEventType.kEnterStage
|
|
|
|
kBeginingOfLoop=PtMultiStageEventType.kBeginingOfLoop
|
|
|
|
kAdvanceNextStage=PtMultiStageEventType.kAdvanceNextStage
|
|
|
|
kRegressPrevStage=PtMultiStageEventType.kRegressPrevStage
|
|
|
|
# Behavior - gotoStage
|
|
|
|
kStageExitBrain=-1 # sending ptAttribBehavior to stage -1 will exit brain
|
|
|
|
|
|
|
|
# OnGUINotify Control Types
|
|
|
|
kDialog=1
|
|
|
|
kButton=2
|
|
|
|
kDraggable=3
|
|
|
|
kListBox=4
|
|
|
|
kTextBox=5
|
|
|
|
kEditBox=6
|
|
|
|
kUpDownPair=7
|
|
|
|
kKnob=8
|
|
|
|
kDragBar=9
|
|
|
|
kCheckBox=10
|
|
|
|
kRadioGroup=11
|
|
|
|
kDynamicTextControl=12
|
|
|
|
kMultiLineEdit=13
|
|
|
|
# GUIControlListBox String Justify Types
|
|
|
|
kLeftJustify=1
|
|
|
|
kRightJustify=2
|
|
|
|
# GUIControlListBox String inherit flag
|
|
|
|
kNoInherit=0
|
|
|
|
kInheritFromNormal=1
|
|
|
|
kInheritFromSelect=2
|
|
|
|
kSelectDetermined=3
|
|
|
|
kSelectUseGUIColor=4
|
|
|
|
# GUIControlMultiLineEdit style flags (additive)
|
|
|
|
kFontBold=1
|
|
|
|
kFontItalic=2
|
|
|
|
kFontShadowed=4
|
|
|
|
|
|
|
|
# OnGUINotify Event Types
|
|
|
|
kShowHide=1 # show or hide change (only on kDialog)
|
|
|
|
kAction=2 # kButton clicked, kListBox item clicked on, kEditBox hit enter
|
|
|
|
kValueChanged=3 # value changed in control (could be from kUpDownPair,kKnob,kCheckBox,kRadioGroup
|
|
|
|
kDialogLoaded=4 # the dialog has just been loaded
|
|
|
|
kFocusChange=5 # the focus changed from one control to another, or none, within the dialog
|
|
|
|
kExitMode = 6 # Modal dialog received an exit mode command
|
|
|
|
kInterestingEvent = 7 # an interesting event happened
|
|
|
|
|
|
|
|
# OnRoomLoad 'what' types
|
|
|
|
kLoaded=1
|
|
|
|
kUnloaded=2
|
|
|
|
|
|
|
|
# Clothing group Types and clothing types
|
|
|
|
kMaleClothingGroup=0
|
|
|
|
kFemaleClothingGroup=1
|
|
|
|
kAnyClothingItem=-1
|
|
|
|
kPantsClothingItem=0
|
|
|
|
kShirtClothingItem=1
|
|
|
|
kLeftHandClothingItem=2
|
|
|
|
kRightHandClothingItem=3
|
|
|
|
kFaceClothingItem=4
|
|
|
|
kHairClothingItem=5
|
|
|
|
kLeftFootClothingItem=6
|
|
|
|
kRightFootClothingItem=7
|
|
|
|
kAccessoryClothingItem=8
|
|
|
|
|
|
|
|
#Debug print levels
|
|
|
|
kDebugDumpLevel = 1
|
|
|
|
kWarningLevel = 2
|
|
|
|
kErrorLevel = 3
|
|
|
|
kAssertLevel = 4
|
|
|
|
|
|
|
|
|
|
|
|
def PtAssert(cond, msg):
|
|
|
|
"Plasma assert. Just like the Python one but we can set it to NOP in release"
|
|
|
|
assert cond,msg
|
|
|
|
|
|
|
|
def PtDebugPrint(*msgs,**keywords):
|
|
|
|
"Plasma debug print. Will be NOP'd when released"
|
|
|
|
try:
|
|
|
|
level = keywords['level']
|
|
|
|
except LookupError:
|
|
|
|
level = kErrorLevel
|
|
|
|
if level >= PtGetPythonLoggingLevel():
|
|
|
|
if level == 4:
|
|
|
|
PtAssert(0,msgs[0])
|
|
|
|
else:
|
|
|
|
for msg in msgs:
|
|
|
|
print msg
|
|
|
|
|
|
|
|
def PtGetObjectName(obj):
|
|
|
|
"Given a ptSceneobject, return its name"
|
|
|
|
if isinstance(obj,ptSceneobject):
|
|
|
|
if type(obj.getKey()) != type(None):
|
|
|
|
return obj.getKey().getName()
|
|
|
|
return "nil"
|
|
|
|
|
|
|
|
# add an event that is in the form of a list
|
|
|
|
# ...to a notify message
|
|
|
|
def PtAddEvent(notify,event):
|
|
|
|
"Add an event of any type to a ptNotify message object"
|
|
|
|
if type(event) != type([]):
|
|
|
|
print "Unrecognized event record structure"
|
|
|
|
return
|
|
|
|
if event[0] == kCollisionEvent:
|
|
|
|
notify.addCollisionEvent(event[1],event[2].getKey(),event[3].getKey())
|
|
|
|
elif event[0] == kPickedEvent:
|
|
|
|
notify.addPickEvent(event[1],event[2].getKey(),event[3].getKey(),event[4])
|
|
|
|
elif event[0] == kControlKeyEvent:
|
|
|
|
notify.addControlKeyEvent(event[1],event[2])
|
|
|
|
elif event[0] == kVariableEvent:
|
|
|
|
if event[2] == PtNotifyDataType.kFloat:
|
|
|
|
notify.addVarFloat(event[1],event[3])
|
|
|
|
elif event[2] == PtNotifyDataType.kInt:
|
|
|
|
notify.addVarInt(event[1],event[3])
|
|
|
|
elif event[2] == PtNotifyDataType.kNull:
|
|
|
|
notify.addVarNull(event[1])
|
|
|
|
elif event[2] == kVarKeyType:
|
|
|
|
notify.addVarKey(event[1],event[3])
|
|
|
|
elif event[0] == kFacingEvent:
|
|
|
|
notify.addFacingEvent(event[1],event[2].getKey(),event[3].getKey(),event[4])
|
|
|
|
elif event[0] == kContainedEvent:
|
|
|
|
notify.addContainerEvent(event[1],event[2].getKey(),event[3].getKey())
|
|
|
|
elif event[0] == kActivateEvent:
|
|
|
|
notify.addActivateEvent(event[1],event[2])
|
|
|
|
elif event[0] == kCallbackEvent:
|
|
|
|
notify.addCallbackEvent(event[1])
|
|
|
|
elif event[0] == kResponderStateEvent:
|
|
|
|
notify.addResponderState(event[1])
|
|
|
|
else:
|
|
|
|
print "Unrecognized event type %d" % (event[0])
|
|
|
|
|
|
|
|
# add a list of events into a ptNotify message
|
|
|
|
def PtAddEvents(notify, events):
|
|
|
|
"Add a list of events to a ptNotify message object"
|
|
|
|
if type(events) == type([]):
|
|
|
|
for event in events:
|
|
|
|
PtAddEvent(notify,event)
|
|
|
|
|
|
|
|
# find the avatar in event record list
|
|
|
|
def PtFindAvatar(events):
|
|
|
|
"Find the avatar in one of the event records"
|
|
|
|
for event in events:
|
|
|
|
if event[0]==kCollisionEvent or event[0]==kPickedEvent or event[0]==kFacingEvent or event[0]==kContainedEvent or event[0]==kSpawnedEvent:
|
|
|
|
return event[2]
|
|
|
|
if event[0] == kMultiStageEvent:
|
|
|
|
return event[3]
|
|
|
|
# didn't find one
|
|
|
|
return None
|
|
|
|
|
|
|
|
####################################
|
|
|
|
# Exceptions
|
|
|
|
####################################
|
|
|
|
import exceptions
|
|
|
|
class ptResponderStateError(exceptions.Exception):
|
|
|
|
def __init__(self,args=None):
|
|
|
|
self.args = args
|
|
|
|
|
|
|
|
#
|
|
|
|
# Attributes that will be exposed in Max to be filled in by <someone>
|
|
|
|
|
|
|
|
####################################
|
|
|
|
# base class for all attributes
|
|
|
|
####################################
|
|
|
|
# (This makes it easy to find all the attributes in a module)
|
|
|
|
class ptAttribute:
|
|
|
|
def __init__(self,id,name, vislistid = -1, visliststates = []):
|
|
|
|
self.id = id
|
|
|
|
self.name = name
|
|
|
|
self.vis_id = vislistid
|
|
|
|
self.vis_states = visliststates
|
|
|
|
|
|
|
|
def setVisInfo(self, id, stateslist):
|
|
|
|
self.vis_id = id
|
|
|
|
self.vis_states = stateslist
|
|
|
|
|
|
|
|
def getVisInfo(self):
|
|
|
|
return (self.vis_id, self.vis_states)
|
|
|
|
|
|
|
|
# base class for all list attributes
|
|
|
|
# (This makes it easy to find all the attributes that are a list)
|
|
|
|
class ptAttributeList(ptAttribute):
|
|
|
|
def __init__(self,id,name):
|
|
|
|
ptAttribute.__init__(self,id,name)
|
|
|
|
|
|
|
|
# Boolean attribute (Checkbox)
|
|
|
|
class ptAttribBoolean(ptAttribute):
|
|
|
|
def __init__(self,id,name=None, default=0):
|
|
|
|
ptAttribute.__init__(self,id,name)
|
|
|
|
self.value = default
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id,self.name,1,self.value)
|
|
|
|
|
|
|
|
# Integer attribute (Spinner)
|
|
|
|
class ptAttribInt(ptAttribute):
|
|
|
|
def __init__(self,id,name=None,default=0,rang=None):
|
|
|
|
ptAttribute.__init__(self,id,name)
|
|
|
|
self.value = default
|
|
|
|
self.rang = rang
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id,self.name,2,self.value,self.rang)
|
|
|
|
|
|
|
|
# Floating point number attribute (Spinner)
|
|
|
|
class ptAttribFloat(ptAttribute):
|
|
|
|
def __init__(self,id,name=None,default=0.0,rang=None):
|
|
|
|
ptAttribute.__init__(self,id,name)
|
|
|
|
self.value = default
|
|
|
|
self.rang = rang
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id,self.name,3,self.value,self.rang)
|
|
|
|
|
|
|
|
# String attribute (Edit box)
|
|
|
|
class ptAttribString(ptAttribute):
|
|
|
|
def __init__(self,id,name=None,default=""):
|
|
|
|
ptAttribute.__init__(self,id,name)
|
|
|
|
self.value = default
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id,self.name,4,self.value)
|
|
|
|
|
|
|
|
# Drop-down list attribute (Drop-down list combo box)
|
|
|
|
class ptAttribDropDownList(ptAttribute):
|
|
|
|
def __init__(self,id,name=None,options=None):
|
|
|
|
ptAttribute.__init__(self,id,name)
|
|
|
|
self.options = options
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id,self.name,20,self.options)
|
|
|
|
|
|
|
|
# Sceneobject attribute (pick single sceneobject box)
|
|
|
|
class ptAttribSceneobject(ptAttribute):
|
|
|
|
def __init__(self,id,name=None,netForce=0):
|
|
|
|
ptAttribute.__init__(self,id,name)
|
|
|
|
self.value = None
|
|
|
|
self.sceneobject = None
|
|
|
|
self.netForce = netForce
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id,self.name,5)
|
|
|
|
def __setvalue__(self,value):
|
|
|
|
if self.netForce:
|
|
|
|
value.netForce(1)
|
|
|
|
self.value = value
|
|
|
|
self.sceneobject = self.value
|
|
|
|
|
|
|
|
# Sceneobject list attribute (pick multiple sceneobjects box)
|
|
|
|
class ptAttribSceneobjectList(ptAttributeList):
|
|
|
|
def __init__(self,id,name=None,byObject=0,netForce=0):
|
|
|
|
ptAttributeList.__init__(self,id,name)
|
|
|
|
self.value = [] # start as an empty list
|
|
|
|
self.sceneobject = self.value
|
|
|
|
self.netForce = netForce
|
|
|
|
if byObject:
|
|
|
|
self.byObject = {}
|
|
|
|
else:
|
|
|
|
self.byObject = None
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id,self.name,6)
|
|
|
|
def __setvalue__(self,value):
|
|
|
|
if self.netForce:
|
|
|
|
value.netForce(1)
|
|
|
|
self.value.append(value)
|
|
|
|
if type(self.byObject) == type({}):
|
|
|
|
name = value.getName()
|
|
|
|
self.byObject[name] = value
|
|
|
|
|
|
|
|
# attribute list of keys
|
|
|
|
class ptAttributeKeyList(ptAttributeList):
|
|
|
|
def __init__(self,id,name=None,byObject=0,netForce=0):
|
|
|
|
ptAttributeList.__init__(self,id,name)
|
|
|
|
self.value = []
|
|
|
|
self.netForce = netForce
|
|
|
|
if byObject:
|
|
|
|
self.byObject = {}
|
|
|
|
else:
|
|
|
|
self.byObject = None
|
|
|
|
def enable(self,objectName=None):
|
|
|
|
if self.value != None:
|
|
|
|
if type(objectName) != type(None) and type(self.byObject) != type(None):
|
|
|
|
pkey = self.byObject[objectName]
|
|
|
|
if self.netForce:
|
|
|
|
pkey.netForce(1)
|
|
|
|
pkey.enable()
|
|
|
|
elif type(self.value)==type([]):
|
|
|
|
for pkey in self.value:
|
|
|
|
if self.netForce:
|
|
|
|
pkey.netForce(1)
|
|
|
|
pkey.enable()
|
|
|
|
else:
|
|
|
|
if self.netForce:
|
|
|
|
self.value.netForce(1)
|
|
|
|
self.value.enable()
|
|
|
|
def disable(self,objectName=None):
|
|
|
|
if self.value != None:
|
|
|
|
if type(objectName) != type(None) and type(self.byObject) != type(None):
|
|
|
|
pkey = self.byObject[objectName]
|
|
|
|
if self.netForce:
|
|
|
|
pkey.netForce(1)
|
|
|
|
pkey.disable()
|
|
|
|
elif type(self.value)==type([]):
|
|
|
|
for pkey in self.value:
|
|
|
|
if self.netForce:
|
|
|
|
pkey.netForce(1)
|
|
|
|
pkey.disable()
|
|
|
|
else:
|
|
|
|
if self.netForce:
|
|
|
|
self.value.netForce(1)
|
|
|
|
self.value.disable()
|
|
|
|
def __setvalue__(self,value):
|
|
|
|
if self.netForce:
|
|
|
|
value.netForce(1)
|
|
|
|
self.value.append(value)
|
|
|
|
if type(self.byObject) == type({}):
|
|
|
|
name = value.getName()
|
|
|
|
self.byObject[name] = value
|
|
|
|
|
|
|
|
# Activator attribute (pick activator types box)
|
|
|
|
class ptAttribActivator(ptAttributeKeyList):
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id,self.name,8)
|
|
|
|
def enableActivator(self):
|
|
|
|
for key in self.value:
|
|
|
|
key.getSceneObject().physics.enable()
|
|
|
|
def disableActivator(self):
|
|
|
|
for key in self.value:
|
|
|
|
key.getSceneObject().physics.disable()
|
|
|
|
def volumeSensorIgnoreExtraEnters(self,state):
|
|
|
|
for key in self.value:
|
|
|
|
key.getSceneObject().volumeSensorIgnoreExtraEnters(state)
|
|
|
|
|
|
|
|
# Activator attribute (pick activator types box)
|
|
|
|
class ptAttribActivatorList(ptAttributeKeyList):
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id,self.name,7)
|
|
|
|
|
|
|
|
# Responder attribute (pick responder types box)
|
|
|
|
class ptAttribResponder(ptAttributeKeyList):
|
|
|
|
def __init__(self,id,name=None,statelist=None,byObject=0,netForce=0):
|
|
|
|
ptAttributeKeyList.__init__(self,id,name,byObject,netForce)
|
|
|
|
self.state_list = statelist
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id,self.name,9)
|
|
|
|
def run(self,key,state=None,events=None,avatar=None,objectName=None,netForce=0,netPropagate=1,fastforward=0):
|
|
|
|
# has the value been set?
|
|
|
|
if type(self.value) != type(None):
|
|
|
|
nt = ptNotify(key)
|
|
|
|
nt.clearReceivers()
|
|
|
|
# see if the value is a list or byObject or a single
|
|
|
|
if type(objectName) != type(None) and type(self.byObject) != type(None):
|
|
|
|
nt.addReceiver(self.byObject[objectName])
|
|
|
|
elif type(self.value)==type([]):
|
|
|
|
for resp in self.value:
|
|
|
|
nt.addReceiver(resp)
|
|
|
|
else:
|
|
|
|
nt.addReceiver(self.value)
|
|
|
|
if not netPropagate:
|
|
|
|
nt.netPropagate(0)
|
|
|
|
# ptNotify defaults to netPropagate=1
|
|
|
|
if netForce or self.netForce:
|
|
|
|
nt.netForce(1)
|
|
|
|
# see if the state is specified
|
|
|
|
if type(state) == type(0):
|
|
|
|
raise ptResponderStateError,"Specifying state as a number is no longer supported"
|
|
|
|
elif type(state) == type(''):
|
|
|
|
if type(self.state_list) != type(None):
|
|
|
|
try:
|
|
|
|
idx = self.state_list.index(state)
|
|
|
|
nt.addResponderState(idx)
|
|
|
|
except ValueError:
|
|
|
|
raise ptResponderStateError, "There is no state called '%s'"%(state)
|
|
|
|
else:
|
|
|
|
raise ptResponderStateError,"There is no state list provided"
|
|
|
|
# see if there are events to pass on
|
|
|
|
if type(events) != type(None):
|
|
|
|
PtAddEvents(nt,events)
|
|
|
|
if type(avatar) != type(None):
|
|
|
|
nt.addCollisionEvent(1,avatar.getKey(),avatar.getKey())
|
|
|
|
if fastforward:
|
|
|
|
nt.setType(PtNotificationType.kResponderFF)
|
|
|
|
# if fast forwarding, then only do it on the local client
|
|
|
|
nt.netPropagate(0)
|
|
|
|
nt.netForce(0)
|
|
|
|
nt.setActivate(1.0)
|
|
|
|
nt.send()
|
|
|
|
def setState(self,key,state,objectName=None,netForce=0,netPropagate=1):
|
|
|
|
# has the value been set?
|
|
|
|
if type(self.value) != type(None):
|
|
|
|
nt = ptNotify(key)
|
|
|
|
nt.clearReceivers()
|
|
|
|
# see if the value is a list or byObject or a single
|
|
|
|
if type(objectName) != type(None) and type(self.byObject) != type(None):
|
|
|
|
nt.addReceiver(self.byObject[objectName])
|
|
|
|
elif type(self.value)==type([]):
|
|
|
|
for resp in self.value:
|
|
|
|
nt.addReceiver(resp)
|
|
|
|
else:
|
|
|
|
nt.addReceiver(self.value)
|
|
|
|
if not netPropagate:
|
|
|
|
nt.netPropagate(0)
|
|
|
|
# ptNotify defaults to netPropagate=1
|
|
|
|
if netForce or self.netForce:
|
|
|
|
nt.netForce(1)
|
|
|
|
# see if the state is specified
|
|
|
|
if type(state) == type(0):
|
|
|
|
raise ptResponderStateError,"Specifying state as a number is no longer supported"
|
|
|
|
elif type(state) == type(''):
|
|
|
|
if type(self.state_list) != type(None):
|
|
|
|
try:
|
|
|
|
idx = self.state_list.index(state)
|
|
|
|
nt.addResponderState(idx)
|
|
|
|
except ValueError:
|
|
|
|
raise ptResponderStateError, "There is no state called '%s'"%(state)
|
|
|
|
else:
|
|
|
|
raise ptResponderStateError,"There is no state list provided"
|
|
|
|
# see if there are events to pass on
|
|
|
|
nt.setType(PtNotificationType.kResponderChangeState)
|
|
|
|
nt.setActivate(1.0)
|
|
|
|
nt.send()
|
|
|
|
|
|
|
|
def getState(self):
|
|
|
|
if (type(self.value) != type(None)):
|
|
|
|
if type(self.value)==type([]):
|
|
|
|
for resp in self.value:
|
|
|
|
obj = resp.getSceneObject()
|
|
|
|
idx = obj.getResponderState()
|
|
|
|
curState = self.state_list[idx]
|
|
|
|
return curState
|
|
|
|
else:
|
|
|
|
obj = self.value.getSceneObject()
|
|
|
|
idx = obj.getResponderState()
|
|
|
|
curState = self.state_list[idx]
|
|
|
|
return curState
|
|
|
|
|
|
|
|
|
|
|
|
# Responder attribute List
|
|
|
|
class ptAttribResponderList(ptAttribResponder):
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id,self.name,10)
|
|
|
|
|
|
|
|
# Activator attribute (pick activator types box)
|
|
|
|
class ptAttribNamedActivator(ptAttribActivator):
|
|
|
|
def getdef(self):
|
|
|
|
# get attribute as a string, then we will turn it into an activator later
|
|
|
|
return (self.id,self.name,4,self.value)
|
|
|
|
|
|
|
|
# Responder attribute (pick responder types box)
|
|
|
|
class ptAttribNamedResponder(ptAttribResponder):
|
|
|
|
def getdef(self):
|
|
|
|
# get attribute as a string, then we will turn it into an responder later
|
|
|
|
return (self.id,self.name,4,self.value)
|
|
|
|
|
|
|
|
# DynamicText attribute pick button
|
|
|
|
class ptAttribDynamicMap(ptAttribute):
|
|
|
|
def __init__(self,id,name=None,netForce=0):
|
|
|
|
ptAttribute.__init__(self,id,name)
|
|
|
|
self.value = None
|
|
|
|
self.textmap = None
|
|
|
|
self.netForce = netForce
|
|
|
|
# this is to set the value via method (only called if defined)
|
|
|
|
def __setvalue__(self,value):
|
|
|
|
# has a ptDynamicText already been made
|
|
|
|
try:
|
|
|
|
self.textmap.addKey(value)
|
|
|
|
except AttributeError:
|
|
|
|
self.textmap = ptDynamicMap(value)
|
|
|
|
if self.netForce:
|
|
|
|
self.textmap.netForce(1)
|
|
|
|
self.value = self.textmap
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id,self.name,11)
|
|
|
|
|
|
|
|
# a GUI Dialogbox attribute
|
|
|
|
class ptAttribGUIDialog(ptAttribute):
|
|
|
|
def __init__(self,id,name=None):
|
|
|
|
ptAttribute.__init__(self,id,name)
|
|
|
|
self.dialog = None
|
|
|
|
self.value = None
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id,self.name,12)
|
|
|
|
def __setvalue__(self,value):
|
|
|
|
self.dialog = ptGUIDialog(value)
|
|
|
|
self.value = self.dialog
|
|
|
|
|
|
|
|
# a Exclude region attribute
|
|
|
|
kExRegRelease = 0
|
|
|
|
kExRegClear = 1
|
|
|
|
class ptAttribExcludeRegion(ptAttribute):
|
|
|
|
def __init__(self,id,name=None):
|
|
|
|
ptAttribute.__init__(self,id,name)
|
|
|
|
self.value = None
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id,self.name,13)
|
|
|
|
def clear(self,sender):
|
|
|
|
if type(self.value) != type(None):
|
|
|
|
PtExcludeRegionSet(sender,self.value,kExRegClear)
|
|
|
|
def release(self,sender):
|
|
|
|
if type(self.value) != type(None):
|
|
|
|
PtExcludeRegionSet(sender,self.value,kExRegRelease)
|
|
|
|
def enable(self):
|
|
|
|
self.sceneobject.physics.enable()
|
|
|
|
def disable(self):
|
|
|
|
self.sceneobject.physics.disable()
|
|
|
|
def clearNow(self,sender):
|
|
|
|
if type(self.value) != type(None):
|
|
|
|
PtExcludeRegionSetNow(sender,self.value,kExRegClear)
|
|
|
|
def releaseNow(self,sender):
|
|
|
|
if type(self.value) != type(None):
|
|
|
|
PtExcludeRegionSetNow(sender,self.value,kExRegRelease)
|
|
|
|
|
|
|
|
class ptAttribWaveSet(ptAttribute):
|
|
|
|
def __init__(self,id,name=None):
|
|
|
|
ptAttribute.__init__(self,id,name)
|
|
|
|
self.value = None
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id,self.name,19)
|
|
|
|
def __setvalue__(self,value):
|
|
|
|
self.waveset = ptWaveSet(value)
|
|
|
|
self.value = self.waveset
|
|
|
|
|
|
|
|
class ptAttribSwimCurrent(ptAttribute):
|
|
|
|
def __init__(self,id,name=None):
|
|
|
|
ptAttribute.__init__(self,id,name)
|
|
|
|
self.value = None
|
|
|
|
self.current = None
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id,self.name,21)
|
|
|
|
def __setvalue__(self,value):
|
|
|
|
self.current = ptSwimCurrentInterface(value)
|
|
|
|
self.value = self.current
|
|
|
|
|
|
|
|
class ptAttribClusterList(ptAttributeList):
|
|
|
|
def __init__(self,id,name=None):
|
|
|
|
ptAttribute.__init__(self,id,name)
|
|
|
|
self.value = []
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id,self.name,22)
|
|
|
|
def __setvalue__(self,value):
|
|
|
|
self.value.append(ptCluster(value))
|
|
|
|
|
|
|
|
# special class for byObject that gets the parents name of the values when someone first asks for them
|
|
|
|
class ptByAnimObject(dict):
|
|
|
|
def __init__(self):
|
|
|
|
dict.__init__(self)
|
|
|
|
self.gotParentKeys = 0
|
|
|
|
def getParentKeys(self):
|
|
|
|
# if we haven't got the parent keys yet, then add them to the dict
|
|
|
|
if not self.gotParentKeys:
|
|
|
|
for anim in dict.values(self):
|
|
|
|
# get the animation target key
|
|
|
|
aKey = anim.getFirstKey()
|
|
|
|
if aKey:
|
|
|
|
# get its parent key
|
|
|
|
pKey = aKey.getParentKey()
|
|
|
|
if pKey:
|
|
|
|
# only add this key once
|
|
|
|
if not pKey.getName() in self:
|
|
|
|
dict.__setitem__(self,pKey.getName(),anim)
|
|
|
|
self.gotParentKeys = 1
|
|
|
|
def __getitem__(self,key):
|
|
|
|
self.getParentKeys()
|
|
|
|
return dict.__getitem__(self,key)
|
|
|
|
def keys(self):
|
|
|
|
self.getParentKeys()
|
|
|
|
return dict.keys(self)
|
|
|
|
def get(self, key, *args):
|
|
|
|
self.getParentKeys()
|
|
|
|
return dict.get(self, key, *args)
|
|
|
|
|
|
|
|
# an Animation attribute
|
|
|
|
kAnimEaseNoEase = 0
|
|
|
|
kAnimEaseConstAccel = 1
|
|
|
|
kAnimEaseSpline = 2
|
|
|
|
class ptAttribAnimation(ptAttribute):
|
|
|
|
def __init__(self,id,name=None,byObject=0,netForce=0):
|
|
|
|
ptAttribute.__init__(self,id,name)
|
|
|
|
self.value = None
|
|
|
|
self.animName = ""
|
|
|
|
self.netForce = netForce
|
|
|
|
if byObject:
|
|
|
|
self.byObject = ptByAnimObject()
|
|
|
|
else:
|
|
|
|
self.byObject = None
|
|
|
|
# this is to set the value via method (only called if defined)
|
|
|
|
def __setvalue__(self,value):
|
|
|
|
# has a ptAnimation already been made
|
|
|
|
if type(value) == type(""):
|
|
|
|
self.animName = value
|
|
|
|
try:
|
|
|
|
self.animation.setAnimName(value)
|
|
|
|
# then if there are animations by object then set those, too
|
|
|
|
if isinstance(self.byObject,ptByAnimObject):
|
|
|
|
for anim in self.byObject.values():
|
|
|
|
anim.setAnimName(value)
|
|
|
|
except AttributeError:
|
|
|
|
self.animation = ptAnimation()
|
|
|
|
self.animation.setAnimName(value)
|
|
|
|
if self.netForce:
|
|
|
|
self.animation.netForce(1)
|
|
|
|
self.value = self.animation
|
|
|
|
elif isinstance(value,ptKey):
|
|
|
|
try:
|
|
|
|
self.animation.addKey(value)
|
|
|
|
except AttributeError:
|
|
|
|
self.animation = ptAnimation()
|
|
|
|
self.animation.addKey(value)
|
|
|
|
if self.netForce:
|
|
|
|
self.animation.netForce(1)
|
|
|
|
self.value = self.animation
|
|
|
|
if isinstance(self.byObject,ptByAnimObject):
|
|
|
|
singleAnim = ptAnimation()
|
|
|
|
singleAnim.addKey(value)
|
|
|
|
if self.netForce:
|
|
|
|
singleAnim.netForce(1)
|
|
|
|
# set name if known
|
|
|
|
if self.animName != "":
|
|
|
|
singleAnim.setAnimName(self.animName)
|
|
|
|
name = value.getName()
|
|
|
|
self.byObject[name] = singleAnim
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id,self.name,14)
|
|
|
|
|
|
|
|
# a Behavior attribute
|
|
|
|
class ptAttribBehavior(ptAttribute):
|
|
|
|
"Attribute for specifying behaviors, including multistage Behaviors"
|
|
|
|
def __init__(self,id,name=None,netForce=1,netProp=1):
|
|
|
|
ptAttribute.__init__(self,id,name)
|
|
|
|
self.value = None
|
|
|
|
self.netForce = netForce
|
|
|
|
self.netProp = netProp
|
|
|
|
def __setvalue__(self,value):
|
|
|
|
self.value = value
|
|
|
|
PtSetBehaviorNetFlags(self.value, self.netForce, self.netProp)
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id,self.name,15)
|
|
|
|
def run(self,avatar):
|
|
|
|
"This will run the behavior on said avatar"
|
|
|
|
if type(self.value) != type(None):
|
|
|
|
if self.netForce:
|
|
|
|
self.value.netForce(1)
|
|
|
|
avatar.avatar.netForce(1)
|
|
|
|
avatar.avatar.runBehavior(self.value,self.netForce,self.netProp)
|
|
|
|
def nextStage(self,avatar,transitionTime=1.0,setTimeFlag=1,newTime=0.0,dirFlag=0,isForward=1):
|
|
|
|
"This will go to the next stage in a multi-stage behavior"
|
|
|
|
if type(self.value) != type(None):
|
|
|
|
if self.netForce:
|
|
|
|
self.value.netForce(1)
|
|
|
|
avatar.avatar.netForce(1)
|
|
|
|
avatar.avatar.nextStage(self.value,transitionTime,setTimeFlag,newTime,dirFlag,isForward,self.netForce)
|
|
|
|
def previousStage(self,avatar,transitionTime=1.0,setTimeFlag=1,newTime=0.0,dirFlag=0,isForward=1):
|
|
|
|
"This will go to the next stage in a multi-stage behavior"
|
|
|
|
if type(self.value) != type(None):
|
|
|
|
if self.netForce:
|
|
|
|
self.value.netForce(1)
|
|
|
|
avatar.avatar.netForce(1)
|
|
|
|
avatar.avatar.previousStage(self.value,transitionTime,setTimeFlag,newTime,dirFlag,isForward,self.netForce)
|
|
|
|
def gotoStage(self,avatar,stage,transitionTime=1.0,setTimeFlag=1,newTime=0.0,dirFlag=0,isForward=1):
|
|
|
|
"This will go to the next stage in a multi-stage behavior"
|
|
|
|
if type(self.value) != type(None):
|
|
|
|
if self.netForce:
|
|
|
|
self.value.netForce(1)
|
|
|
|
avatar.avatar.netForce(1)
|
|
|
|
avatar.avatar.gotoStage(self.value,stage,transitionTime,setTimeFlag,newTime,dirFlag,isForward,self.netForce)
|
|
|
|
def setLoopCount(self,stage,loopCount):
|
|
|
|
"This will set the loop count for a stage"
|
|
|
|
if type(self.value) != type(None):
|
|
|
|
PtSetBehaviorLoopCount(self.value,stage,loopCount,self.netForce)
|
|
|
|
|
|
|
|
# Material texture attribute pick button
|
|
|
|
class ptAttribMaterial(ptAttribute):
|
|
|
|
def __init__(self,id,name=None):
|
|
|
|
ptAttribute.__init__(self,id,name)
|
|
|
|
self.value = None
|
|
|
|
self.map = None
|
|
|
|
# this is to set the value via method (only called if defined)
|
|
|
|
def __setvalue__(self,value):
|
|
|
|
self.map = ptImage(value)
|
|
|
|
self.value = self.map
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id,self.name,16)
|
|
|
|
|
|
|
|
class ptAttribMaterialAnimation(ptAttribute):
|
|
|
|
def __init__(self, id, name = None):
|
|
|
|
ptAttribute.__init__(self, id, name)
|
|
|
|
self.value = None
|
|
|
|
self.animation = None
|
|
|
|
|
|
|
|
def __setvalue__(self, value):
|
|
|
|
if type(self.animation) == type(None):
|
|
|
|
self.animation = ptAnimation()
|
|
|
|
self.animation.addKey(value)
|
|
|
|
self.value = self.animation
|
|
|
|
else:
|
|
|
|
self.animation.addKey(value)
|
|
|
|
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id, self.name, 23)
|
|
|
|
|
|
|
|
|
|
|
|
# Sceneobject list attribute (pick multiple sceneobjects box)
|
|
|
|
class ptAttribMaterialList(ptAttributeList):
|
|
|
|
def __init__(self,id,name=None,byObject=0,netForce=0):
|
|
|
|
ptAttributeList.__init__(self,id,name)
|
|
|
|
self.value = [] # start as an empty list
|
|
|
|
self.map = self.value
|
|
|
|
self.netForce = netForce
|
|
|
|
if byObject:
|
|
|
|
self.byObject = {}
|
|
|
|
else:
|
|
|
|
self.byObject = None
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id,self.name,6)
|
|
|
|
def __setvalue__(self,value):
|
|
|
|
if self.netForce:
|
|
|
|
value.netForce(1)
|
|
|
|
self.value.append(value)
|
|
|
|
if type(self.byObject) == type({}):
|
|
|
|
name = value.getName()
|
|
|
|
self.byObject[name] = value
|
|
|
|
|
|
|
|
# a GUI PopUpMenu attribute
|
|
|
|
class ptAttribGUIPopUpMenu(ptAttribute):
|
|
|
|
def __init__(self,id,name=None):
|
|
|
|
ptAttribute.__init__(self,id,name)
|
|
|
|
self.value = None
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id,self.name,17)
|
|
|
|
def __setvalue__(self,value):
|
|
|
|
self.menu = ptGUIPopUpMenu(value)
|
|
|
|
self.value = self.menu
|
|
|
|
|
|
|
|
# a GUI Skin attribute
|
|
|
|
class ptAttribGUISkin(ptAttribute):
|
|
|
|
def __init__(self,id,name=None):
|
|
|
|
ptAttribute.__init__(self,id,name)
|
|
|
|
self.value = None
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id,self.name,18)
|
|
|
|
def __setvalue__(self,value):
|
|
|
|
self.skin = ptGUISkin(value)
|
|
|
|
self.value = self.skin
|
|
|
|
|
|
|
|
# a Grass Shader attribute
|
|
|
|
class ptAttribGrassShader(ptAttribute):
|
|
|
|
def __init__(self,id,name=None):
|
|
|
|
ptAttribute.__init__(self,id,name)
|
|
|
|
self.value = None
|
|
|
|
def getdef(self):
|
|
|
|
return (self.id,self.name,24)
|
|
|
|
def __setvalue__(self,value):
|
|
|
|
self.shader = ptGrassShader(value)
|
|
|
|
self.value = self.shader
|
|
|
|
|
|
|
|
|
|
|
|
#
|
|
|
|
# ptModifier - class for creating a Plasma modifier, such as a responder
|
|
|
|
|
|
|
|
# base class
|
|
|
|
class ptModifier:
|
|
|
|
def __init__(self):
|
|
|
|
self.key = None
|
|
|
|
self.SDL = None
|
|
|
|
self.version = 0
|
|
|
|
|
|
|
|
class ptResponder(ptModifier):
|
|
|
|
# this modifier will get a plNotifyMsg as an OnNotify
|
|
|
|
def __init__(self):
|
|
|
|
ptModifier.__init__(self)
|
|
|
|
self.sceneobject = None
|
|
|
|
|
|
|
|
class ptMultiModifier(ptModifier):
|
|
|
|
# this modifier can be attached to multiple object, but only one module
|
|
|
|
def __init__(self):
|
|
|
|
ptModifier.__init__(self)
|