OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3 Commits
79 Branches
23 Tags
171 MiB
 
 
 
 
 
Tree: a363a783c5
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'a363a783c5'
${ noResults }
CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Scripts/Python/plasma/PlasmaTypes.py

820 lines
30 KiB
Raw Blame History

""" *==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/>.
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.kNumber
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] == kVarNumberType:
notify.addVarNumber(event[1],event[3])
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)