def __init__(self, air, zone, name, x, y, z, h, p, r):
DistributedNodeAI.__init__(self, air)
self.name = name
self.air = air
self.seats = [
None,
None,
None,
None,
None,
None]
self.setPos(x, y, z)
self.setHpr(h, p, r)
self.playersSitting = 0
self.myPos = (x, y, z)
self.myHpr = (h, p, r)
self.playerIdList = []
self.checkersZoneId = None
self.generateOtpObject(air.districtId, zone, optionalFields = [
'setX',
'setY',
'setZ',
'setH',
'setP',
'setR'])
self.observers = []
self.allowPickers = []
self.hasPicked = False
self.game = None
self.gameDoId = None
self.isAccepting = True
def generate(self):
DistributedNodeAI.generate(self)
pond = self.air.doId2do.get(self.pondDoId)
if pond:
pond.addTarget(self)
self.centerPoint = FishingTargetGlobals.getTargetCenter(pond.getArea())
self.__updateState()
def delete(self):
self.numBarrels = None
self.mg = None
self.index = None
self.hasReportedAllGone = None
DistributedNodeAI.delete(self)
return
def __init__(self, air, zone, name, x, y, z, h, p, r):
DistributedNodeAI.__init__(self, air)
self.name = name
self.air = air
self.seats = [None,
None,
None,
None,
None,
None]
self.setPos(x, y, z)
self.setHpr(h, p, r)
self.playersSitting = 0
self.myPos = (x, y, z)
self.myHpr = (h, p, r)
self.playerIdList = []
self.checkersZoneId = None
self.generateOtpObject(air.districtId, zone, optionalFields=['setX',
'setY',
'setZ',
'setH',
'setP',
'setR'])
self.observers = []
self.allowPickers = []
self.hasPicked = False
self.game = None
self.gameDoId = None
self.isAccepting = True
return
def __init__(self, air, zone, name, x, y, z, h, p, r):
DistributedNodeAI.__init__(self,air)
self.name = name
self.air = air
self.seats = [None, None, None, None, None, None]
self.setPos(x,y,z)
self.setHpr(h,p,r)
self.playersSitting = 0
self.myPos = (x,y,z)
self.myHpr = (h,p,r)
self.playerIdList = []
self.checkersZoneId = None
self.generateOtpObject(air.districtId, zone, optionalFields = ["setX","setY","setZ", "setH", "setP", "setR"])
self.observers = []
self.allowPickers = []
self.hasPicked = False
self.game = None
self.gameDoId = None
#Will NOT allow boarders once game has begun
self.isAccepting = True
def __init__(self, air):
DistributedNodeAI.__init__(self, air)
self.pondDoId = 0
self.angle = 0
self.radius = 0
self.time = 0
self.centerPoint = None
def delete(self):
self.fsm.requestFinalState()
self.parent = None
self.parentDo = None
del self.board
del self.fsm
DistributedNodeAI.delete(self)
def __init__(self, air, mg, index):
DistributedNodeAI.__init__(self, air)
self.numBarrels = 0
self.dBarrels = []
self.hasReportedAllGone = False
self.index = index
self.mg = mg
def delete(self):
self.fsm.requestFinalState()
self.parent = None
self.parentDo = None
del self.board
del self.fsm
DistributedNodeAI.delete(self)
def __init__(self, air):
DistributedNodeAI.__init__(self, air)
self.pondId = 0
self.angle = 0
self.targetRadius = 0
self.time = 0
self.centerPoint = [0, 0, 0]
def delete(self):
self.fsm.requestFinalState()
self.board.delete()
self.playerSeatPos = None
del self.fsm
DistributedNodeAI.delete(self)
return
def delete(self):
self.fsm.requestFinalState()
self.board.delete()
self.playerSeatPos = None
del self.fsm
DistributedNodeAI.delete(self)
return
def delete(self):
self.fsm.requestFinalState()
self.board.delete()
self.playerSeatPos = None
del self.fsm
#simbase.air.deallocateZone(self.zoneId)
DistributedNodeAI.delete(self)
def __init__(self, mgr):
DistributedNodeAI.__init__(self, mgr.air)
self.mgr = mgr
self.plot = 0
self.ownerIndex = 0
self.ownerDoId = 0
self.owner = None
def __init__(self, air):
DistributedNodeAI.__init__(self, air)
self.pondId = 0
self.angle = 0
self.targetRadius = 0
self.time = 0
self.centerPoint = [0, 0, 0]
def delete(self):
if self.getSuitManager():
if self.getSuitManager().getDrops():
self.getSuitManager().getDrops().remove(self)
self.suitMgr = None
self.tutDrop = None
DistributedNodeAI.delete(self)
def __init__(self, air):
DistributedNodeAI.__init__(self, air)
self.modelPath = ''
self.links = []
self.uniqueId = ''
self.name = PLocalizer.Unknown
self.uidMgr = UniqueIdManager(self.air)
self.builder = GameAreaBuilderAI(self.air, self)
def delete(self):
if self.getSuitManager():
if self.getSuitManager().getDrops():
self.getSuitManager().getDrops().remove(self)
self.suitMgr = None
self.tutDrop = None
DistributedNodeAI.delete(self)
return
def generate(self):
DistributedNodeAI.generate(self)
self.updateState()
if not self.pondId:
return
pond = self.air.doId2do[self.pondId]
pond.addTarget(self)
self.centerPoint = FishingTargetGlobals.getTargetCenter(pond.getArea())
def __init__(self, air, pathIndex):
DistributedNodeAI.__init__(self, air)
self.state = ''
self.stateTimestamp = 0
self.pathIndex = pathIndex
ivalStart = 0
ivalEnd = CityCartGlobals.index2Duration[self.pathIndex]
self.ivalTDisplace = 0
def __init__(self, air):
try:
self.DistributedShopAI_initialized
return
except:
self.DistributedShopAI_initialized = 1
DistributedNodeAI.__init__(self, air)
self.avatars = []
def generate(self):
DistributedNodeAI.generate(self)
self.updateState()
if not self.pondId:
#We dont have a pond ID for some reason...
return
pond = self.air.doId2do[self.pondId]
pond.addTarget(self)
self.centerPoint = FishingTargetGlobals.getTargetCenter(pond.getArea())
def delete(self):
self.fsm.requestFinalState()
self.hood = None
self.state = None
self.toLoc = None
self.fromLoc = None
self.stateChangeTimestamp = None
self.wingType = None
DistributedNodeAI.delete(self)
def announceGenerate(self):
DistributedEntityAI.announceGenerate(self)
DistributedNodeAI.announceGenerate(self)
assert self.cEntity
self.setPos(self.cEntity.getOrigin())
self.setHpr(self.cEntity.getAngles())
pos = self.getPos()
hpr = self.getHpr()
self.d_setPosHpr(pos[0], pos[1], pos[2], hpr[0], hpr[1], hpr[2])
def __init__(self, air, gardenManager, ownerIndex):
DistributedNodeAI.__init__(self, air)
self.gardenManager = gardenManager
self.ownerIndex = ownerIndex
self.plotIndex = None
self.plotType = None
self.pos = None
self.heading = None
self.movie = None
def __init__(self, air, gardenManager, ownerIndex):
DistributedNodeAI.__init__(self, air)
self.gardenManager = gardenManager
self.ownerIndex = ownerIndex
self.plotIndex = None
self.plotType = None
self.pos = None
self.heading = None
self.movie = None
def __init__(self, air, hood, wingType):
DistributedNodeAI.__init__(self, air)
self.hood = hood
self.wingType = wingType
self.state = 0
self.stateChangeTimestamp = 0.0
self.fromLoc = 0
self.toLoc = 0
self.fsm = ClassicFSM('DBFAI', [State('off', self.enterOff, self.exitOff),
State('sit', self.enterSit, self.exitSit),
State('fly', self.enterFly, self.exitFly)],
'off', 'off')
self.fsm.enterInitialState()
def __init__(self, air, parent, name, x, y, z, h, p, r):
DistributedNodeAI.__init__(self, air)
self.name = name
self.air = air
self.setPos(x, y, z)
self.setHpr(h, p, r)
self.myPos = (x, y, z)
self.myHpr = (h, p, r)
self.board = CheckersBoard.CheckersBoard()
self.parent = self.air.doId2do[parent]
self.parentDo = parent
self.wantStart = []
self.playersPlaying = []
self.playersSitting = 0
self.playersTurn = 1
self.movesMade = 0
self.playerNum = 1
self.hasWon = False
self.playersGamePos = [None, None]
self.wantTimer = True
self.timerEnd = 0
self.turnEnd = 0
self.playersObserving = []
self.winLaffPoints = 20
self.movesRequiredToWin = 10
self.zoneId = self.air.allocateZone()
self.generateOtpObject(
air.districtId,
self.zoneId,
optionalFields=['setX', 'setY', 'setZ', 'setH', 'setP', 'setR'])
self.parent.setCheckersZoneId(self.zoneId)
self.startingPositions = [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
[
20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
30, 31
]]
self.kingPositions = [[31, 30, 29, 28], [0, 1, 2, 3]]
self.timerStart = None
self.fsm = ClassicFSM.ClassicFSM('Checkers', [
State.State('waitingToBegin', self.enterWaitingToBegin,
self.exitWaitingToBegin, ['playing']),
State.State('playing', self.enterPlaying, self.exitPlaying,
['gameOver']),
State.State('gameOver', self.enterGameOver, self.exitGameOver,
['waitingToBegin'])
], 'waitingToBegin', 'waitingToBegin')
self.fsm.enterInitialState()
return
def __init__(self, air, parent, name, x, y, z, h, p, r):
DistributedNodeAI.__init__(self, air)
self.name = name
self.air = air
self.setPos(x, y, z)
self.setHpr(h, p, r)
self.myPos = (x, y, z)
self.myHpr = (h, p, r)
self.board = ChineseCheckersBoard.ChineseCheckersBoard()
self.parent = self.air.doId2do[parent]
self.parentDo = parent
self.wantStart = []
self.playersPlaying = []
self.playersSitting = 0
self.playersTurn = 1
self.movesMade = 0
self.playersGamePos = [None, None, None, None, None, None]
self.wantTimer = True
self.timerEnd = 0
self.turnEnd = 0
self.playersObserving = []
self.winLaffPoints = 20
self.movesRequiredToWin = 10
self.zoneId = self.air.allocateZone()
self.generateOtpObject(
air.districtId,
self.zoneId,
optionalFields=['setX', 'setY', 'setZ', 'setH', 'setP', 'setR'])
self.parent.setCheckersZoneId(self.zoneId)
self.startingPositions = [
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
[10, 11, 12, 13, 23, 24, 25, 35, 36, 46],
[65, 75, 76, 86, 87, 88, 98, 99, 100, 101],
[111, 112, 113, 114, 115, 116, 117, 118, 119, 120],
[74, 84, 85, 95, 96, 97, 107, 108, 109, 110],
[19, 20, 21, 22, 32, 33, 34, 44, 45, 55]
]
self.timerStart = None
self.fsm = ClassicFSM.ClassicFSM('ChineseCheckers', [
State.State('waitingToBegin', self.enterWaitingToBegin,
self.exitWaitingToBegin, ['playing']),
State.State('playing', self.enterPlaying, self.exitPlaying,
['gameOver']),
State.State('gameOver', self.enterGameOver, self.exitGameOver,
['waitingToBegin'])
], 'waitingToBegin', 'waitingToBegin')
self.fsm.enterInitialState()
return
def delete(self):
self.fsm.requestFinalState()
self.timerEnd = 0
self.playersSitting = 0
self.resultReady = []
self.wantStart = []
self.activePlayers = []
self.currentTurn = []
self.playerDecks = {}
self.roundResults = {}
self.remainingCards = {}
del self.fsm
DistributedNodeAI.delete(self)
def __init__(self, air, parent, name, x, y, z, h, p, r):
DistributedNodeAI.__init__(self, air)
self.name = name
self.air = air
self.setPos(x, y, z)
self.setHpr(h, p, r)
self.myPos = (x, y, z)
self.myHpr = (h, p, r)
self.board = CheckersBoard.CheckersBoard()
self.parent = self.air.doId2do[parent]
self.parentDo = parent
self.wantStart = []
self.playersPlaying = []
self.playersSitting = 0
self.playersTurn = 1
self.movesMade = 0
self.playerNum = 1
self.hasWon = False
self.playersGamePos = [None, None]
self.wantTimer = True
self.timerEnd = 0
self.turnEnd = 0
self.playersObserving = []
self.winLaffPoints = 20
self.movesRequiredToWin = 10
self.zoneId = self.air.allocateZone()
self.generateOtpObject(
air.districtId, self.zoneId, optionalFields=["setX", "setY", "setZ", "setH", "setP", "setR"]
)
self.parent.setCheckersZoneId(self.zoneId)
self.startingPositions = [
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
[20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31],
]
self.kingPositions = [[31, 30, 29, 28], [0, 1, 2, 3]]
self.timerStart = None
self.fsm = ClassicFSM.ClassicFSM(
"Checkers",
[
State.State("waitingToBegin", self.enterWaitingToBegin, self.exitWaitingToBegin, ["playing"]),
State.State("playing", self.enterPlaying, self.exitPlaying, ["gameOver"]),
State.State("gameOver", self.enterGameOver, self.exitGameOver, ["waitingToBegin"]),
],
"waitingToBegin",
"waitingToBegin",
)
self.fsm.enterInitialState()
def __init__(self, air, zone, name, x, y, z, h, p, r):
DistributedNodeAI.__init__(self, air)
self.name = name
self.zoneId = zone
self.air = air
self.seats = [None, None, None, None, None, None]
self.setPos(x, y, z)
self.setHpr(h, p, r)
self.playersSitting = 0
self.playerIdList = []
self.checkersZoneId = None
self.observers = []
self.allowPickers = []
self.hasPicked = False
self.game = None
self.gameDoId = None
self.isAccepting = True
def delete(self):
# We need to clean up to prevent memory leaks.
taskMgr.removeTasksMatching(self.captureAttemptTaskName)
taskMgr.removeTasksMatching(self.resetTaskName)
taskMgr.removeTasksMatching(self.awardKingTaskName)
self.contesters = []
self.resetHill()
self.d_startCircleAnim(3)
del self.king
del self.kingId
del self.kingOnPoint
del self.primaryContester
del self.contesters
del self.team
del self.mg
del self.resetTaskName
del self.elapsedCaptureTime
del self.captureAttemptTaskName
del self.elapsedCaptureResetTime
del self.state
del self.resetCaptureTime
self.removeNode()
DistributedNodeAI.delete(self)
def __init__(self, air, mg):
DistributedNodeAI.__init__(self, air)
self.mg = mg
self.team = -2
self.resetTaskName = None
self.captureAttemptTaskName = None
self.awardKingTaskName = None
self.elapsedCaptureTime = 0
self.elapsedCaptureResetTime = 0
self.state = CaptureState.IDLE
self.resetCaptureTime = self.RESET_TIME
# The one who has captured this point.
# For free-for-all KOTH.
self.king = None
self.kingId = None
self.kingOnPoint = False
# The Toon that is trying to capture the point.
self.primaryContester = None
# Toons who contesting the capture.
self.contesters = []
def __init__(self, air, zone, name, x, y, z, h, p, r):
DistributedNodeAI.__init__(self, air)
self.name = name
self.zoneId = zone
self.air = air
self.seats = [
None,
None,
None,
None,
None,
None]
self.setPos(x, y, z)
self.setHpr(h, p, r)
self.playersSitting = 0
self.playerIdList = []
self.checkersZoneId = None
self.observers = []
self.allowPickers = []
self.hasPicked = False
self.game = None
self.gameDoId = None
self.isAccepting = True
def __init__(self, air, name):
DistributedNodeAI.__init__(self, air)
self.name = name
self.air = air
self.timerEnd = 0
self.playersSitting = 0
self.resultReady = []
self.waitingOn = []
self.wantStart = []
self.activePlayers = []
self.currentTurn = []
self.playerDecks = {}
self.roundResults = {}
self.remainingCards = {}
self.fsm = ClassicFSM.ClassicFSM('CardJitsu', [
State.State('waitingToBegin', self.enterWaitingToBegin, self.exitWaitingToBegin, ['playing']),
State.State('playing', self.enterPlaying, self.exitPlaying, ['gameOver']),
State.State('gameOver', self.enterGameOver, self.exitGameOver, ['waitingToBegin'])],
'waitingToBegin', 'waitingToBegin')
self.fsm.enterInitialState()
def __init__(self, air):
DistributedNodeAI.__init__(self, air)
def __init__(self, air):
DistributedNodeAI.__init__(self, air)
self.hp = 0
self.maxHp = 0
def delete(self):
DistributedNodeAI.delete(self)
self.game = None
self.gameDoId = None
return
def __init__(self, mgr):
self.mgr = mgr
DistributedNodeAI.__init__(self, self.mgr.air)
self.plot = 0
self.ownerIndex = 0
def generate(self):
DistributedNodeAI.generate(self)
self.updateState()
pond = self.air.doId2do[self.pondId]
pond.addTarget(self)
self.centerPoint = FishingTargetGlobals.getTargetCenter(pond.getArea())
def delete(self):
DistributedNodeAI.delete(self)
def __init__(self, air):
DistributedNodeAI.__init__(self, air)
self.avatar = None
return
def delete(self):
self.fsm.requestFinalState()
self.board.delete()
del self.fsm
DistributedNodeAI.delete(self)
def delete(self):
taskMgr.remove('updateFishingTarget%d' % self.doId)
DistributedNodeAI.delete(self)
def __init__(self, air, parent, name, x, y, z, h, p, r):
DistributedNodeAI.__init__(self, air)
self.name = name
self.air = air
self.setPos(x, y, z)
self.setHpr(h, p, r)
self.myPos = (x, y, z)
self.myHpr = (h, p, r)
self.board = [[0,
0,
0,
0,
0,
0,
0],
[0,
0,
0,
0,
0,
0,
0],
[0,
0,
0,
0,
0,
0,
0],
[0,
0,
0,
0,
0,
0,
0],
[0,
0,
0,
0,
0,
0,
0],
[0,
0,
0,
0,
0,
0,
0]]
self.parent = self.air.doId2do[parent]
self.parentDo = parent
self.wantStart = []
self.playersPlaying = []
self.playersSitting = 0
self.playersTurn = 1
self.movesMade = 0
self.playerNum = 1
self.winDirection = None
self.playersGamePos = [None, None]
self.wantTimer = True
self.timerEnd = 0
self.turnEnd = 0
self.playersObserving = []
self.winLaffPoints = 20
self.movesRequiredToWin = 10
self.zoneId = self.air.allocateZone()
self.generateOtpObject(air.districtId, self.zoneId, optionalFields=['setX',
'setY',
'setZ',
'setH',
'setP',
'setR'])
self.parent.setCheckersZoneId(self.zoneId)
self.timerStart = None
self.fsm = ClassicFSM.ClassicFSM('Checkers', [State.State('waitingToBegin', self.enterWaitingToBegin, self.exitWaitingToBegin, ['playing']), State.State('playing', self.enterPlaying, self.exitPlaying, ['gameOver']), State.State('gameOver', self.enterGameOver, self.exitGameOver, ['waitingToBegin'])], 'waitingToBegin', 'waitingToBegin')
self.fsm.enterInitialState()
def __init__(self, air):
DistributedNodeAI.__init__(self, air)
self.avatars = []
def __init__(self, cr):
DistributedNodeAI.__init__(self, cr)
self.message = ''
self.color = (1, 1, 1)
def __init__(self, air):
DistributedNodeAI.__init__(self, air)
self.air = air
self.plot = None
self.ownerIndex = None
def announceGenerate(self):
DistributedNodeAI.announceGenerate(self)
def delete(self):
DistributedNodeAI.delete(self)
self.game = None
self.gameDoId = None
def delete(self):
del self.avatar
DistributedNodeAI.delete(self)
def __init__(self, air):
DistributedNodeAI.__init__(self, air)
self.suitMgr = None
self.tutDrop = None
def __init__(self, air):
DistributedNodeAI.__init__(self, air)
self.suitMgr = None
self.tutDrop = None
return
def disable(self):
DistributedNodeAI.disable(self)
def __init__(self, air):
DistributedNodeAI.__init__(self, air)
self.plot = 0
self.h = 0
self.pos = (0, 0, 0)
self.ownerIndex = 0
def __init__(self, air, modelPath, name=None, uid=None, links=[]):
DistributedNodeAI.__init__(self, air)
self.modelPath = modelPath
self.links = links
self.uid = uid
self.name = name
def __init__(self, air, parent, name, x, y, z, h, p, r):
DistributedNodeAI.__init__(self, air)
self.name = name
self.air = air
self.setPos(x, y, z)
self.setHpr(h, p, r)
self.myPos = (x, y, z)
self.myHpr = (h, p, r)
self.board = ChineseCheckersBoard.ChineseCheckersBoard()
self.parent = self.air.doId2do[parent]
self.parentDo = parent
self.wantStart = []
self.playersPlaying = []
self.playersSitting = 0
self.playersTurn = 1
self.movesMade = 0
self.playersGamePos = [
None,
None,
None,
None,
None,
None]
self.wantTimer = True
self.timerEnd = 0
self.turnEnd = 0
self.playersObserving = []
self.winLaffPoints = 20
self.movesRequiredToWin = 10
self.zoneId = self.air.allocateZone()
self.generateOtpObject(air.districtId, self.zoneId, optionalFields = [
'setX',
'setY',
'setZ',
'setH',
'setP',
'setR'])
self.parent.setCheckersZoneId(self.zoneId)
self.startingPositions = [
[
0,
1,
2,
3,
4,
5,
6,
7,
8,
9],
[
10,
11,
12,
13,
23,
24,
25,
35,
36,
46],
[
65,
75,
76,
86,
87,
88,
98,
99,
100,
101],
[
111,
112,
113,
114,
115,
116,
117,
118,
119,
120],
[
74,
84,
85,
95,
96,
97,
107,
108,
109,
110],
[
19,
20,
21,
22,
32,
33,
34,
44,
45,
55]]
self.timerStart = None
self.fsm = ClassicFSM.ClassicFSM('ChineseCheckers', [
State.State('waitingToBegin', self.enterWaitingToBegin, self.exitWaitingToBegin, [
'playing']),
State.State('playing', self.enterPlaying, self.exitPlaying, [
'gameOver']),
State.State('gameOver', self.enterGameOver, self.exitGameOver, [
'waitingToBegin'])], 'waitingToBegin', 'waitingToBegin')
self.fsm.enterInitialState()
def delete(self):
DistributedNodeAI.delete(self)
self.avatars = []
del self.avatars
