def makePerspective(parent):
v = Viewport('persp', parent)
v.camPos = Point3(-19, -19, 19)
v.camLookAt = Point3(0, 0, 0)
v.grid = DirectGrid(parent=render)
collPlane = CollisionNode('PerspGridCol')
collPlane.addSolid(CollisionPlane(Plane(0, 0, 1, 0)))
#oldBitmask = collPlane.getIntoCollideMask()
#collPlane.setIntoCollideMask(BitMask32.bit(21)|oldBitmask)
collPlane.setIntoCollideMask(BitMask32.bit(21))
v.collPlane = NodePath(collPlane)
v.collPlane.reparentTo(v.grid)
collPlane2 = CollisionNode('PerspGridCol2')
collPlane2.addSolid(CollisionPlane(Plane(0, 0, -1, 0)))
#oldBitmask = collPlane2.getIntoCollideMask()
#collPlane2.setIntoCollideMask(BitMask32.bit(21)|oldBitmask)
collPlane2.setIntoCollideMask(BitMask32.bit(21))
v.collPlane2 = NodePath(collPlane2)
v.collPlane2.reparentTo(v.grid)
#v.grid.gridBack.findAllMatches("**/+GeomNode")[0].setName("_perspViewGridBack")
LE_showInOneCam(v.grid, 'persp')
return v
def makeOrthographic(parent, name, campos):
v = Viewport(name, parent)
v.lens = OrthographicLens()
v.lens.setFilmSize(30)
v.camPos = campos
v.camLookAt = Point3(0, 0, 0)
v.grid = DirectGrid(parent=render)
if name == 'left':
v.grid.setHpr(0, 0, 90)
collPlane = CollisionNode('LeftGridCol')
collPlane.addSolid(CollisionPlane(Plane(1, 0, 0, 0)))
collPlane.setIntoCollideMask(BitMask32.bit(21))
v.collPlane = NodePath(collPlane)
v.collPlane.wrtReparentTo(v.grid)
#v.grid.gridBack.findAllMatches("**/+GeomNode")[0].setName("_leftViewGridBack")
LE_showInOneCam(v.grid, name)
elif name == 'front':
v.grid.setHpr(90, 0, 90)
collPlane = CollisionNode('FrontGridCol')
collPlane.addSolid(CollisionPlane(Plane(0, -1, 0, 0)))
collPlane.setIntoCollideMask(BitMask32.bit(21))
v.collPlane = NodePath(collPlane)
v.collPlane.wrtReparentTo(v.grid)
#v.grid.gridBack.findAllMatches("**/+GeomNode")[0].setName("_frontViewGridBack")
LE_showInOneCam(v.grid, name)
else:
collPlane = CollisionNode('TopGridCol')
collPlane.addSolid(CollisionPlane(Plane(0, 0, 1, 0)))
collPlane.setIntoCollideMask(BitMask32.bit(21))
v.collPlane = NodePath(collPlane)
v.collPlane.reparentTo(v.grid)
#v.grid.gridBack.findAllMatches("**/+GeomNode")[0].setName("_topViewGridBack")
LE_showInOneCam(v.grid, name)
return v
def _initCollisions(self):
self.collPlane = CollisionPlane(Plane(Vec3(0, 0, 1.0), Point3(0, 0, 10)))
self.collPlane.setTangible(0)
self.collNode = CollisionNode('fogPlane')
self.collNode.setIntoCollideMask(OTPGlobals.FloorBitmask)
self.collNode.addSolid(self.collPlane)
self.collNodePath = self.root.attachNewNode(self.collNode)
self.collNodePath.hide()
def _initCollisions(self):
self.collPlane = CollisionPlane(Plane(Vec3(0, 0, 1.0), Point3(0, 0, 10)))
self.collPlane.setTangible(0)
self.collNode = CollisionNode('fogPlane')
self.collNode.setIntoCollideMask(OTPGlobals.FloorBitmask)
self.collNode.addSolid(self.collPlane)
self.collNodePath = self.root.attachNewNode(self.collNode)
self.collNodePath.hide()
def __init__(self):
self.line_dir = NodePath()
base.cTrav = CollisionTraverser()
self.col_handler = CollisionHandlerEvent()
picker_node = CollisionNode("mouseRayNode")
pickerNPos = base.camera.attachNewNode(picker_node)
self.pickerRay = CollisionRay()
picker_node.addSolid(self.pickerRay)
plane_node = CollisionNode("base_plane")
plane = base.render.attachNewNode(plane_node)
self.plane_col = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0)))
picker_node.addSolid(self.pickerRay)
picker_node.setTag("rays", "mray")
base.cTrav.addCollider(pickerNPos, self.col_handler)
self.col_handler.addInPattern("%(rays)ft-into-%(type)it")
self.col_handler.addOutPattern("%(rays)ft-out-%(type)it")
self.col_handler.addAgainPattern("ray_again_all%("
"rays"
")fh%("
"type"
")ih")
self.model = loader.loadModel("../models/chest.egg")
self.model_node = NodePath("sdfafd")
self.model.reparentTo(self.model_node)
self.model_node.reparentTo(render)
#
# self.text_node = TextNode("battle_text")
# self.text_node.setText("TEXTYTEXTYTEXTTEXT")
# self.text_node_path = render.attachNewNode(self.text_node)
# self.text_node_path.reparentTo(render)
# self.text_node_path.setPos(0,0,4)
# self.text_node_path.setHpr(0,0,0)
# self.text_node_path.setScale(1)
# #self.text_node_path.setTransparency(TransparencyAttrib.MAlpha)
# self.text_node.setTextColor((1,1,1,1))
# self.text_node.setAlign(TextNode.ALeft)
self.placement_ghost = EditorObjects.PlacementGhost(
0, "tower", base.object_scale)
z = 0
self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, z))
taskMgr.add(self.ray_update, "updatePicker")
taskMgr.add(self.get_mouse_plane_pos, "MousePositionOnPlane")
taskMgr.add(self.task_mouse_press_check, "checkMousePress")
self.input_init()
self.pickable = None
def setupCollision(self):
# create collision traverser
self.picker = CollisionTraverser()
# create collision handler
self.pq = CollisionHandlerQueue()
# create collision node
self.pickerNode = CollisionNode('mouseRay') # create collision node
# attach new collision node to camera node
self.pickerNP = camera.attachNewNode(
self.pickerNode) # attach collision node to camera
# set bit mask to one
self.pickerNode.setFromCollideMask(BitMask32.bit(1)) # set bit mask
# create a collision ray
self.pickerRay = CollisionRay() # create collision ray
# add picker ray to the picker node
self.pickerNode.addSolid(
self.pickerRay) # add the collision ray to the collision node
# make the traverser know about the picker node and its even handler queue
self.picker.addCollider(
self.pickerNP,
self.pq) # add the colision node path and collision handler queue
#self.picker.showCollisions( render ) # render or draw the collisions
#self.pickerNP.show( ) # render picker ray
# create col node
self.colPlane = CollisionNode('colPlane')
# add solid to col node plane
self.colPlane.addSolid(
CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0))))
# attach new node to the render
self.colPlanePath = render.attachNewNode(self.colPlane)
#self.colPlanePath.show( ) # render node
# make the col plane look at the camera
# this makes it alway look at the camera no matter the orientation
# we need this because the ray nees to intersect a plane parallel
# to the camera
self.colPlanePath.lookAt(camera)
# prop up the col plane
self.colPlanePath.setP(-45)
# set bit mask to one
# as I understand it, this makes all col nodes with bit mask one
# create collisions while ignoring others of other masks
self.colPlanePath.node().setIntoCollideMask(BitMask32.bit(1))
def __init__(self, game_data, gfx_manager):
self.game_data = game_data
self.gui_traverser = CollisionTraverser()
self.handler = CollisionHandlerQueue()
self.selectable_objects = {}
for cid, model in gfx_manager.character_models.items():
new_collision_node = CollisionNode('person_' + str(cid))
new_collision_node.addSolid(
CollisionTube(0, 0, 0.5, 0, 0, 1.5, 0.5))
new_collision_nodepath = model.attachNewNode(new_collision_node)
new_collision_nodepath.setTag("type", "character")
new_collision_nodepath.setTag("id", str(cid))
picker_node = CollisionNode('mouseRay')
picker_np = camera.attachNewNode(picker_node)
self.picker_ray = CollisionRay()
picker_node.addSolid(self.picker_ray)
self.gui_traverser.addCollider(picker_np, self.handler)
self.floor = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0)))
self.floor_np = render.attachNewNode(CollisionNode('floor'))
self.floor_np.setTag("type", "ground")
self.floor_np.node().addSolid(self.floor)
class CogdoFlyingLevel(DirectObject):
notify = directNotify.newCategory('CogdoFlyingLevel')
def __init__(self, parent, frameModel, startPlatformModel,
endPlatformModel, quadLengthUnits, quadVisibilityAhead,
quadVisibiltyBehind):
self.parent = parent
self.quadLengthUnits = quadLengthUnits
self._halfQuadLengthUnits = quadLengthUnits / 2.0
self.quadVisibiltyAhead = quadVisibilityAhead
self.quadVisibiltyBehind = quadVisibiltyBehind
self._frameModel = frameModel
self.root = NodePath('CogdoFlyingLevel')
self.quadrantRoot = NodePath('QuadrantsRoot')
self.quadrantRoot.reparentTo(self.root)
self._startPlatformModel = startPlatformModel
self._startPlatformModel.reparentTo(self.root)
self._startPlatformModel.setZ(Globals.Level.StartPlatformHeight)
self._endPlatformModel = endPlatformModel
self._endPlatformModel.reparentTo(self.root)
self._endPlatformModel.setZ(Globals.Level.EndPlatformHeight)
self.wallR = self._frameModel.find('**/wallR')
self.wallL = self._frameModel.find('**/wallL')
self._exit = CogdoGameExit()
self._exit.reparentTo(self._endPlatformModel)
loc = self._endPlatformModel.find('**/exit_loc')
offset = loc.getPos(render)
self._exit.setPos(render, offset)
self.quadrants = []
self.visibleQuadIndices = []
self._numQuads = 0
self._currentQuadNum = -1
self._camera = None
self._initCollisions()
self.upLimit = self._frameModel.find('**/limit_up').getZ(render)
self.downLimit = self._frameModel.find('**/limit_down').getZ(render)
self.leftLimit = self._frameModel.find('**/limit_left').getX(
render) - 30.0
self.rightLimit = self._frameModel.find('**/limit_right').getX(
render) + 30.0
self.backLimit = -self.quadLengthUnits
self.forwardLimit = self.quadLengthUnits * 20
self._frameModel.flattenStrong()
self.gatherableFactory = CogdoFlyingGatherableFactory()
self.obstacleFactory = CogdoFlyingObtacleFactory()
return
def getExit(self):
return self._exit
def getBounds(self):
return ((self.leftLimit, self.rightLimit),
(self.backLimit, self.forwardLimit), (self.downLimit,
self.upLimit))
def getGatherable(self, serialNum):
for quadrant in self.quadrants:
for gatherable in quadrant.gatherables:
if gatherable.serialNum == serialNum:
return gatherable
return None
def ready(self):
self.gatherableFactory.destroy()
del self.gatherableFactory
self.obstacleFactory.destroy()
del self.obstacleFactory
self._initStartEndPlatforms()
self._frameModel.reparentTo(self.root)
self.root.reparentTo(self.parent)
self.root.stash()
def _initStartEndPlatforms(self):
self.startPlatform = CogdoFlyingPlatform(
self._startPlatformModel,
Globals.Level.PlatformTypes.StartPlatform)
self.endPlatform = CogdoFlyingPlatform(
self._endPlatformModel, Globals.Level.PlatformTypes.EndPlatform)
self._endPlatformModel.setY(self.convertQuadNumToY(self._numQuads))
self.backLimit = self._startPlatformModel.getY(
render) - Globals.Level.StartPlatformLength * 0.7
self.forwardLimit = self._endPlatformModel.getY(
render) + Globals.Level.EndPlatformLength * 0.7
def _initCollisions(self):
self.collPlane = CollisionPlane(
Plane(Vec3(0, 0, 1.0), Point3(0, 0, 10)))
self.collPlane.setTangible(0)
self.collNode = CollisionNode('fogPlane')
self.collNode.setIntoCollideMask(OTPGlobals.FloorBitmask)
self.collNode.addSolid(self.collPlane)
self.collNodePath = self.root.attachNewNode(self.collNode)
self.collNodePath.hide()
def destroy(self):
del self.collPlane
self.collNodePath.removeNode()
del self.collNodePath
del self.collNode
for quadrant in self.quadrants:
quadrant.destroy()
self._exit.destroy()
del self._exit
self.root.removeNode()
del self.root
def onstage(self):
self.root.unstash()
self.update(0.0)
def offstage(self):
self.root.stash()
def start(self, startTime=0.0):
self._startTime = startTime
def stop(self):
pass
def getLength(self):
return self.quadLengthUnits * self.getNumQuadrants()
def appendQuadrant(self, model):
quadrant = CogdoFlyingLevelQuadrant(self._numQuads, model, self,
self.root)
if self._numQuads == 0:
quadrant.generateGatherables(self._startPlatformModel)
quadrant.offstage()
self.quadrants.append(quadrant)
self._numQuads = len(self.quadrants)
def getNumQuadrants(self):
return self._numQuads
def setCamera(self, camera):
self._camera = camera
def getCameraActualQuadrant(self):
camY = self._camera.getY(render)
y = self.root.getY(render)
return self.convertYToQuadNum(camY - y)
def update(self, dt=0.0):
if self._camera is None:
return
quadNum = clamp(self.getCameraActualQuadrant(), 0, self._numQuads - 1)
if quadNum < self._numQuads:
self.quadrants[quadNum].update(dt)
if quadNum + 1 < self._numQuads:
self.quadrants[quadNum + 1].update(dt)
if quadNum != self._currentQuadNum:
self._switchToQuadrant(quadNum)
return
def _switchToQuadrant(self, quadNum):
self.visibleQuadIndices = []
if quadNum >= 0:
if quadNum > 0:
self.quadrants[max(quadNum - self.quadVisibiltyBehind,
0)].onstage()
for i in range(
quadNum,
min(quadNum + self.quadVisibiltyAhead + 1,
self._numQuads)):
self.quadrants[i].onstage()
self.visibleQuadIndices.append(i)
if i == 0:
self.startPlatform.onstage()
elif i == self._numQuads - 1:
self.endPlatform.onstage()
self._currentQuadNum = quadNum
for i in range(
0, max(
self._currentQuadNum - self.quadVisibiltyBehind,
0)) + range(
min(self._currentQuadNum + self.quadVisibiltyAhead + 1,
self._numQuads), self._numQuads):
self.quadrants[i].offstage()
if i == 0:
self.startPlatform.offstage()
elif i == self._numQuads - 1:
self.endPlatform.offstage()
def convertQuadNumToY(self, quadNum):
return quadNum * self.quadLengthUnits
def convertYToQuadNum(self, y):
return int(y / self.quadLengthUnits)
def convertCenterYToQuadNum(self, y):
return self.convertYToQuadNum(y + self._halfQuadLengthUnits)
class CogdoFlyingLevel(DirectObject):
notify = directNotify.newCategory('CogdoFlyingLevel')
def __init__(self, parent, frameModel, startPlatformModel, endPlatformModel, quadLengthUnits, quadVisibilityAhead, quadVisibiltyBehind):
self.parent = parent
self.quadLengthUnits = quadLengthUnits
self._halfQuadLengthUnits = quadLengthUnits / 2.0
self.quadVisibiltyAhead = quadVisibilityAhead
self.quadVisibiltyBehind = quadVisibiltyBehind
self._frameModel = frameModel
self.root = NodePath('CogdoFlyingLevel')
self.quadrantRoot = NodePath('QuadrantsRoot')
self.quadrantRoot.reparentTo(self.root)
self._startPlatformModel = startPlatformModel
self._startPlatformModel.reparentTo(self.root)
self._startPlatformModel.setZ(Globals.Level.StartPlatformHeight)
self._endPlatformModel = endPlatformModel
self._endPlatformModel.reparentTo(self.root)
self._endPlatformModel.setZ(Globals.Level.EndPlatformHeight)
self.wallR = self._frameModel.find('**/wallR')
self.wallL = self._frameModel.find('**/wallL')
self._exit = CogdoGameExit()
self._exit.reparentTo(self._endPlatformModel)
loc = self._endPlatformModel.find('**/exit_loc')
offset = loc.getPos(render)
self._exit.setPos(render, offset)
self.quadrants = []
self.visibleQuadIndices = []
self._numQuads = 0
self._currentQuadNum = -1
self._camera = None
self._initCollisions()
self.upLimit = self._frameModel.find('**/limit_up').getZ(render)
self.downLimit = self._frameModel.find('**/limit_down').getZ(render)
self.leftLimit = self._frameModel.find('**/limit_left').getX(render) - 30.0
self.rightLimit = self._frameModel.find('**/limit_right').getX(render) + 30.0
self.backLimit = -self.quadLengthUnits
self.forwardLimit = self.quadLengthUnits * 20
self._frameModel.flattenStrong()
self.gatherableFactory = CogdoFlyingGatherableFactory()
self.obstacleFactory = CogdoFlyingObstacleFactory()
return
def getExit(self):
return self._exit
def getBounds(self):
return ((self.leftLimit, self.rightLimit), (self.backLimit, self.forwardLimit), (self.downLimit, self.upLimit))
def getGatherable(self, serialNum):
for quadrant in self.quadrants:
for gatherable in quadrant.gatherables:
if gatherable.serialNum == serialNum:
return gatherable
return None
def ready(self):
self.gatherableFactory.destroy()
del self.gatherableFactory
self.obstacleFactory.destroy()
del self.obstacleFactory
self._initStartEndPlatforms()
self._frameModel.reparentTo(self.root)
self.root.reparentTo(self.parent)
self.root.stash()
def _initStartEndPlatforms(self):
self.startPlatform = CogdoFlyingPlatform(self._startPlatformModel, Globals.Level.PlatformTypes.StartPlatform)
self.endPlatform = CogdoFlyingPlatform(self._endPlatformModel, Globals.Level.PlatformTypes.EndPlatform)
self._endPlatformModel.setY(self.convertQuadNumToY(self._numQuads))
self.backLimit = self._startPlatformModel.getY(render) - Globals.Level.StartPlatformLength * 0.7
self.forwardLimit = self._endPlatformModel.getY(render) + Globals.Level.EndPlatformLength * 0.7
def _initCollisions(self):
self.collPlane = CollisionPlane(Plane(Vec3(0, 0, 1.0), Point3(0, 0, 10)))
self.collPlane.setTangible(0)
self.collNode = CollisionNode('fogPlane')
self.collNode.setIntoCollideMask(OTPGlobals.FloorBitmask)
self.collNode.addSolid(self.collPlane)
self.collNodePath = self.root.attachNewNode(self.collNode)
self.collNodePath.hide()
def destroy(self):
del self.collPlane
self.collNodePath.removeNode()
del self.collNodePath
del self.collNode
for quadrant in self.quadrants:
quadrant.destroy()
self._exit.destroy()
del self._exit
self.root.removeNode()
del self.root
def onstage(self):
self.root.unstash()
self.update(0.0)
def offstage(self):
self.root.stash()
def start(self, startTime = 0.0):
self._startTime = startTime
def stop(self):
pass
def getLength(self):
return self.quadLengthUnits * self.getNumQuadrants()
def appendQuadrant(self, model):
quadrant = CogdoFlyingLevelQuadrant(self._numQuads, model, self, self.root)
if self._numQuads == 0:
quadrant.generateGatherables(self._startPlatformModel)
quadrant.offstage()
self.quadrants.append(quadrant)
self._numQuads = len(self.quadrants)
def getNumQuadrants(self):
return self._numQuads
def setCamera(self, camera):
self._camera = camera
def getCameraActualQuadrant(self):
camY = self._camera.getY(render)
y = self.root.getY(render)
return self.convertYToQuadNum(camY - y)
def update(self, dt = 0.0):
if self._camera is None:
return
else:
quadNum = clamp(self.getCameraActualQuadrant(), 0, self._numQuads - 1)
if quadNum < self._numQuads:
self.quadrants[quadNum].update(dt)
if quadNum + 1 < self._numQuads:
self.quadrants[quadNum + 1].update(dt)
if quadNum != self._currentQuadNum:
self._switchToQuadrant(quadNum)
return
def _switchToQuadrant(self, quadNum):
self.visibleQuadIndices = []
if quadNum >= 0:
if quadNum > 0:
self.quadrants[max(quadNum - self.quadVisibiltyBehind, 0)].onstage()
for i in xrange(quadNum, min(quadNum + self.quadVisibiltyAhead + 1, self._numQuads)):
self.quadrants[i].onstage()
self.visibleQuadIndices.append(i)
if i == 0:
self.startPlatform.onstage()
elif i == self._numQuads - 1:
self.endPlatform.onstage()
self._currentQuadNum = quadNum
for i in range(0, max(self._currentQuadNum - self.quadVisibiltyBehind, 0)) + range(min(self._currentQuadNum + self.quadVisibiltyAhead + 1, self._numQuads), self._numQuads):
self.quadrants[i].offstage()
if i == 0:
self.startPlatform.offstage()
elif i == self._numQuads - 1:
self.endPlatform.offstage()
def convertQuadNumToY(self, quadNum):
return quadNum * self.quadLengthUnits
def convertYToQuadNum(self, y):
return int(y / self.quadLengthUnits)
def convertCenterYToQuadNum(self, y):
return self.convertYToQuadNum(y + self._halfQuadLengthUnits)
def __init__(self):
base.cTrav = CollisionTraverser()
self.col_handler = CollisionHandlerEvent()
self.selected = -1
self.selected_node = None
self.selecteds = []
self.multi_select = False
self.multi_selecting = False
self.select_box = NodePath()
picker_node = CollisionNode("mouseRayNode")
pickerNPos = base.camera.attachNewNode(picker_node)
self.pickerRay = CollisionRay()
picker_node.addSolid(self.pickerRay)
plane_node = CollisionNode("base_plane")
plane = base.render.attachNewNode(plane_node)
self.plane_col = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0)))
picker_node.addSolid(self.pickerRay)
picker_node.setTag("rays", "mray")
base.cTrav.addCollider(pickerNPos, self.col_handler)
self.col_handler.addInPattern("%(rays)ft-into-%(type)it")
self.col_handler.addOutPattern("%(rays)ft-out-%(type)it")
self.col_handler.addAgainPattern("ray_again_all%("
"rays"
")fh%("
"type"
")ih")
self.DO = DirectObject()
self.DO.accept('mray-into-army', self.col_in_object)
self.DO.accept('mray-out-army', self.col_out_object)
self.DO.accept('mray-into-battle', self.col_in_object)
self.DO.accept('mray-out-battle', self.col_out_object)
self.DO.accept('mray-into-tower', self.col_in_object)
self.DO.accept('mray-out-tower', self.col_out_object)
self.DO.accept('ray_again_all', self.col_against_object)
if base.client == False:
self.col_handler.addInPattern("%(player)ft-into-%(player)it")
self.col_handler.addInPattern("%(type)ft-into-%(type)it")
self.DO.accept('army-into-battle', self.col_army_against_battle)
self.DO.accept('army-into-tower', self.col_army_against_tower)
self.DO.accept('1-into-2', self.col_p1_into_p2)
self.pickable = None
self.DO.accept('mouse1', self.mouse_click, ["down"])
self.DO.accept('mouse1-up', self.mouse_click, ["up"])
self.DO.accept('mouse3-up', self.mouse_order)
taskMgr.add(self.ray_update, "updatePicker")
taskMgr.add(self.task_select_check, "updatePicker")
taskMgr.add(self.get_mouse_plane_pos, "MousePositionOnPlane")
z = 0
self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, z))
self.model = loader.loadModel("models/chest.egg")
self.model.reparentTo(render)
self.model.hide()
cm = CardMaker("blah")
cm.setFrame(-100, 100, -100, 100)
pnode = render.attachNewNode(cm.generate()) #.lookAt(0, 0, -1)
pnode.hide()
