def place_markers(self,nodes):
for n in range(len(nodes)):
town_node = NodePath("town")
town = loader.loadModel("models/infantry_counter.egg")
x = (nodes[n+1]["x"]-map_center[0])*amplification
y = (nodes[n+1]["y"]-map_center[1])*amplification
town.setPos(x,y,0)
if nodes[n+1]["type"] == "city":
scale = 12
elif nodes[n+1]["type"] == "town":
scale = 7
elif nodes[n+1]["type"] == "village":
scale = 4
town.setScale(scale,scale,scale)
town.reparentTo(town_node)
town_node.reparentTo(render)
text_node = TextNode("town_text_node")
text_node.setText(nodes[n+1]["name"])
text_node_path = town.attachNewNode(text_node)
text_node_path.setPos(1,0,0)
text_node_path.setHpr(0,-90,0)
text_node_path.setScale(scale/2)
text_node_path.setTransparency(TransparencyAttrib.MAlpha)
text_node.setTextColor(0.8, 0.1, 0.1, 1)
text_node.setAlign(TextNode.ALeft)
def announceGenerate(self):
assert(self.notify.debug("announceGenerate()"))
DistributedObject.DistributedObject.announceGenerate(self)
self.sendUpdate("avIdEnteredParty", [base.localAvatar.doId])
# we probably just spent a lot of time loading, so
# tell globalClock to update the frame timestamp
globalClock.syncFrameTime()
self.startPartyClock()
base.localAvatar.chatMgr.chatInputSpeedChat.addInsidePartiesMenu()
self.spawnTitleText()
if config.GetBool('show-debug-party-grid', 0):
# Debug grid
self.testGrid = NodePath("test_grid")
self.testGrid.reparentTo(base.cr.playGame.hood.loader.geom)
for i in range(len(self.grid)):
for j in range(len(self.grid[i])):
cm = CardMaker("gridsquare")
np = NodePath(cm.generate())
np.setScale(12)
np.setP(-90.0)
np.setPos(PartyUtils.convertDistanceFromPartyGrid(j,0)-6.0, PartyUtils.convertDistanceFromPartyGrid(i,1)-6.0, 0.1)
np.reparentTo(self.testGrid)
if self.grid[i][j]:
np.setColorScale(0.0, 1.0, 0.0, 1.0)
else:
np.setColorScale(1.0, 0.0, 0.0, 1.0)
def announceGenerate(self):
# TODO - for some reason this is getting called hundreds of times when there are multiple districts
DistributedObject.DistributedObject.announceGenerate(self)
self.sendUpdate("enteredParty", [])
globalClock.syncFrameTime()
self.startPartyClock()
base.localAvatar.chatMgr.chatInputSpeedChat.addInsidePartiesMenu()
self.spawnTitleText()
messenger.send(self.generatedEvent)
if config.GetBool("show-debug-party-grid", 0):
self.testGrid = NodePath("test_grid")
self.testGrid.reparentTo(base.cr.playGame.hood.loader.geom)
for i in xrange(len(self.grid)):
for j in xrange(len(self.grid[i])):
cm = CardMaker("gridsquare")
np = NodePath(cm.generate())
np.setScale(12)
np.setP(-90.0)
np.setPos(
PartyUtils.convertDistanceFromPartyGrid(j, 0) - 6.0,
PartyUtils.convertDistanceFromPartyGrid(i, 1) - 6.0,
0.1,
)
np.reparentTo(self.testGrid)
if self.grid[i][j]:
np.setColorScale(0.0, 1.0, 0.0, 1.0)
else:
np.setColorScale(1.0, 0.0, 0.0, 1.0)
def _loadAndBuildMazeModel(self, flatten = False):
self.getMazeData()
self._model = NodePath('CogdoMazeModel')
levelModel = CogdoUtil.loadMazeModel('level')
self.quadrants = []
quadrantUnitSize = int(self.quadrantSize * self.cellWidth)
frameActualSize = self.frameWallThickness * self.cellWidth
size = quadrantUnitSize + frameActualSize
halfWidth = int(self.width / 2)
halfHeight = int(self.height / 2)
i = 0
for y in range(self.height):
for x in range(self.width):
ax = (x - halfWidth) * size
ay = (y - halfHeight) * size
extension = ''
if hasattr(getBase(), 'air'):
extension = '.bam'
filepath = self.quadrantData[i][0] + extension
angle = self.quadrantData[i][2]
m = self._createQuadrant(filepath, i, angle, quadrantUnitSize)
m.setPos(ax, ay, 0)
m.reparentTo(self._model)
self.quadrants.append(m)
i += 1
quadrantHalfUnitSize = quadrantUnitSize * 0.5
barrierModel = CogdoUtil.loadMazeModel('grouping_blockerDivider').find('**/divider')
y = 3
for x in range(self.width):
if x == (self.width - 1) / 2:
continue
ax = (x - halfWidth) * size
ay = (y - halfHeight) * size - quadrantHalfUnitSize - (self.cellWidth - 0.5)
b = NodePath('barrier')
barrierModel.instanceTo(b)
b.setPos(ax, ay, 0)
b.reparentTo(self._model)
offset = self.cellWidth - 0.5
for x in (0, 3):
for y in range(self.height):
ax = (x - halfWidth) * size - quadrantHalfUnitSize - frameActualSize + offset
ay = (y - halfHeight) * size
b = NodePath('barrier')
barrierModel.instanceTo(b)
b.setPos(ax, ay, 0)
b.setH(90)
b.reparentTo(self._model)
offset -= 2.0
barrierModel.removeNode()
levelModel.getChildren().reparentTo(self._model)
for np in self._model.findAllMatches('**/*lightCone*'):
CogdoUtil.initializeLightCone(np, 'fixed', 3)
if flatten:
self._model.flattenStrong()
return self._model
class AttackCursor(object):
_EDGES = 40
_color = Vec4(0.8, 0.3, 0.3, 1)
def __init__(self, parent, entity, foot=1):
self.entity = entity
self.pos = entity.pos
self.attackRad = entity.attackRad
self.footRad = foot
self._footCircle = LineSegs()
self._footCircleNP = NodePath("Movement Foot Circle Node")
self._attackRadCircle = LineSegs()
self._attackRadCircleNP = NodePath("Attack Radius Node")
self._np = NodePath("Movement Node")
self.attackables = Entity.EntityManager().getEntitiesWithin(
self.pos, self.attackRad)
for e in self.attackables:
if isinstance(
e, Entity.EntityShip
) and e != self.entity and e.owner != self.entity.owner:
e.representation.setAttackable()
def draw(self):
# Draw attack radius
attackRadLine = LineSegs()
attackRadLine.setThickness(1)
attackRadLine.setColor(self._color)
attackRadLine.moveTo(self.attackRad, 0, 0)
for i in range(self._EDGES + 1):
newX = (self.attackRad * math.cos((2 * math.pi / self._EDGES) * i))
newY = (self.attackRad * math.sin((2 * math.pi / self._EDGES) * i))
attackRadLine.drawTo(newX, newY, 0)
attackRadGeom = attackRadLine.create()
self._attackRadCircleNP = NodePath(attackRadGeom)
self._attackRadCircleNP.reparentTo(self._np)
# Draw foot circle
self._footCircle.setThickness(1)
self._footCircle.setColor(self._color)
self._footCircle.moveTo(self.footRad, 0, 0)
for i in range(self._EDGES):
newX = (self.footRad * math.cos((2 * math.pi / self._EDGES) * i))
newY = (self.footRad * math.sin((2 * math.pi / self._EDGES) * i))
self._footCircle.drawTo(newX, newY, 0)
self._footCircle.drawTo(self.footRad, 0, 0)
footCircleGeom = self._footCircle.create()
self._footCircleNP = NodePath(footCircleGeom)
self._footCircleNP.reparentTo(self._np)
def removeNode(self):
for e in self.attackables:
if isinstance(e, Entity.EntityShip):
e.representation.unsetAttackable()
self._footCircleNP.removeNode()
self._attackRadCircleNP.removeNode()
self._np.removeNode()
def __del__(self):
self.removeNode()
def makeNew(self, pos, nor, parent=None):
"""Makes a new bullet hole."""
if parent == None:
parent = self.container
else:
# Add a subnode to the parent, if it's not already there
child = parent.find('bullet-holes')
if child.isEmpty():
parent = parent.attachNewNode('bullet-holes')
else:
parent = child
newhole = NodePath(self.card.generate())
newhole.reparentTo(parent)
newhole.lookAt(render, Point3(newhole.getPos(render) - nor))
newhole.setR(newhole, random() * 360.0)
newhole.setPos(render, pos)
# Offset it a little to avoid z-fighting
# Increase this value if you still see it.
newhole.setY(newhole, -.001 - random() * 0.01)
del newhole
# We don't want one batch per bullet hole, so flatten it.
# This could be made smarter to preserve culling, but
# I have yet to see a performance loss.
# The clearTexture() is a necessary hack.
parent.clearTexture()
parent.flattenStrong()
parent.setTexture(self.texture)
parent.setTransparency(TransparencyAttrib.MDual)
parent.setShaderOff(1)
parent.hide(BitMask32.bit(
2)) # Invisible to volumetric lighting camera (speedup)
parent.hide(BitMask32.bit(3)) # Invisible to shadow cameras (speedup)
class bigWall(StaticObject):
def __init__(self, game):
self.game = game
self.collGeom = OdeBoxGeom( self.game.physicsSpace, 50, 15, 15)
#self.collGeom.setBody(self.body)
self.collGeom.setCategoryBits( BitMask32(0x000000ff) )#ffffffff) )
self.collGeom.setCollideBits( BitMask32(0x000000ff) )
#remember to make wall model with "50" length... no idea 50 what, though
self.visualNode = NodePath('Visual node')
self.visualNode.reparentTo(render)
model = loader.loadModel('BigWall.egg')
model.reparentTo(self.visualNode)
def osuminen(self, ship1):
if OdeUtil.collide(ship1.collGeom, self.collGeom):
print "sdfgfdhgdfhxfhdhghcfh"
print "ship1 xdfhgxdgxdgfbcdll!!"
def _optimize(self):
lightCones = NodePath('lightCones')
for np in self._platformsRoot.findAllMatches('**/*lightCone*'):
np.wrtReparentTo(lightCones)
lightCones.reparentTo(self._model)
node = self._model.find('**/ducts')
if not node.isEmpty():
node.flattenStrong()
for np in node.getChildren():
np.wrtReparentTo(self._model)
node = self._model.find('**/nests')
if not node.isEmpty():
for np in node.getChildren():
np.flattenStrong()
np.wrtReparentTo(self._model)
for np in self._model.findAllMatches('**/*LayerStack*'):
np.wrtReparentTo(self._model)
if not self._model.find('**/static').isEmpty():
for np in self._model.find('**/static').getChildren():
np.wrtReparentTo(self._model)
self._model.flattenMedium()
class BigWall(StaticObject):
def __init__(self, game, width=200.0, thickness=4.0, height=10):
self.game = game
self.collGeom = OdeBoxGeom( self.game.physicsSpace, width, thickness, height)
#self.collGeom.setBody(self.body)
self.collGeom.setCategoryBits( BitMask32(0x000000ff) )#ffffffff) )
self.collGeom.setCollideBits( BitMask32(0x000000ff) )
self.visualNode = NodePath('Visual node')
self.visualNode.reparentTo(render)
model = loader.loadModel('BigWall.egg')
model.setScale(width/50.0, thickness/4.0, height)
model.reparentTo(self.visualNode)
model.setZ(266)
# tex = loader.loadTexture('seina.jpg')
# model.setTexture(tex, 1)
def osuminen(self, ship1):
if OdeUtil.collide(ship1.collGeom, self.collGeom):
print "sdfgfdhgdfhxfhdhghcfh"
print "ship1 xdfhgxdgxdgfbcdll!!"
def title(self):
#Removes title and loads current room
def destroyTitle(task):
card.removeNode()
startGame()
def startGame():
if os.path.isfile('saves/location.json'):
self.directToRoom()
else:
self.homeFirst()
#Loads title animation
titleText = self.loader.loadTexture('resources/titleText.avi')
titleText.setLoopCount(1)
titleText.play()
#Displays title
cm = CardMaker('titleText')
cm.setFrameFullscreenQuad()
cm.setUvRange(titleText)
# noinspection PyArgumentList
card = NodePath(cm.generate())
card.reparentTo(self.render2d)
card.setTexture(titleText)
self.taskMgr.doMethodLater(5.6, destroyTitle, 'endTitle')
class TileGroup(object):
"group and flatten tiles, for rendering performance"
def __init__(self, parent, tile_x, tile_y):
self.parent = parent
self.name = "{0}:TileGroup({1},{2})".format(parent.name, tile_x, tile_y)
self.nodepath = NodePath(PandaNode(self.name))
self.textures = [[None] * TILE_GRP_SIZE for i in range(TILE_GRP_SIZE)]
self.nodepath.reparentTo(self.parent.nodepath)
self.dirty = False
def update(self, x, y, texture):
if self.textures[x][y] != texture:
self.textures[x][y] = texture
self.dirty = True
def redraw(self):
if not self.dirty:
return # nothing has changed, no need to redraw
container = NodePath(PandaNode(self.name + "container"))
for i in range(TILE_GRP_SIZE):
for j in range(TILE_GRP_SIZE):
cur = self.textures[i][j]
if cur:
node = container.attachNewNode(CARD_MAKER.generate())
node.setTexture(cur)
node.setTwoSided(True)
node.setPos(i * TILE_SIZE, 0, j * TILE_SIZE)
container.flattenStrong()
for child in self.nodepath.getChildren():
child.removeNode()
container.reparentTo(self.nodepath)
self.dirty = False
def makeNew(self, pos, nor, parent = None):
"""Makes a new bullet hole."""
if parent == None:
parent = self.container
else:
# Add a subnode to the parent, if it's not already there
child = parent.find('bullet-holes')
if child.isEmpty():
parent = parent.attachNewNode('bullet-holes')
else:
parent = child
newhole = NodePath(self.card.generate())
newhole.reparentTo(parent)
newhole.lookAt(render, Point3(newhole.getPos(render) - nor))
newhole.setR(newhole, random() * 360.0)
newhole.setPos(render, pos)
# Offset it a little to avoid z-fighting
# Increase this value if you still see it.
newhole.setY(newhole, -.001 - random() * 0.01)
del newhole
# We don't want one batch per bullet hole, so flatten it.
# This could be made smarter to preserve culling, but
# I have yet to see a performance loss.
# The clearTexture() is a necessary hack.
parent.clearTexture()
parent.flattenStrong()
parent.setTexture(self.texture)
parent.setTransparency(TransparencyAttrib.MDual)
parent.setShaderOff(1)
parent.hide(BitMask32.bit(2)) # Invisible to volumetric lighting camera (speedup)
parent.hide(BitMask32.bit(3)) # Invisible to shadow cameras (speedup)
def restart(self):
"""Start or restart the plugin."""
self.draw = Draw() # Utility for drawing 2D lines and shapes in 3-space
path = Path([Vec2(40,40),Vec2(40,-40),Vec2(-40,40),Vec2(-40,-40)])
for vehicle in self.vehicles[:3]:
vehicle._pos = SteerVec((random.random()-0.5)*100,(random.random()-0.5)*100)
vehicle._velocity = SteerVec((random.random()-0.5)*2,(random.random()-0.5)*2)
vehicle.followPath(path,loop=True)
c=(.6,.6,.6,.3)
t=1
z=1.5
self.draw.drawLine(Vec3(path[0].getX(),path[0].getY(),z),Vec3(path[1].getX(),path[1].getY(),z),color=c,thickness=t)
self.draw.drawLine(Vec3(path[1].getX(),path[1].getY(),z),Vec3(path[2].getX(),path[2].getY(),z),color=c,thickness=t)
self.draw.drawLine(Vec3(path[2].getX(),path[2].getY(),z),Vec3(path[3].getX(),path[3].getY(),z),color=c,thickness=t)
self.draw.drawLine(Vec3(path[3].getX(),path[3].getY(),z),Vec3(path[0].getX(),path[0].getY(),z),color=c,thickness=t)
path = Path([Vec2(-40,-40),Vec2(40,-40),Vec2(-40,40),Vec2(40,40)])
for vehicle in self.vehicles[3:]:
vehicle._pos = SteerVec((random.random()-0.5)*100,(random.random()-0.5)*100)
vehicle._velocity = SteerVec((random.random()-0.5)*2,(random.random()-0.5)*2)
vehicle.followPath(path,loop=True)
self.draw.drawLine(Vec3(path[0].getX(),path[0].getY(),z),Vec3(path[1].getX(),path[1].getY(),z),color=c,thickness=t)
self.draw.drawLine(Vec3(path[1].getX(),path[1].getY(),z),Vec3(path[2].getX(),path[2].getY(),z),color=c,thickness=t)
self.draw.drawLine(Vec3(path[2].getX(),path[2].getY(),z),Vec3(path[3].getX(),path[3].getY(),z),color=c,thickness=t)
self.draw.drawLine(Vec3(path[3].getX(),path[3].getY(),z),Vec3(path[0].getX(),path[0].getY(),z),color=c,thickness=t)
for vehicle in self.vehicles:
vehicle.avoidObstacles = True
vehicle.avoidVehicles = True
vehicle.maxforce = 0.1
vehicle.maxspeed = 0.5 + (random.random()/2)
node = self.draw.create()
np = NodePath(node)
np.reparentTo(render)
class Level(object):
"""
Represents one level of the asteroid.
Internal to Asteroid mostly.
"""
def __init__(self, parent, num):
self.parent = parent
self.name = "{0}-Level#{1}".format(parent.name, num)
# create one root nodepath for the overall level
self.nodepath = NodePath(PandaNode(self.name))
self.tile_groups = {}
self.nodepath.reparentTo(self.parent.nodepath)
def update(self, x, y, texture):
tgs = TILE_GRP_SIZE
tg_pos = tg_x, tg_y = x / tgs, y / tgs
if tg_pos not in self.tile_groups:
self.tile_groups[tg_pos] = TileGroup(self, tg_x, tg_y)
scale = TILE_GRP_SIZE * TILE_SIZE
self.tile_groups[tg_pos].nodepath.setPos(tg_x * scale, 0, tg_y * scale)
self.tile_groups[tg_pos].update(x % tgs, y % tgs, texture)
def redraw(self):
for tg in self.tile_groups.values():
tg.redraw()
def generateToonMoveTrack(self, toon):
node = NodePath('tempNode')
displacement = Vec3(toon.getPos(render) - self.getPos(render))
displacement.setZ(0)
displacement.normalize()
movieDistance = self.movieNode.getDistance(self.rotateNode)
displacement *= movieDistance
node.reparentTo(render)
node.setPos(displacement + self.getPos(render))
node.lookAt(self)
heading = PythonUtil.fitDestAngle2Src(toon.getH(render),
node.getH(render))
hpr = toon.getHpr(render)
hpr.setX(heading)
finalX = node.getX(render)
finalY = node.getY(render)
finalZ = node.getZ(render)
node.removeNode()
toonTrack = Sequence(
Parallel(
ActorInterval(toon, 'walk', loop=True, duration=1),
Parallel(
LerpPosInterval(toon,
1.0,
Point3(finalX, finalY, toon.getZ(render)),
fluid=True,
bakeInStart=False)),
LerpHprInterval(toon, 1.0, hpr=hpr)),
Func(toon.loop, 'neutral'))
return toonTrack
def loadModel(self):
self.rotateNode = self.plantPath.attachNewNode('rotate')
self.model = Actor.Actor()
animPath = self.modelPath + self.anims[1]
self.model.loadModel(self.modelPath + self.anims[0])
self.model.loadAnims(dict([
[
self.anims[1],
animPath]]))
colNode = self.model.find('**/+CollisionNode')
if self.typeIndex == 234:
colNode.setScale(0.5)
if not colNode.isEmpty():
(score, multiplier) = ToontownGlobals.PinballScoring[ToontownGlobals.PinballStatuary]
if self.pinballScore:
score = self.pinballScore[0]
multiplier = self.pinballScore[1]
scoreNodePath = NodePath('statuary-%d-%d' % (score, multiplier))
colNode.setName('statuaryCol')
scoreNodePath.reparentTo(colNode.getParent())
colNode.reparentTo(scoreNodePath)
self.model.setScale(self.worldScale)
self.model.reparentTo(self.rotateNode)
self.model.loop(self.anims[1])
def _loadAndBuildMazeModel(self, flatten = False):
self.getMazeData()
self._model = NodePath('CogdoMazeModel')
levelModel = CogdoUtil.loadMazeModel('level')
self.quadrants = []
quadrantUnitSize = int(self.quadrantSize * self.cellWidth)
frameActualSize = self.frameWallThickness * self.cellWidth
size = quadrantUnitSize + frameActualSize
halfWidth = int(self.width / 2)
halfHeight = int(self.height / 2)
i = 0
for y in range(self.height):
for x in range(self.width):
ax = (x - halfWidth) * size
ay = (y - halfHeight) * size
extension = ''
if hasattr(getBase(), 'air'):
extension = '.bam'
filepath = self.quadrantData[i][0] + extension
angle = self.quadrantData[i][2]
m = self._createQuadrant(filepath, i, angle, quadrantUnitSize)
m.setPos(ax, ay, 0)
m.reparentTo(self._model)
self.quadrants.append(m)
i += 1
quadrantHalfUnitSize = quadrantUnitSize * 0.5
barrierModel = CogdoUtil.loadMazeModel('grouping_blockerDivider').find('**/divider')
y = 3
for x in range(self.width):
if x == (self.width - 1) / 2:
continue
ax = (x - halfWidth) * size
ay = (y - halfHeight) * size - quadrantHalfUnitSize - (self.cellWidth - 0.5)
b = NodePath('barrier')
barrierModel.instanceTo(b)
b.setPos(ax, ay, 0)
b.reparentTo(self._model)
offset = self.cellWidth - 0.5
for x in (0, 3):
for y in range(self.height):
ax = (x - halfWidth) * size - quadrantHalfUnitSize - frameActualSize + offset
ay = (y - halfHeight) * size
b = NodePath('barrier')
barrierModel.instanceTo(b)
b.setPos(ax, ay, 0)
b.setH(90)
b.reparentTo(self._model)
offset -= 2.0
barrierModel.removeNode()
levelModel.getChildren().reparentTo(self._model)
for np in self._model.findAllMatches('**/*lightCone*'):
CogdoUtil.initializeLightCone(np, 'fixed', 3)
if flatten:
self._model.flattenStrong()
return self._model
def generateToonMoveTrack(self, toon):
node = NodePath("tempNode")
displacement = Vec3(toon.getPos(render) - self.getPos(render))
displacement.setZ(0)
displacement.normalize()
movieDistance = self.movieNode.getDistance(self.rotateNode)
displacement *= movieDistance
node.reparentTo(render)
node.setPos(displacement + self.getPos(render))
node.lookAt(self)
heading = PythonUtil.fitDestAngle2Src(toon.getH(render), node.getH(render))
hpr = toon.getHpr(render)
hpr.setX(heading)
finalX = node.getX(render)
finalY = node.getY(render)
finalZ = node.getZ(render)
node.removeNode()
toonTrack = Sequence(
Parallel(
ActorInterval(toon, "walk", loop=True, duration=1),
Parallel(
LerpPosInterval(toon, 1.0, Point3(finalX, finalY, toon.getZ(render)), fluid=True, bakeInStart=False)
),
LerpHprInterval(toon, 1.0, hpr=hpr),
),
Func(toon.loop, "neutral"),
)
return toonTrack
def _optimize(self):
lightCones = NodePath('lightCones')
for np in self._platformsRoot.findAllMatches('**/*lightCone*'):
np.wrtReparentTo(lightCones)
lightCones.reparentTo(self._model)
node = self._model.find('**/ducts')
if not node.isEmpty():
node.flattenStrong()
for np in node.getChildren():
np.wrtReparentTo(self._model)
node = self._model.find('**/nests')
if not node.isEmpty():
for np in node.getChildren():
np.flattenStrong()
np.wrtReparentTo(self._model)
for np in self._model.findAllMatches('**/*LayerStack*'):
np.wrtReparentTo(self._model)
for np in self._model.find('**/static').getChildren():
np.wrtReparentTo(self._model)
self._model.flattenMedium()
def map_populate(self,task):
self.init_collisions()
for p in range(len(self.provinces)):
city = loader.loadModel("models/house2.x")
city.reparentTo(render)
city.setName(self.provinces[p+1][0])
city.setScale(2, 2, 2)
x = float(self.provinces[p+1][2]*self.map_scale)-(self.map_width/2)
y = self.map_height-float(self.provinces[p+1][3]*self.map_scale)-(self.map_height/2)
city.setPos(x, y, 1.0)
city_col = city.attachNewNode(CollisionNode("CityCNode%d"%p))
city_col.setScale((3,3,3))
city_col.node().addSolid(CollisionSphere(0,0,0,1))
city_col.setTag("prov","city")
city.setTag("id",str(p+1))
for p in range(len(self.paths)):
path_split = string.replace(self.paths[p],"-"," ")
path_split = string.split(path_split)
prov_a = int(path_split[0])
prov_b = int(path_split[1])
line = LineSegs()
line.setColor(1, 0, 0, 1)
line.setThickness(5)
line.moveTo(self.provinces[prov_a][2]-600, -(self.provinces[prov_a][3])+350, 2)
line.drawTo(self.provinces[prov_b][2]-600, -(self.provinces[prov_b][3])+350, 2)
node = line.create()
node_path = NodePath(node)
node_path.reparentTo(render)
print "line drawn",self.provinces[prov_a][2],self.provinces[prov_a][3]
for a in range(len(self.armies)):
self.army_create(a+1,self.armies[a+1][2])
self.load_state = "Done!"
task.done
def attach_to(self, render):
'''creates Panda3D representation that can be attached to render
this function is mainly used inside Render class and its derivatives and
user not need to worry to call it'''
lines = NodePath(self.line_seqs.create())
lines.reparentTo(render.render)
return lines
def announceGenerate(self):
#TODO - for some reason this is getting called hundreds of times when there are multiple districts
DistributedObject.DistributedObject.announceGenerate(self)
self.sendUpdate('enteredParty', [])
globalClock.syncFrameTime()
self.startPartyClock()
base.localAvatar.chatMgr.chatInputSpeedChat.addInsidePartiesMenu()
self.spawnTitleText()
messenger.send(self.generatedEvent)
if config.GetBool('show-debug-party-grid', 0):
self.testGrid = NodePath('test_grid')
self.testGrid.reparentTo(base.cr.playGame.hood.loader.geom)
for i in range(len(self.grid)):
for j in range(len(self.grid[i])):
cm = CardMaker('gridsquare')
np = NodePath(cm.generate())
np.setScale(12)
np.setP(-90.0)
np.setPos(
PartyUtils.convertDistanceFromPartyGrid(j, 0) - 6.0,
PartyUtils.convertDistanceFromPartyGrid(i, 1) - 6.0,
0.1)
np.reparentTo(self.testGrid)
if self.grid[i][j]:
np.setColorScale(0.0, 1.0, 0.0, 1.0)
else:
np.setColorScale(1.0, 0.0, 0.0, 1.0)
class Block( object ):
def __init__(self, blockType, position, owner, damage, seed, baseColor ):
""" """
from blockType import BlockType
from player import Player
from pandac.PandaModules import Vec3
if not isinstance( blockType, BlockType ): raise TypeError( blockType )
if not isinstance( owner, Player ): raise TypeError( owner )
if not isinstance( position, Vec3 ): raise TypeError( position )
if not isinstance( damage, int ): raise TypeError( damage )
if not isinstance( seed, int ): raise TypeError( seed )
if not isinstance( baseColor, tuple ): raise TypeError( baseColor )
super(Block, self).__init__()
self.identifier = blockType.identifier
self.blockType = blockType
self.position = position
self.damage = damage
self.owner = owner
self.seed = seed
self.baseColor = baseColor
return None
def damage(self, amount):
""" """
# Abuse the fact that int rounds down?
self.damage += int( amount / self.blockType.rate )
if self.damage > self.blockType.durability: return self.destroy()
else: return self.damage
def create(self, environment ): return self.load( environment )
def load(self, environment):
"""Add the block to the world. Do the actual construction of the model when
necessary and add it to the environment (should actually be a chunk)."""
if self.blockType.name == 'air': return None
self.cube = NodePath('cube')
model = self.blockType.getModel()
model.instanceTo( self.cube )
self.cube.setPos( self.position )
self.cube.reparentTo( environment )
return self
def unload( self ):
''' '''
self.cube.detachNode()
return None
def destroy(self):
"""See what items should be dropped, remove the block from the world, and handle
everything else that should happens when a block breaks."""
raise NotImplementedError
class CogdoMaze(MazeBase, DirectObject):
def __init__(self, model, data, cellWidth):
MazeBase.__init__(self, model, data, cellWidth)
self._initWaterCoolers()
self.elevatorPos = self.maze.find('**/elevator_loc').getPos(render)
self.exitPos = self.maze.find('**/exit_loc').getPos(render)
self.maze.flattenStrong()
self._clearColor = VBase4(base.win.getClearColor())
self._clearColor.setW(1.0)
base.win.setClearColor(VBase4(0.0, 0.0, 0.0, 1.0))
def _initWaterCoolers(self):
self._waterCoolers = []
self._waterCoolerRoot = NodePath('WaterCoolerRoot')
self._waterCoolerRoot.reparentTo(render)
models = []
for model in self.maze.findAllMatches('**/*waterCooler'):
model.wrtReparentTo(render)
models.append(
(model.getPos(self.maze), model.getHpr(self.maze), model))
models.sort()
i = 0
for pos, hpr, model in models:
wc = CogdoMazeWaterCooler(i, model)
wc.wrtReparentTo(self._waterCoolerRoot)
wc.setPos(pos)
wc.setHpr(hpr)
self._waterCoolers.append(wc)
i += 1
self._waterCoolerRoot.stash()
def getWaterCoolers(self):
return self._waterCoolers
def isAccessible(self, tX, tY):
if tX < 0 or tY < 0 or tX >= self.width or tY >= self.height:
return 0
return self.collisionTable[tY][tX] != 1
def destroy(self):
for waterCooler in self._waterCoolers:
waterCooler.destroy()
del self._waterCoolers
self._waterCoolerRoot.removeNode()
del self._waterCoolerRoot
base.win.setClearColor(self._clearColor)
del self._clearColor
MazeBase.destroy(self)
def onstage(self):
MazeBase.onstage(self)
self._waterCoolerRoot.unstash()
def offstage(self):
self._waterCoolerRoot.stash()
MazeBase.offstage(self)
class RepairSawingLine:
def __init__(self, parent, thickness, color, lineSpawnDist=0.01):
self.points = []
self.parent = parent
self.thickness = thickness
self.color = color
self.lineNode = None
self.lineDrawer = LineSegs()
self.lineDrawer.setThickness(thickness)
self.lineSpawnDist = lineSpawnDist
self.currentPoint = None
self.startPoint = None
self.redraw()
def redraw(self):
self.clearLine()
self.lineDrawer.reset()
self.lineDrawer.setThickness(self.thickness)
self.lineDrawer.setColor(self.color)
if len(self.points) > 0:
self.lineDrawer.moveTo(self.points[0])
for i in range(1, len(self.points)):
p = self.points[i]
self.lineDrawer.drawTo(p)
self.currentPoint = p
self.lineNode = NodePath(self.lineDrawer.create())
self.lineNode.reparentTo(self.parent)
self.lineNode.setBin('fixed', 37)
self.lineNode.setTransparency(True)
def update(self, point):
if self.currentPoint == None or (
point - self.currentPoint).length() >= self.lineSpawnDist:
self.addPoint(point)
self.redraw()
def addPoint(self, p):
if len(self.points) == 0:
self.startPoint = p
self.points.append(p)
def clearLine(self):
if self.lineNode != None:
self.lineNode.removeNode()
def reset(self):
self.clearLine()
self.points = []
self.redraw()
self.currentPoint = None
self.startPoint = None
def show(self):
self.lineNode.unstash()
def hide(self):
self.lineNode.stash()
class CogdoMaze(MazeBase, DirectObject):
def __init__(self, model, data, cellWidth):
MazeBase.__init__(self, model, data, cellWidth)
self._initWaterCoolers()
self.elevatorPos = self.maze.find('**/elevator_loc').getPos(render)
self.exitPos = self.maze.find('**/exit_loc').getPos(render)
self.maze.flattenStrong()
self._clearColor = VBase4(base.win.getClearColor())
self._clearColor.setW(1.0)
base.win.setClearColor(VBase4(0.0, 0.0, 0.0, 1.0))
def _initWaterCoolers(self):
self._waterCoolers = []
self._waterCoolerRoot = NodePath('WaterCoolerRoot')
self._waterCoolerRoot.reparentTo(render)
models = []
for model in self.maze.findAllMatches('**/*waterCooler'):
model.wrtReparentTo(render)
models.append((model.getPos(self.maze), model.getHpr(self.maze), model))
models.sort()
i = 0
for pos, hpr, model in models:
wc = CogdoMazeWaterCooler(i, model)
wc.wrtReparentTo(self._waterCoolerRoot)
wc.setPos(pos)
wc.setHpr(hpr)
self._waterCoolers.append(wc)
i += 1
self._waterCoolerRoot.stash()
def getWaterCoolers(self):
return self._waterCoolers
def isAccessible(self, tX, tY):
if tX < 0 or tY < 0 or tX >= self.width or tY >= self.height:
return 0
return self.collisionTable[tY][tX] != 1
def destroy(self):
for waterCooler in self._waterCoolers:
waterCooler.destroy()
del self._waterCoolers
self._waterCoolerRoot.removeNode()
del self._waterCoolerRoot
base.win.setClearColor(self._clearColor)
del self._clearColor
MazeBase.destroy(self)
def onstage(self):
MazeBase.onstage(self)
self._waterCoolerRoot.unstash()
def offstage(self):
self._waterCoolerRoot.stash()
MazeBase.offstage(self)
def cmd_tree(self, params=[]):
self.game.world.create_trees()
trees = self.game.world.trees
x = y = 0
tree = NodePath("tree")
trees[0].copyTo(tree)
tree.setPos(x, y, 0)
tree.reparentTo(self.game.gui.render)
def printText(name, message, color):
text = TextNode(name)
text.setText(message)
x,y,z = color
text.setTextColor(x,y,z, 1)
text3d = NodePath(text)
text3d.reparentTo(render)
return text3d
def _parseStatic(nodePath, parent):
notify.debug('creating %s' % nodePath.getName()[len(STATIC_PREFIX) + 1:])
element = NodePath(nodePath.getName()[len(STATIC_PREFIX) + 1:])
element.reparentTo(parent)
nodePath.copyTo(element)
element.setScale(SCALE_MULTIPLIER)
element.setPos(0, 0, 0)
return (nodePath.getName()[len(STATIC_PREFIX) + 1:], element)
def cmd_tree(self, params=[]):
self.game.world.create_trees()
trees = self.game.world.trees
x = y = 0
tree = NodePath('tree')
trees[0].copyTo(tree)
tree.setPos(x, y, 0)
tree.reparentTo(self.game.gui.render)
def printText(name, message, color):
text = TextNode(name)
text.setText(message)
x, y, z = color
text.setTextColor(x, y, z, 1)
text3d = NodePath(text)
text3d.reparentTo(render)
return text3d
def _parseStatic(nodePath, parent):
notify.debug('creating %s' % nodePath.getName()[len(STATIC_PREFIX) + 1:])
element = NodePath(nodePath.getName()[len(STATIC_PREFIX) + 1:])
element.reparentTo(parent)
nodePath.copyTo(element)
element.setScale(SCALE_MULTIPLIER)
element.setPos(0, 0, 0)
return (nodePath.getName()[len(STATIC_PREFIX) + 1:], element)
class DistributedGardenBox(DistributedLawnDecor.DistributedLawnDecor):
notify = DirectNotifyGlobal.directNotify.newCategory(
'DistributedGardenPlot')
def __init__(self, cr):
DistributedLawnDecor.DistributedLawnDecor.__init__(self, cr)
#self.defaultModel = "phase_8/models/props/flower_treasure.bam"
self.plantPath = NodePath('plantPath')
self.plantPath.reparentTo(self)
self.plotScale = 1.0
self.plantingGuiDoneEvent = "plantingGuiDone"
self.defaultModel = "phase_5.5/models/estate/planterC"
def announceGenerate(self):
#print("box announceGenerate!!!!")
self.notify.debug('announceGenerate')
DistributedLawnDecor.DistributedLawnDecor.announceGenerate(self)
def doModelSetup(self):
if self.typeIndex == GardenGlobals.BOX_THREE:
self.defaultModel = "phase_5.5/models/estate/planterA"
elif self.typeIndex == GardenGlobals.BOX_TWO:
self.defaultModel = "phase_5.5/models/estate/planterC"
else:
self.defaultModel = "phase_5.5/models/estate/planterD"
self.collSphereOffset = 0.0
self.collSphereRadius = self.collSphereRadius * 1.41
self.plotScale = Vec3(1.0, 1.0, 1.0)
def setupShadow(self):
#we don't want the shadow
pass
def loadModel(self):
self.rotateNode = self.plantPath.attachNewNode('rotate')
self.model = None
self.model = loader.loadModel(self.defaultModel)
self.model.setScale(self.plotScale)
self.model.reparentTo(self.rotateNode)
self.stick2Ground()
#uncomment line below if we want the toons to walk on top of the planter
#self.model.find("**/collision").stash()
def handleEnterPlot(self, entry=None):
#print("Box entered")
pass
def handleExitPlot(self, entry=None):
DistributedLawnDecor.DistributedLawnDecor.handleExitPlot(self, entry)
pass
def setTypeIndex(self, typeIndex):
#print("box setting type index!!!!")
self.typeIndex = typeIndex
class cameraPickingClass( DirectObject ):
enabled = False
def __init__( self ):
self.keybindings = { "mouse1" : [self.mousePick, 1]
, "mouse1-up" : [self.mousePick, 0] }
self.mouseSetup()
self.enable()
def enable( self ):
self.enabled = True
# set keyboard mappings
for mapping, [binding, setting] in self.keybindings.items():
if setting is not None:
self.accept( mapping, binding, [setting] )
else:
self.accept( mapping, binding )
def disable( self ):
self.enabled = False
self.ignoreAll()
def mouseSetup( self ):
# create a node in front of the camera
self.cameraFrontNode = NodePath( 'cameraFrontNode' )
self.cameraFrontNode.reparentTo( base.camera )
self.cameraFrontNode.setPos( Vec3(0,3,0) )
self.pickedObject = None
self.pickedObjectDistance = 0
def mousePick( self, keyDown ):
# pick up item
if keyDown:
pickedObject = objectIdPickling.getObjectMousePick()
if pickedObject:
self.startDrag( pickedObject )
# drop item
else: # key release
if self.pickedObject:
self.stopDrag( self.pickedObject )
def startDrag( self, dragNode ):
# save the object we drag&drop
self.pickedObject = dragNode
self.pickedObject.startDrag()
# start the object move task (required to have the object moving with a free mouse)
taskMgr.add( self.dragTask, 'mouseDragTask' )
def stopDrag( self, dragNode ):
self.pickedObject.stopDrag()
# we dont drag&drop anything now
self.pickedObject = None
taskMgr.remove( 'mouseDragTask' )
def dragTask( self, task ):
# get a ray where the mouse points at
newMouseRay = objectIdPickling.getPickerRayDirection()
self.pickedObject.whileDrag( newMouseRay )
return Task.cont
class Base(StaticObject):
#17.12.2009: collGeomInner -> collGeom, dropBall(x, y ,z, linX, linY), collectible.setPos() ja setVelocity()
def __init__(self, game):
self.game = game
#poista se fysiikka-avaruus ja vaan tee se alue... justiinsa
self.collGeom = OdeBoxGeom( 24,8,2 )
#self.collGeom.setBody(self.body)
self.collGeom.setCategoryBits( BitMask32(1) )
self.collGeom.setCollideBits( BitMask32(1) )
# self.collGeomOuter = OdeBoxGeom( self.game.physicsSpace, 28,6,2)
# #self.collGeom.setBody(self.body)
# self.collGeomOuter.setCategoryBits( BitMask32(1) )
# self.collGeomOuter.setCollideBits( BitMask32(1) )
self.visualNode = NodePath('Visual node')
self.visualNode.reparentTo(render)
model = loader.loadModel('Base.egg')
model.reparentTo(self.visualNode)
plight = PointLight('baselight')
plight.setPoint( Point3(0, 0, 12) )
plight.setColor( Vec4(1,1,1,1) )
plight.setAttenuation( Vec3(0.1, 0.1, 0.005) )
self.visualNode.setLight(model.attachNewNode(plight))
def checkCollision( self, ship, collectiblelist ):
if OdeUtil.collide(ship.collGeom, self.collGeom) and ship.hasBall():
#if ship.hasBall():
ship.addPoints( (ship.Ball.getValue()*2) )
pos = self.getPos()
ship.dropBall( x = pos[0], y = pos[1], z = 50, linX = random.randrange(-10,10), linY = (0-pos[1]) / 4 )
print ship.SHIP_TYPE + " " + str(ship.getPoints()) + " Points! "
if (self.game.goalSfx.status() == 1):
self.game.goalSfx.play()
self.game.updateHUD()
#print " Base One! "
for collectible in collectiblelist:
if OdeUtil.collide(collectible.collGeom, self.collGeom):
pos = self.getPos()
ship.addPoints(collectible.getValue())
collectible.setPos( Vec3(pos[0], pos[1], 50))
collectible.setVelocity(x = random.randrange(-10,10), y = (0-pos[1]) / 4)
self.game.goalSfx.play()
self.game.updateHUD()
print ship.SHIP_TYPE + " " + str(ship.getPoints()) + " Points! by throwing the ball"
def addToBaseList(self, baseList):
baseList.append(self)
def setPos(self, pos, pos2):
self.visualNode.setPos( pos )
self.collGeom.setPosition( pos2 )
def printText(self, name, message, color, parent=render):
text = TextNode(name) # create a TextNode. Note that 'name' is not the text, rather it is a name that identifies the object.
text.setText(message) # Here we set the text of the TextNode
x,y,z = color # break apart the color tuple
text.setTextColor(x,y,z, 1) # Set the text color from the color tuple
text3d = NodePath(text) # Here we create a NodePath from the TextNode, so that we can manipulate it 'in world'
text3d.reparentTo(parent)
return text3d # return the NodePath for further use
def draw_line(self,p,col):
line = LineSegs()
line.setColor(col[0],col[1],col[2], 1)
line.setThickness(2)
line.moveTo(p[0],p[1],0)
line.drawTo(p[2],p[3],0)
line_node = line.create()
node_path = NodePath(line_node)
node_path.reparentTo(render)
class AttackCursor(object):
_EDGES = 40
_color = Vec4(0.8, 0.3, 0.3, 1)
def __init__(self, parent, entity, foot=1):
self.entity = entity
self.pos = entity.pos
self.attackRad = entity.attackRad
self.footRad = foot
self._footCircle = LineSegs()
self._footCircleNP = NodePath("Movement Foot Circle Node")
self._attackRadCircle = LineSegs()
self._attackRadCircleNP= NodePath("Attack Radius Node")
self._np = NodePath("Movement Node")
self.attackables = Entity.EntityManager().getEntitiesWithin(self.pos, self.attackRad)
for e in self.attackables:
if isinstance(e, Entity.EntityShip) and e != self.entity and e.owner != self.entity.owner:
e.representation.setAttackable()
def draw(self):
# Draw attack radius
attackRadLine = LineSegs()
attackRadLine.setThickness(1)
attackRadLine.setColor(self._color)
attackRadLine.moveTo(self.attackRad, 0, 0)
for i in range(self._EDGES + 1):
newX = (self.attackRad * math.cos((2*math.pi/self._EDGES)*i))
newY = (self.attackRad * math.sin((2*math.pi/self._EDGES)*i))
attackRadLine.drawTo(newX, newY, 0)
attackRadGeom = attackRadLine.create()
self._attackRadCircleNP = NodePath(attackRadGeom)
self._attackRadCircleNP.reparentTo(self._np)
# Draw foot circle
self._footCircle.setThickness(1)
self._footCircle.setColor(self._color)
self._footCircle.moveTo(self.footRad, 0, 0)
for i in range(self._EDGES):
newX = (self.footRad * math.cos((2*math.pi/self._EDGES)*i))
newY = (self.footRad * math.sin((2*math.pi/self._EDGES)*i))
self._footCircle.drawTo(newX, newY, 0)
self._footCircle.drawTo(self.footRad, 0, 0)
footCircleGeom = self._footCircle.create()
self._footCircleNP = NodePath(footCircleGeom)
self._footCircleNP.reparentTo(self._np)
def removeNode(self):
for e in self.attackables:
if isinstance(e, Entity.EntityShip):
e.representation.unsetAttackable()
self._footCircleNP.removeNode()
self._attackRadCircleNP.removeNode()
self._np.removeNode()
def __del__(self):
self.removeNode()
class CogdoMazeHud():
__module__ = __name__
def __init__(self):
self._update = None
self._initQuestArrow()
return
def _initQuestArrow(self):
matchingGameGui = loader.loadModel(
'phase_3.5/models/gui/matching_game_gui')
arrow = matchingGameGui.find('**/minnieArrow')
arrow.setScale(Globals.QuestArrowScale)
arrow.setColor(*Globals.QuestArrowColor)
arrow.setHpr(90, -90, 0)
self._questArrow = NodePath('Arrow')
arrow.reparentTo(self._questArrow)
self._questArrow.reparentTo(render)
self.hideQuestArrow()
matchingGameGui.removeNode()
def destroy(self):
self.__stopUpdateTask()
self._questArrow.removeNode()
self._questArrow = None
return
def showQuestArrow(self, parent, nodeToPoint, offset=Point3(0, 0, 0)):
self._questArrowNodeToPoint = nodeToPoint
self._questArrowParent = parent
self._questArrowOffset = offset
self._questArrow.unstash()
self._questArrowVisible = True
self.__startUpdateTask()
def hideQuestArrow(self):
self._questArrow.stash()
self.__stopUpdateTask()
self._questArrowVisible = False
self._questArrowNodeToPoint = None
return
def __startUpdateTask(self):
self.__stopUpdateTask()
self._update = taskMgr.add(self._updateTask, 'CogdoMazeHud_Update', 45)
def __stopUpdateTask(self):
if self._update is not None:
taskMgr.remove(self._update)
return
def _updateTask(self, task):
if self._questArrowVisible:
self._questArrow.setPos(self._questArrowParent,
self._questArrowOffset)
self._questArrow.lookAt(self._questArrowNodeToPoint)
return Task.cont
class LocalView(View):
"""The pseudo-2D main display where the player is likely to spend
most of their time."""
def update_ship(self, view):
ship = view.obj
pos3 = Point3(ship.pos.x, ship.pos.y, ship.pos.z)
view.node.setPos(pos3)
view.node.setHpr(ship.hpr)
def view_for(self, obj):
if isinstance(obj, Star):
if not self.views.has_key('star'):
self.views.star = StarView(self, obj)
return self.views.star
elif isinstance(obj, Planet):
if not self.views.planets.has_key(obj):
self.views.planets[obj] = PlanetView(self, obj)
return self.views.planets[obj]
elif isinstance(obj, Ship):
try: return self.views.ships[obj]
except KeyError:
shipview = ShipView(self, obj)
self.delegate(obj, 'reposition', lambda: self.update_ship(shipview))
self.views.ships[obj] = shipview
return shipview
else:
raise NotImplementedError
def render(self):
starview = self.view_for(self.locality.star)
starview.node.setScale(100)
for planet in self.locality.planets:
pview = self.view_for(planet)
pview.set_light(starview.light)
planet.recalc_pos()
pos = Point3(planet.pos.x, planet.pos.y, planet.pos.z) * self.distance_scale
pview.node.setPos(pos)
pview.node.setScale(100)
for ship in self.locality.ships:
view = self.view_for(ship)
self.update_ship(view)
def __init__(self, parent, locality, **kwargs):
super(LocalView, self).__init__(parent, locality, **kwargs)
self.locality = locality
self.distance_scale = 0.01
self.views = propdict()
self.views.planets = {}
self.views.ships = {}
self.node = NodePath('local')
self.node.reparentTo(self.parent.node)
self.render()
def drawBestPath(self):
if self.bestPath != None:
ls = LineSegs()
ls.setThickness(10.0)
for i in range(len(self.bestPath) - 1):
ls.setColor(0, 0, 1, 1)
ls.moveTo(self.bestPath[i].getPos())
ls.drawTo(self.bestPath[i + 1].getPos())
np = NodePath(ls.create("aoeu"))
np.reparentTo(render)
def createSafeZone(self, dnaFile):
SafeZoneLoader.SafeZoneLoader.createSafeZone(self, dnaFile)
parent = self.geom.getParent()
geom = self.geom
n = NodePath('PartyGroundRoot')
n.reparentTo(parent)
geom.reparentTo(n)
geom.setPos(-10.0, 0.0, 0.0)
self.geom = n
self.loadSunMoon()
def createSafeZone(self, dnaFile):
SafeZoneLoader.SafeZoneLoader.createSafeZone(self, dnaFile)
parent = self.geom.getParent()
geom = self.geom
n = NodePath('PartyGroundRoot')
n.reparentTo(parent)
geom.reparentTo(n)
geom.setPos(-10.0, 0.0, 0.0)
self.geom = n
self.loadSunMoon()
def drawBestPath(self):
if self.bestPath != None:
ls = LineSegs()
ls.setThickness(10.0)
for i in range(len(self.bestPath) - 1):
ls.setColor(0, 0, 1, 1)
ls.moveTo(self.bestPath[i].getPos())
ls.drawTo(self.bestPath[i + 1].getPos())
np = NodePath(ls.create("aoeu"))
np.reparentTo(render)
def createCamNodes(self):
"""Creates a few empty nodes around a plane which the camera might be
parented to. It looks if there are cameras inside the model file and
uses those if possible. Where everything named "camera CamType" is
considered a camera. At least ThirdPerson, FirstPerson and Cockpit
should be defined inside the egg file, otherwise some guessed defaults
are taken.
"""
# Look for cameras inside the model (loaded egg file)
self.cameras = NodePath("cameras")
found_cams = self.parent.node.findAllMatches("**/camera ?*")
found_cams.removeDuplicatePaths()
found_cams.reparentTo(self.cameras)
if not found_cams.isEmpty():
self.notifier.info("Cameras found under model:\n%s"
% found_cams)
else:
self.notifier.info("No cameras found under model.")
# FirstPerson camera is a must-have. Set up a guessed one if none
# defined yet.
if self.cameras.find("camera FirstPerson").isEmpty():
assert self.notifier.debug("No first person camera found in %s. "
"Guessing best position." % self.parent.name)
first_person = NodePath("camera FirstPerson")
# TODO: Guess best position based on bounding box.
first_person.setY(5)
first_person.reparentTo(cameras)
# ThirdPerson camera is a must-have. Set up a guessed one if none
# defined yet.
if self.cameras.find("camera ThirdPerson").isEmpty():
assert self.notifier.debug("No third person camera found in %s. "
"Guessing best position." % self.parent.name)
third_person = NodePath("camera ThirdPerson")
# TODO: Guess best position based on bounding box.
third_person.setPos(0, -30, 5)
#third_person.setP(-80)
third_person.reparentTo(cameras)
# Cockpit needs to be accurate. Don't try to guess it.
if self.cameras.find("camera Cockpit").isEmpty():
assert self.notifier.debug("No cockpit camera found in "
"%s. Cockpit camera disabled."
% self.parent.name)
self.sideview_cam = NodePath("camera Sideview")
self.sideview_cam.reparentTo(render)
# Store the cams at parent node..
# You can edit the camera nodes from outside as well.
# If you attach new camera nodes, though, you'll have to call this
# function again.
self.cameras.reparentTo(self.parent.node)
def createCamNodes(self):
"""Creates a few empty nodes around a plane which the camera might be
parented to. It looks if there are cameras inside the model file and
uses those if possible. Where everything named "camera CamType" is
considered a camera. At least ThirdPerson, FirstPerson and Cockpit
should be defined inside the egg file, otherwise some guessed defaults
are taken.
"""
# Look for cameras inside the model (loaded egg file)
self.cameras = NodePath("cameras")
found_cams = self.parent.node.findAllMatches("**/camera ?*")
found_cams.removeDuplicatePaths()
found_cams.reparentTo(self.cameras)
if not found_cams.isEmpty():
self.notifier.info("Cameras found under model:\n%s"
% found_cams)
else:
self.notifier.info("No cameras found under model.")
# FirstPerson camera is a must-have. Set up a guessed one if none
# defined yet.
if self.cameras.find("camera FirstPerson").isEmpty():
assert self.notifier.debug("No first person camera found in %s. "
"Guessing best position." % self.parent.name)
first_person = NodePath("camera FirstPerson")
# TODO: Guess best position based on bounding box.
first_person.setY(5)
first_person.reparentTo(cameras)
# ThirdPerson camera is a must-have. Set up a guessed one if none
# defined yet.
if self.cameras.find("camera ThirdPerson").isEmpty():
assert self.notifier.debug("No third person camera found in %s. "
"Guessing best position." % self.parent.name)
third_person = NodePath("camera ThirdPerson")
# TODO: Guess best position based on bounding box.
third_person.setPos(0, -30, 5)
#third_person.setP(-80)
third_person.reparentTo(cameras)
# Cockpit needs to be accurate. Don't try to guess it.
if self.cameras.find("camera Cockpit").isEmpty():
assert self.notifier.debug("No cockpit camera found in "
"%s. Cockpit camera disabled."
% self.parent.name)
self.sideview_cam = NodePath("camera Sideview")
self.sideview_cam.reparentTo(render)
# Store the cams at parent node..
# You can edit the camera nodes from outside as well.
# If you attach new camera nodes, though, you'll have to call this
# function again.
self.cameras.reparentTo(self.parent.node)
class CogdoMazeHud():
__module__ = __name__
def __init__(self):
self._update = None
self._initQuestArrow()
return
def _initQuestArrow(self):
matchingGameGui = loader.loadModel('phase_3.5/models/gui/matching_game_gui')
arrow = matchingGameGui.find('**/minnieArrow')
arrow.setScale(Globals.QuestArrowScale)
arrow.setColor(*Globals.QuestArrowColor)
arrow.setHpr(90, -90, 0)
self._questArrow = NodePath('Arrow')
arrow.reparentTo(self._questArrow)
self._questArrow.reparentTo(render)
self.hideQuestArrow()
matchingGameGui.removeNode()
def destroy(self):
self.__stopUpdateTask()
self._questArrow.removeNode()
self._questArrow = None
return
def showQuestArrow(self, parent, nodeToPoint, offset = Point3(0, 0, 0)):
self._questArrowNodeToPoint = nodeToPoint
self._questArrowParent = parent
self._questArrowOffset = offset
self._questArrow.unstash()
self._questArrowVisible = True
self.__startUpdateTask()
def hideQuestArrow(self):
self._questArrow.stash()
self.__stopUpdateTask()
self._questArrowVisible = False
self._questArrowNodeToPoint = None
return
def __startUpdateTask(self):
self.__stopUpdateTask()
self._update = taskMgr.add(self._updateTask, 'CogdoMazeHud_Update', 45)
def __stopUpdateTask(self):
if self._update is not None:
taskMgr.remove(self._update)
return
def _updateTask(self, task):
if self._questArrowVisible:
self._questArrow.setPos(self._questArrowParent, self._questArrowOffset)
self._questArrow.lookAt(self._questArrowNodeToPoint)
return Task.cont
def printText(self, name, message, color, parent=render):
text = TextNode(
name
) # create a TextNode. Note that 'name' is not the text, rather it is a name that identifies the object.
text.setText(message) # Here we set the text of the TextNode
x, y, z = color # break apart the color tuple
text.setTextColor(x, y, z, 1) # Set the text color from the color tuple
text3d = NodePath(text) # Here we create a NodePath from the TextNode, so that we can manipulate it 'in world'
text3d.reparentTo(parent)
return text3d # return the NodePath for further use
def addToon(self, toon, tX, tY):
marker = NodePath('toon_marker-%i' % toon.doId)
marker.reparentTo(self)
self._getToonMarker(toon).copyTo(marker)
marker.setColor(toon.style.getHeadColor())
if toon.isLocal():
marker.setScale(0.07)
else:
marker.setScale(0.05)
marker.flattenStrong()
marker.setPos(*self.gui2pos(*self.tile2gui(tX, tY)))
self._toon2marker[toon] = marker
def regenTree(self):
forest= render.findAllMatches("Tree Holder")
forest.detach()
bodydata=GeomVertexData("body vertices", self.format, Geom.UHStatic)
treeNodePath=NodePath("Tree Holder")
makeFractalTree(bodydata, treeNodePath,Vec3(4,4,7), Vec3(0,0,0),self.numIterations, self.numCopies)
treeNodePath.setTexture(self.barkTexture,1)
treeNodePath.reparentTo(render)
def addToon(self, toon, tX, tY):
marker = NodePath('toon_marker-%i' % toon.doId)
marker.reparentTo(self)
self._getToonMarker(toon).copyTo(marker)
marker.setColor(toon.style.getHeadColor())
if toon.isLocal():
marker.setScale(0.07)
else:
marker.setScale(0.05)
marker.flattenStrong()
marker.setPos(*self.gui2pos(*self.tile2gui(tX, tY)))
self._toon2marker[toon] = marker
def load(self):
self.root = NodePath('root')
self.root.reparentTo(render)
self.root.stash()
self.world = loadMockup("cogdominium/mockup.egg")
self.world.reparentTo(self.root)
self.world.stash()
# Setup and placement of starting platform
self.startPlatform = loadMockup("cogdominium/start_platform.egg")
startPlatformLoc = self.world.find("**/start_platform_loc")
self.startPlatform.reparentTo(startPlatformLoc)
colModel = self.startPlatform.find("**/col_floor")
colModel.setTag('start_platform', '%s' % base.localAvatar.doId)
# Here we set the current platform for the local player
self.localPlayer.setCheckpointPlatform(self.startPlatform)
# Setup and placement of the end platform
self.endPlatform = loadMockup("cogdominium/end_platform.egg")
endPlatformLoc = self.world.find("**/end_platform_loc")
self.endPlatform.reparentTo(endPlatformLoc)
colModel = self.endPlatform.find("**/col_floor")
colModel.setTag('end_platform', '%s' % base.localAvatar.doId)
# Setup and placement for all the fuel platforms
fuelPlatformModel = loadMockup("cogdominium/fuel_platform.egg")
fuelIndex = 1
fuelLoc = self.world.find('**/fuel_platform_loc_%d' % fuelIndex)
while not fuelLoc.isEmpty():
fuelModel = NodePath("fuel_platform_%d" % fuelIndex)
fuelPlatformModel.copyTo(fuelModel)
fuelModel.reparentTo(fuelLoc)
colModel = fuelModel.find("**/col_floor")
colModel.setTag('fuel_platform', '%s' % base.localAvatar.doId)
colModel.setTag('isUsed', '%s' % 0)
self.fuelPlatforms[fuelModel.getName()] = fuelModel
fuelIndex += 1
fuelLoc = self.world.find('**/fuel_platform_loc_%d' % fuelIndex)
self.accept("entercol_floor", self.handleCollision)
self.skybox = self.world.find("**/skybox")
self.upLimit = self.world.find("**/limit_up").getPos(render).getZ()
self.downLimit = self.world.find("**/limit_down").getPos(render).getZ()
self.leftLimit = self.world.find("**/limit_left").getPos(render).getX()
self.rightLimit = self.world.find("**/limit_right").getPos(
render).getX()
del fuelPlatformModel
self._initFog()
def splitShip(self):
if not self.isSplit:
self.isSplit = True
self.modelGeom.instanceTo(self.clipParent2)
planeNode1 = NodePath(PlaneNode('planeNode1', Plane(Vec4(0, 1, 0, 0))))
planeNode1.reparentTo(self.clipParent1)
planeNode1.setY(ShipGlobals.getShipSplitOffset(self.shipClass))
self.clipParent1.setClipPlane(planeNode1)
planeNode2 = NodePath(PlaneNode('planeNode2', Plane(Vec4(0, -1, 0, 0))))
planeNode2.reparentTo(self.clipParent2)
planeNode2.setY(ShipGlobals.getShipSplitOffset(self.shipClass))
self.clipParent2.setClipPlane(planeNode2)
def createSafeZone(self, dnaFile):
assert (self.notify.debug("createParty()"))
SafeZoneLoader.SafeZoneLoader.createSafeZone(self, dnaFile)
parent = self.geom.getParent()
geom = self.geom
n = NodePath("PartyGroundRoot")
n.reparentTo(parent)
geom.reparentTo(n)
geom.setPos(-10.0, 0.0, 0.0)
self.geom = n
# load the sun and moon
self.loadSunMoon()
def addToon(self, toon):
marker = NodePath('toon_marker-%i' % toon.doId)
marker.reparentTo(self)
self._getToonMarker(toon).copyTo(marker)
marker.setColor(toon.style.getHeadColor())
if toon.isLocal():
marker.setScale(Globals.Gui.LocalMarkerScale)
marker.setBin('fixed', 10)
else:
marker.setScale(Globals.Gui.MarkerScale)
marker.setBin('fixed', 5)
marker.flattenStrong()
self._toonMarkers[toon] = marker
class SimViewer(LightBase):
""" Visualizes simulation."""
def __init__(self):
super(SimViewer, self).__init__()
# Make a window.
size = (700, 520)
self.create_output(size, "SimViewer")
self.output.setClearColor((0.0, 0.0, 0.0, 1.0))
# Lights node
self.lights = NodePath('lights')
# Create a spotlight
slight = Spotlight('slight')
slight.setScene(self.root)
slight.setShadowCaster(True, 2**11, 2**11)
# Set shadow mask, so we can exclude objects from casting shadows
self.shadow_mask = BitMask32.bit(2)
slight.setCameraMask(self.shadow_mask)
c = 1.4
slight.setColor((c, c, c, 1.0))
slight.getLens().setNearFar(4, 100)
slight.getLens().setFov(45)
slnp = self.lights.attachNewNode(slight)
slnp.setPos((7, 10, 40))
slnp.lookAt(2, 0, 1.5)
self.root.setLight(slnp)
# Create an ambient light.
alight = AmbientLight('alight')
c = 0.6
alight.setColor((c, c, c, 1.0))
alnp = self.lights.attachNewNode(alight)
self.root.setLight(alnp)
self.lights.reparentTo(self.root)
# Set auto shading for shadows.
self.root.setShaderAuto()
# Set antialiasing on.
self.root.setAntialias(AntialiasAttrib.MAuto)
# Camera.
lens = PerspectiveLens()
self.lens = lens
self.lens.setNearFar(0.1, 1000.)
self.lens.setFov((40, 30))
self.cameras = self.root.attachNewNode('cameras')
self.camera = self.make_camera(self.output, lens=self.lens)
self.camera.setPos(15, 44, 3.)
self.camera.setPos(15, 35, 15.)
self.camera.lookAt(0, 0, 1.)
def create_output(self, size, name):
self.output = self.make_window(size=size, name=name)
self.render_frame()
self.render_frame()
