def __init__(self, mainClass): base.cTrav = CollisionTraverser('world') # collisionHandler = CollisionHandlerEvent() self.collisionHandler2 = CollisionHandlerQueue() pickerNode = CollisionNode('mouse ray CollisionNode') pickerNP = base.camera.attachNewNode(pickerNode) self.pickerRay = CollisionRay() pickerNode.addSolid(self.pickerRay) # base.cTrav.showCollisions(render) # The ray tag pickerNode.setTag('rays', 'ray1') base.cTrav.addCollider(pickerNP, self.collisionHandler2) self.tileSelected = (0, 0) self.unitSelected = None self.buildingSelected = None self.tempJob = None self.accept("mouse1", self.mouseClick1, [mainClass]) self.accept("mouse3", self.mouseClick3, [mainClass]) taskMgr.add(self.rayUpdate, "Mouse checking")
def __initSceneGraph(self): #load various texture stages of the planet self.forge_tex = TextureStage('forge') self.forge_tex.setMode(TextureStage.MDecal) self.nexus_tex = TextureStage('nexus') self.nexus_tex.setMode(TextureStage.MDecal) self.extractor_phylon_ge_tex = TextureStage('extractor_phylon_ge') self.extractor_phylon_ge_tex.setMode(TextureStage.MDecal) # Parent node for relative position (no scaling) self.point_path = self.parent_star.point_path.attachNewNode("planet_node") self.point_path.setPos(self.position) #Models & textures self.model_path = loader.loadModel("models/planets/planet_sphere") self.model_path.setTexture(SphericalBody.dead_planet_tex, 1) self.model_path.reparentTo(self.point_path) self.model_path.setScale(self.radius) self.model_path.setPythonTag('pyPlanet', self); cnode = CollisionNode("coll_sphere_node") cnode.setTag('planet', str(id(self))) #We use no displacement (0,0,0) and no scaling factor (1) cnode.addSolid(CollisionSphere(0,0,0,1)) cnode.setIntoCollideMask(BitMask32.bit(1)) # Reparenting the collision sphere so that it # matches the planet perfectly. self.cnode_path = self.model_path.attachNewNode(cnode) self.lines = LineNodePath(parent = self.parent_star.point_path, thickness = 4.0, colorVec = Vec4(1.0, 1.0, 1.0, 0.2)) self.quad_path = None
def __initSceneGraph(self): self.point_path = self.host_planet.point_path.attachNewNode("unit_center_node") self.model_path = self.point_path.attachNewNode("unit_node") self.model_path.reparentTo(self.point_path) self.model_path.setPos(Vec3(0,6,0)) self.model_path.setPythonTag('pyUnit', self) rad = 1 cnode = CollisionNode("coll_sphere_node") cnode.addSolid(CollisionBox(Point3(-rad,-rad,-rad),Point3(rad,rad,rad))) cnode.setIntoCollideMask(BitMask32.bit(1)) cnode.setTag('unit', str(id(self))) self.cnode_path = self.model_path.attachNewNode(cnode) #self.cnode_path.show() tex = loader.loadTexture("models/billboards/flare.png") cm = CardMaker('quad') cm.setFrameFullscreenQuad() self.quad_path = self.model_path.attachNewNode(cm.generate()) self.quad_path.setTexture(tex) self.quad_path.setTransparency(TransparencyAttrib.MAlpha) self.quad_path.setBillboardPointEye() self.quad_path.setColor(self.player.color)
def __init__(self, mainClass): base.cTrav = CollisionTraverser('world') # collisionHandler = CollisionHandlerEvent() self.collisionHandler2 = CollisionHandlerQueue() pickerNode=CollisionNode('mouse ray CollisionNode') pickerNP = base.camera.attachNewNode(pickerNode) self.pickerRay=CollisionRay() pickerNode.addSolid(self.pickerRay) # base.cTrav.showCollisions(render) # The ray tag pickerNode.setTag('rays','ray1') base.cTrav.addCollider(pickerNP, self.collisionHandler2) self.tileSelected = (0,0) self.unitSelected = None self.buildingSelected = None self.tempJob = None self.accept("mouse1", self.mouseClick1, [mainClass]) self.accept("mouse3", self.mouseClick3, [mainClass]) taskMgr.add(self.rayUpdate, "Mouse checking")
def __initSceneGraph(self): # Parent node for relative position (no scaling) self.point_path = render.attachNewNode("star_node") self.point_path.setPos(self.position) #For transforming the object with scaling, colors, shading, etc. # Hosting the actual 3d model object. #Models & textures self.flare_ts = TextureStage('flare') self.flare_ts.setMode(TextureStage.MModulateGlow) self.model_path = loader.loadModel("models/stars/planet_sphere") self.model_path.setTexture(SphericalBody.star_dead_tex, 1) self.model_path.reparentTo(self.point_path) self.model_path.setScale(self.radius) self.model_path.setPythonTag('pyStar', self); # Collision sphere for object picking #----------------------------------------------------- # As described in the Tut-Chessboard.py sample: "If this model was # any more complex than a single polygon, you should set up a collision # sphere around it instead." cnode = CollisionNode("coll_sphere_node") cnode.setTag('star', str(id(self))) #We use no displacement (0,0,0) and no scaling factor (1) cnode.addSolid(CollisionSphere(0,0,0,1)) cnode.setIntoCollideMask(BitMask32.bit(1)) self.cnode_path = self.model_path.attachNewNode(cnode) #For temporary testing, display collision sphere. # self.cnode_path.show() self.quad_path = None
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 init_collisions(self): base.cTrav = CollisionTraverser() self.cHandler = CollisionHandlerEvent() pickerNode = CollisionNode("mouseRayNode") pickerNPos = base.camera.attachNewNode(pickerNode) self.pickerRay = CollisionRay() pickerNode.addSolid(self.pickerRay) pickerNode.setTag("rays","ray1") base.cTrav.addCollider(pickerNPos, self.cHandler)
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 createRainDrop(self, x=0, y=0, doubleDrop=False, tripleDrop=False): # Set up line geometry for rain. id = str(uuid.uuid4()) dummy = NodePath('dummy' + id) lineSegs = LineSegs('line' + id) if self.tripleDrop: lineSegs.setThickness(3.0) elif self.doubleDrop: lineSegs.setThickness(2.0) else: lineSegs.setThickness(1.0) lineSegs.moveTo(0, 0, 0) lineSegs.drawTo(0, 0, self.deltaZ * .1) lineGeomNode = lineSegs.create() # True: gray; False: white and red. if True: lineSegs.setVertexColor(0, Vec4(1, 1, 1, .4)) lineSegs.setVertexColor(1, Vec4(.3, .3, .3, 0)) pass else: lineSegs.setVertexColor(0, Vec4(1, 1, 1, .4)) lineSegs.setVertexColor(1, Vec4(1, 0, 0, 1)) linePath = dummy.attachNewNode(lineGeomNode) linePath.setTransparency(True) linePath.reparentTo(render) # Add collision node with 'FROM' tag = 'rain' pickerNode = CollisionNode('linecnode' + id) pickerNode.setTag('FROM', 'rain') rayCollider = linePath.attachNewNode(pickerNode) # A small collision sphere is attached to the bottom of each rain drop. rayCollider.node().addSolid(CollisionSphere(0, 0, 0, .25)) #base.cTrav.addCollider(rayCollider, collisionHandler) # Sequence rain Sequence( LerpPosInterval(linePath, self.dropDuration, Point3(x, y, self.pt1.z), Point3(x, y, self.pt2.z), blendType='easeIn', fluid=1), Parallel(Func(dummy.removeNode), Func(linePath.removeNode))).start()
def createRainDrop(self, x=0, y=0, doubleDrop=False, tripleDrop=False): # Set up line geometry for rain. id = str(uuid.uuid4()) dummy = NodePath('dummy'+id) lineSegs = LineSegs('line'+id) if self.tripleDrop: lineSegs.setThickness(3.0) elif self.doubleDrop: lineSegs.setThickness(2.0) else: lineSegs.setThickness(1.0) lineSegs.moveTo(0, 0, 0) lineSegs.drawTo(0, 0, self.deltaZ*.1) lineGeomNode = lineSegs.create() # True: gray; False: white and red. if True: lineSegs.setVertexColor(0, Vec4(1, 1, 1, .4)) lineSegs.setVertexColor(1, Vec4(.3, .3, .3, 0)) pass else: lineSegs.setVertexColor(0, Vec4(1, 1, 1, .4)) lineSegs.setVertexColor(1, Vec4(1, 0, 0, 1)) linePath = dummy.attachNewNode(lineGeomNode) linePath.setTransparency(True) linePath.reparentTo(render) # Add collision node with 'FROM' tag = 'rain' pickerNode = CollisionNode('linecnode'+id) pickerNode.setTag('FROM', 'rain') rayCollider = linePath.attachNewNode(pickerNode) # A small collision sphere is attached to the bottom of each rain drop. rayCollider.node().addSolid(CollisionSphere(0, 0, 0, .25)) #base.cTrav.addCollider(rayCollider, collisionHandler) # Sequence rain Sequence( LerpPosInterval(linePath, self.dropDuration, Point3(x, y, self.pt1.z), Point3(x, y, self.pt2.z), blendType='easeIn', fluid=1), Parallel(Func(dummy.removeNode), Func(linePath.removeNode)) ).start()
To biefly sum up what happen next, we'll make interact an invisible collision ray with two kinds of INTO objects: smileys and frowneys. The FROM ray will generate collision events as soon as touch each INTO object moving the mouse pointer over, routing toward different function handlers depending on the object group the object belongs (smiley or frowney). All of this is efficiently achieved using tags and special collision patterns, using therefore a slightly different setup from what we used to see so far in previous steps. """ #========================================================================= #** Collision events ignition base.cTrav=CollisionTraverser() collisionHandler = CollisionHandlerEvent() #** Setting the ray collider - see step5.py for details pickerNode=CollisionNode('mouseraycnode') pickerNP=base.camera.attachNewNode(pickerNode) pickerRay=CollisionRay() pickerNode.addSolid(pickerRay) #** This is new stuff: we set here a so called 'tag' for the ray - its purpose is to make the ray recognizable in a different event pattern matching situation from what we are used to use so far. Just note the first parameter is the main object grouping. See details below setting the patterns. pickerNode.setTag('rays','ray1') base.cTrav.addCollider(pickerNP, collisionHandler) #** This function is used to create all our smileys in the scene - I won't get into the basic commands that should be clear if you passed by the previous steps. def smileyMachine(n, pos): smileyModel = loader.loadModel('smiley') smileyModel.setName('Smiley#%d'%n) smileyModel.reparentTo(render) smileyModel.setPos(pos) smileyCollider = smileyModel.attachNewNode(CollisionNode('smileycnode%d'%n)) smileyCollider.node().addSolid(CollisionSphere(0, 0, 0, 1)) # we set here the tag to recognize later all the smileys - just note to remember later that the grouping it belongs is called 'balls' and the value tells it is 'smileys'. smileyCollider.setTag('balls', 'smiley') #** as the above this is a dispenser for the frowney objects def frowneyMachine(n, pos):
camXMove = 0 camMovingX = False camMovingY = False camSpeed = 1 base.disableMouse() base.cTrav = CollisionTraverser() cHandler = CollisionHandlerEvent() pickerNode = CollisionNode("mouseRayNode") pickerNPos = base.camera.attachNewNode(pickerNode) pickerRay = CollisionRay() pickerNode.addSolid(pickerRay) pickerNode.setTag("rays","ray1") base.cTrav.addCollider(pickerNPos, cHandler) countBuilding = 0 buildingName = [] buildingX = [] buildingY = [] def createBuilding(num,name,x,y): oBuilding = loader.loadModel("frowney") oBuilding.setName(name) oBuilding.reparentTo(render) oBuilding.setPos((x,y,1)) oBuildingCol = oBuilding.attachNewNode(CollisionNode("BuildingCNode%d"%num))
class world(DirectObject): def __init__(self): base.disableMouse() base.camLens.setFar(100) self.parserClass = Parser.Parser() # Making the required instances self.mapLoaderClass = mapLoader.mapLoader(self) self.gameObjects = {} self.gameObjectID = 0 self.mapX = self.mapLoaderClass.mapConfigParser.getint("map", "width") - 1 # Name says it all really self.mapY = self.mapLoaderClass.mapConfigParser.getint("map", "height") - 1 self.modelLoaderClass = modelLoader.modelLoader(self) self.cameraClass = stratCam.CameraHandler(self) self.mouseClass = stratCam.mouseHandler(self) self.GUI = stratCam.GUI(self) # self.GUI = stratCam.GUI(self) self.priorities = priorities.priorities() base.setFrameRateMeter(True) ############### base.cTrav2 = CollisionTraverser('world2') # base.cTrav2.showCollisions(render) self.heightRay = CollisionRay() # A collision ray, used for getting the height of the terrain self.heightRay.setOrigin(0,0,100) self.heightRay.setDirection(0,0,-1) self.heightCol = CollisionNode('unit Ray') self.heightCol.addSolid(self.heightRay) self.heightCol.setTag('units','ray1') self.heightCol.setFromCollideMask(BitMask32.bit(0)) # self.heightCol.setIntoCollideMask(BitMask32.allOff()) self.heightColNp = render.attachNewNode(self.heightCol) self.heightColNp.setPos(2,2,0) self.heightHandler = CollisionHandlerQueue() base.cTrav2.addCollider(self.heightColNp, self.heightHandler) ############### # myFrame = DirectFrame(frameColor=(0, 0, 0, 1), # frameSize=(-0.25, 0.25, -1, 1), # pos=(1.08, 0, 0)) # button = DirectButton(text = ("button"), scale = 0.1) # button.reparentTo(myFrame) # button.setPos(0, 0, 0.9) self.grids = astar.grid(self) self.unitHandler = unitHandler.world(self) # self.unitHandler.addUnit(0, (10,10,5), self) # self.unitHandler.addUnit(1, (6,10,5), self) # self.unitHandler.moveTo(self, (6, 34), 0) # self.unitHandler.moveTo(self, (34, 30), 1) self.buildingHandler = buildingHandler.buildingHandler(self) self.tileSelected = (0,0) taskMgr.add(self.tskCheckWalls, "Wall checking") taskMgr.add(self.priorities.jobTask, "Jobs", extraArgs = [self]) self.loadLight() self.accept("escape", sys.exit) self.accept("1", self.unitHandler.addUnit2, extraArgs = [0, self]) self.accept("2", self.unitHandler.addUnit2, extraArgs = [1, self]) self.accept("3", self.unitHandler.addUnit2, extraArgs = [2, self]) self.accept("enter", self.buildingHandler.addBuilding2, extraArgs = [self, 0]) self.accept("p", self.priorities.addJob) print 'END OF GAMEMAIN.PY!' def tskCheckWalls(self, task): for row in self.mapLoaderClass.tileArray: for tile in row: if (tile.solid == True): aroundNo = 0 # if (tile.solidMap[1] == True): # aroundNo += 1 # if (tile.solidMap[3] == True): # aroundNo += 1 # if (tile.solidMap[5] == True): # aroundNo += 1 # if (tile.solidMap[7] == True): # aroundNo += 1 for i in tile.solidMap: if (i == True): aroundNo += 1 if ((tile.solidMap[1] == True and # If only supported by 1 other solid tile.solidMap[3] == False and tile.solidMap[5] == False and tile.solidMap[7] == False) or (tile.solidMap[1] == False and tile.solidMap[3] == True and tile.solidMap[5] == False and tile.solidMap[7] == False) or (tile.solidMap[1] == False and tile.solidMap[3] == False and tile.solidMap[5] == True and tile.solidMap[7] == False) or (tile.solidMap[1] == False and tile.solidMap[3] == False and tile.solidMap[5] == False and tile.solidMap[7] == True) or (tile.solidMap[1] == True and tile.solidMap[3] == False and tile.solidMap[5] == False and tile.solidMap[7] == True) or (tile.solidMap[1] == False and tile.solidMap[3] == True and tile.solidMap[5] == True and tile.solidMap[7] == False) or#): (aroundNo < 3)): #(tile.modelName[0:13] == 'solid no work')): self.mineWall(tile) return Task.cont def mineWall(self, firstTile): def changer(firstTile, finalTileNumber): firstTile.model.detachNode() finalTileData = self.parserClass.wall[self.parserClass.main['wall_types'][finalTileNumber]] finalTile = copy.copy(finalTileData) finalTile.posX = firstTile.posX finalTile.posY = firstTile.posY finalTile.posZ = firstTile.posZ finalTile.cornerMap = firstTile.cornerMap finalTile.solidMap = firstTile.solidMap finalTile.reda = 0 finalTile.renu = 0 print finalTile.posX/4, finalTile.posY/4 if (finalTileData.solid == False): finalTile.solidMap[4] == False if (finalTile.walkable == True): # Change the meshes for the new tile self.grids.landMesh[finalTile.posY/4][finalTile.posX/4] = True else: self.grids.landMesh[finalTile.posY/4][finalTile.posX/4] = False if (finalTile.water == True): self.grids.waterMesh[finalTile.posY/4][finalTile.posX/4] = True else: self.grids.waterMesh[finalTile.posY/4][finalTile.posX/4] = False if (finalTile.lava == True) or (finalTile.water == True) or (finalTile.walkable == True): self.grids.airMesh[finalTile.posY/4][finalTile.posX/4] = True else: self.grids.airMesh[finalTile.posY/4][finalTile.posX/4] = False elif (finalTileData.solid == True): finalTile.solidMap[4] == True self.grids.landMesh[finalTile.posY/4][finalTile.posX/4] = True self.grids.waterMesh[finalTile.posY/4][finalTile.posX/4] = True self.grids.airMesh[finalTile.posY/4][finalTile.posX/4] = True finalTile.model = self.modelLoaderClass.makeModel(finalTile, self)#, mapLoaderClass) # From here on is reparenting and positioning the tile to the right place finalTile.model.reparentTo(render) finalTile.model.setPos(finalTile.posX, finalTile.posY, 0) finalTile.model.setCollideMask(0x1) tex = loader.loadTexture(finalTile.texture) finalTile.model.setTexture(tex, 1) if (firstTile.renu != 0): print self.parserClass.main['objects'][firstTile.reda], firstTile.renu for i in range(firstTile.renu): self.modelLoaderClass.addObject(self, firstTile.reda, finalTile) return finalTile self.mapLoaderClass.tileArray[firstTile.posY/4][firstTile.posX/4] = changer(firstTile, 0) self.reloadSurround(self.mapLoaderClass.tileArray[firstTile.posY/4][firstTile.posX/4]) def reloadSurround(self, tileChanged): aroundInfo = [] yBehind = tileChanged.posY/4 - 1 yInfront = tileChanged.posY/4 +1 xBehind = tileChanged.posX/4 - 1 xInfront = tileChanged.posX/4 + 1 if (yInfront >= self.mapY-1): yInfront = self.mapY-1 if (yBehind <= 0): yBehind = 0 if (xInfront >= self.mapX-1): xInfront = self.mapX-1 if (xBehind <= 0): xBehind = 0 aroundInfo.append(self.mapLoaderClass.tileArray[yBehind][xBehind]) # BL aroundInfo.append(self.mapLoaderClass.tileArray[yBehind][tileChanged.posX/4]) # BC aroundInfo.append(self.mapLoaderClass.tileArray[yBehind][xInfront]) # BR aroundInfo.append(self.mapLoaderClass.tileArray[tileChanged.posY/4][xBehind]) # L aroundInfo.append(self.mapLoaderClass.tileArray[tileChanged.posY/4][tileChanged.posX/4-1]) aroundInfo.append(self.mapLoaderClass.tileArray[tileChanged.posY/4][xInfront]) # R aroundInfo.append(self.mapLoaderClass.tileArray[yInfront][xBehind]) # TL aroundInfo.append(self.mapLoaderClass.tileArray[yInfront][tileChanged.posX/4]) # TC aroundInfo.append(self.mapLoaderClass.tileArray[yInfront][xInfront]) # TR name = self.mapLoaderClass.tileArray[tileChanged.posY/4+1][tileChanged.posX/4+1].modelName for around in aroundInfo: around.solidMap = self.modelLoaderClass.reloadSolidMap(self, around.posX/4, around.posY/4) around.model.remove() around.model = self.modelLoaderClass.makeModel(around, self) around.model.setCollideMask(0x01) around.model.reparentTo(render) around.model.setPos(around.posX, around.posY, 0) tex = loader.loadTexture(around.texture) around.model.setTexture(tex, 1) def loadLight(self): #Sets the lights plight = AmbientLight('my plight') light = self.parserClass.userConfig.getfloat('display', 'light') plight.setColor(VBase4(light,light,light,0.5)) plnp = render.attachNewNode(plight) render.setLight(plnp)
def init_nodepath(self): # Load the environment model. self.environ = loader.loadModel("models/env03") # water self.water = loader.loadModel('models/square') self.water.setSx(400 * 2) self.water.setSy(400 * 2) self.water.setPos(0, 80, -1) # sea level self.water.setTransparency(TransparencyAttrib.MAlpha) newTS = TextureStage('1') self.water.setTexture(newTS, loader.loadTexture('models/water.png')) self.water.setTexScale(newTS, 4) self.water.reparentTo(render) LerpTexOffsetInterval(self.water, 50, (1, 0), (0, 0), textureStage=newTS).loop() # Our sky self.skysphere = loader.loadModel('models/blue-sky-sphere') self.skysphere.setEffect(CompassEffect.make(render)) self.skysphere.setScale(0.05) # NOT render or you'll fly through the sky!: self.skysphere.reparentTo(base.camera) # Reparent the model to render. self.environ.reparentTo(render) # Apply scale and position transforms on the model. self.environ.setScale(1, 1, 1) self.environ.setPos(37, 48, 0) self.environ.setHpr(270, 0, 0) self.environ.setTwoSided(True) # fog colour = (0.1, 0.1, 0.1) expfog = Fog("scene-wide-fog") expfog.setColor(*colour) expfog.setExpDensity(0.01) render.setFog(expfog) # Set Rain Boundaries mapCollision = CollisionNode('mapcnode') mapCollision.setTag('INTO', 'map') self.pt1, self.pt2 = self.environ.getTightBounds() self.deltaX = self.pt2.x - self.pt1.x self.deltaY = self.pt2.y - self.pt1.y self.deltaZ = 1000 # Set up rain effect initialization self.spawnEveryXSeconds = .001 self.spawnXDrops = 4 self.dropDuration = .2 self.percentChanceOfImpactCircle = .8 self.percentChanceOfImpactFog = .5 self.percentChanceOfDoubleDrop = .8 self.percentChanceOfTripleDrop = .2 # base.setBackgroundColor(*colour) self.nodePath = render.attachNewNode('World') self.init_lights() self.init_camera() self.terrain.init_nodepath() for team in self.teams: for character in team.characters: character.init_nodepath() # create rain taskMgr.doMethodLater(0, self.makeItRain, 'make-it-rain')
class world(DirectObject): def __init__(self): base.disableMouse() base.camLens.setFar(100) self.parserClass = Parser.Parser() # Making the required instances self.mapLoaderClass = mapLoader.mapLoader(self) self.gameObjects = {} self.gameObjectID = 0 self.mapX = self.mapLoaderClass.mapConfigParser.getint( "map", "width") - 1 # Name says it all really self.mapY = self.mapLoaderClass.mapConfigParser.getint( "map", "height") - 1 self.modelLoaderClass = modelLoader.modelLoader(self) self.cameraClass = stratCam.CameraHandler(self) self.mouseClass = stratCam.mouseHandler(self) self.GUI = stratCam.GUI(self) # self.GUI = stratCam.GUI(self) self.priorities = priorities.priorities() base.setFrameRateMeter(True) ############### base.cTrav2 = CollisionTraverser('world2') # base.cTrav2.showCollisions(render) self.heightRay = CollisionRay( ) # A collision ray, used for getting the height of the terrain self.heightRay.setOrigin(0, 0, 100) self.heightRay.setDirection(0, 0, -1) self.heightCol = CollisionNode('unit Ray') self.heightCol.addSolid(self.heightRay) self.heightCol.setTag('units', 'ray1') self.heightCol.setFromCollideMask(BitMask32.bit(0)) # self.heightCol.setIntoCollideMask(BitMask32.allOff()) self.heightColNp = render.attachNewNode(self.heightCol) self.heightColNp.setPos(2, 2, 0) self.heightHandler = CollisionHandlerQueue() base.cTrav2.addCollider(self.heightColNp, self.heightHandler) ############### # myFrame = DirectFrame(frameColor=(0, 0, 0, 1), # frameSize=(-0.25, 0.25, -1, 1), # pos=(1.08, 0, 0)) # button = DirectButton(text = ("button"), scale = 0.1) # button.reparentTo(myFrame) # button.setPos(0, 0, 0.9) self.grids = astar.grid(self) self.unitHandler = unitHandler.world(self) # self.unitHandler.addUnit(0, (10,10,5), self) # self.unitHandler.addUnit(1, (6,10,5), self) # self.unitHandler.moveTo(self, (6, 34), 0) # self.unitHandler.moveTo(self, (34, 30), 1) self.buildingHandler = buildingHandler.buildingHandler(self) self.tileSelected = (0, 0) taskMgr.add(self.tskCheckWalls, "Wall checking") taskMgr.add(self.priorities.jobTask, "Jobs", extraArgs=[self]) self.loadLight() self.accept("escape", sys.exit) self.accept("1", self.unitHandler.addUnit2, extraArgs=[0, self]) self.accept("2", self.unitHandler.addUnit2, extraArgs=[1, self]) self.accept("3", self.unitHandler.addUnit2, extraArgs=[2, self]) self.accept("enter", self.buildingHandler.addBuilding2, extraArgs=[self, 0]) self.accept("p", self.priorities.addJob) print 'END OF GAMEMAIN.PY!' def tskCheckWalls(self, task): for row in self.mapLoaderClass.tileArray: for tile in row: if (tile.solid == True): aroundNo = 0 # if (tile.solidMap[1] == True): # aroundNo += 1 # if (tile.solidMap[3] == True): # aroundNo += 1 # if (tile.solidMap[5] == True): # aroundNo += 1 # if (tile.solidMap[7] == True): # aroundNo += 1 for i in tile.solidMap: if (i == True): aroundNo += 1 if (( tile.solidMap[1] == True and # If only supported by 1 other solid tile.solidMap[3] == False and tile.solidMap[5] == False and tile.solidMap[7] == False) or (tile.solidMap[1] == False and tile.solidMap[3] == True and tile.solidMap[5] == False and tile.solidMap[7] == False) or (tile.solidMap[1] == False and tile.solidMap[3] == False and tile.solidMap[5] == True and tile.solidMap[7] == False) or (tile.solidMap[1] == False and tile.solidMap[3] == False and tile.solidMap[5] == False and tile.solidMap[7] == True) or (tile.solidMap[1] == True and tile.solidMap[3] == False and tile.solidMap[5] == False and tile.solidMap[7] == True) or (tile.solidMap[1] == False and tile.solidMap[3] == True and tile.solidMap[5] == True and tile.solidMap[7] == False) or #): (aroundNo < 3)): #(tile.modelName[0:13] == 'solid no work')): self.mineWall(tile) return Task.cont def mineWall(self, firstTile): def changer(firstTile, finalTileNumber): firstTile.model.detachNode() finalTileData = self.parserClass.wall[ self.parserClass.main['wall_types'][finalTileNumber]] finalTile = copy.copy(finalTileData) finalTile.posX = firstTile.posX finalTile.posY = firstTile.posY finalTile.posZ = firstTile.posZ finalTile.cornerMap = firstTile.cornerMap finalTile.solidMap = firstTile.solidMap finalTile.reda = 0 finalTile.renu = 0 print finalTile.posX / 4, finalTile.posY / 4 if (finalTileData.solid == False): finalTile.solidMap[4] == False if (finalTile.walkable == True ): # Change the meshes for the new tile self.grids.landMesh[finalTile.posY / 4][finalTile.posX / 4] = True else: self.grids.landMesh[finalTile.posY / 4][finalTile.posX / 4] = False if (finalTile.water == True): self.grids.waterMesh[finalTile.posY / 4][finalTile.posX / 4] = True else: self.grids.waterMesh[finalTile.posY / 4][finalTile.posX / 4] = False if (finalTile.lava == True) or (finalTile.water == True) or (finalTile.walkable == True): self.grids.airMesh[finalTile.posY / 4][finalTile.posX / 4] = True else: self.grids.airMesh[finalTile.posY / 4][finalTile.posX / 4] = False elif (finalTileData.solid == True): finalTile.solidMap[4] == True self.grids.landMesh[finalTile.posY / 4][finalTile.posX / 4] = True self.grids.waterMesh[finalTile.posY / 4][finalTile.posX / 4] = True self.grids.airMesh[finalTile.posY / 4][finalTile.posX / 4] = True finalTile.model = self.modelLoaderClass.makeModel( finalTile, self ) #, mapLoaderClass) # From here on is reparenting and positioning the tile to the right place finalTile.model.reparentTo(render) finalTile.model.setPos(finalTile.posX, finalTile.posY, 0) finalTile.model.setCollideMask(0x1) tex = loader.loadTexture(finalTile.texture) finalTile.model.setTexture(tex, 1) if (firstTile.renu != 0): print self.parserClass.main['objects'][ firstTile.reda], firstTile.renu for i in range(firstTile.renu): self.modelLoaderClass.addObject(self, firstTile.reda, finalTile) return finalTile self.mapLoaderClass.tileArray[firstTile.posY / 4][firstTile.posX / 4] = changer( firstTile, 0) self.reloadSurround(self.mapLoaderClass.tileArray[firstTile.posY / 4][firstTile.posX / 4]) def reloadSurround(self, tileChanged): aroundInfo = [] yBehind = tileChanged.posY / 4 - 1 yInfront = tileChanged.posY / 4 + 1 xBehind = tileChanged.posX / 4 - 1 xInfront = tileChanged.posX / 4 + 1 if (yInfront >= self.mapY - 1): yInfront = self.mapY - 1 if (yBehind <= 0): yBehind = 0 if (xInfront >= self.mapX - 1): xInfront = self.mapX - 1 if (xBehind <= 0): xBehind = 0 aroundInfo.append( self.mapLoaderClass.tileArray[yBehind][xBehind]) # BL aroundInfo.append( self.mapLoaderClass.tileArray[yBehind][tileChanged.posX / 4]) # BC aroundInfo.append( self.mapLoaderClass.tileArray[yBehind][xInfront]) # BR aroundInfo.append(self.mapLoaderClass.tileArray[tileChanged.posY / 4][xBehind]) # L aroundInfo.append( self.mapLoaderClass.tileArray[tileChanged.posY / 4][tileChanged.posX / 4 - 1]) aroundInfo.append(self.mapLoaderClass.tileArray[tileChanged.posY / 4][xInfront]) # R aroundInfo.append( self.mapLoaderClass.tileArray[yInfront][xBehind]) # TL aroundInfo.append( self.mapLoaderClass.tileArray[yInfront][tileChanged.posX / 4]) # TC aroundInfo.append( self.mapLoaderClass.tileArray[yInfront][xInfront]) # TR name = self.mapLoaderClass.tileArray[tileChanged.posY / 4 + 1][tileChanged.posX / 4 + 1].modelName for around in aroundInfo: around.solidMap = self.modelLoaderClass.reloadSolidMap( self, around.posX / 4, around.posY / 4) around.model.remove() around.model = self.modelLoaderClass.makeModel(around, self) around.model.setCollideMask(0x01) around.model.reparentTo(render) around.model.setPos(around.posX, around.posY, 0) tex = loader.loadTexture(around.texture) around.model.setTexture(tex, 1) def loadLight(self): #Sets the lights plight = AmbientLight('my plight') light = self.parserClass.userConfig.getfloat('display', 'light') plight.setColor(VBase4(light, light, light, 0.5)) plnp = render.attachNewNode(plight) render.setLight(plnp)
To biefly sum up what happen next, we'll make interact an invisible collision ray with two kinds of INTO objects: smileys and frowneys. The FROM ray will generate collision events as soon as touch each INTO object moving the mouse pointer over, routing toward different function handlers depending on the object group the object belongs (smiley or frowney). All of this is efficiently achieved using tags and special collision patterns, using therefore a slightly different setup from what we used to see so far in previous steps. """ #========================================================================= #** Collision events ignition base.cTrav = CollisionTraverser() collisionHandler = CollisionHandlerEvent() #** Setting the ray collider - see step5.py for details pickerNode = CollisionNode('mouseraycnode') pickerNP = base.camera.attachNewNode(pickerNode) pickerRay = CollisionRay() pickerNode.addSolid(pickerRay) #** This is new stuff: we set here a so called 'tag' for the ray - its purpose is to make the ray recognizable in a different event pattern matching situation from what we are used to use so far. Just note the first parameter is the main object grouping. See details below setting the patterns. pickerNode.setTag('rays', 'ray1') base.cTrav.addCollider(pickerNP, collisionHandler) #** This function is used to create all our smileys in the scene - I won't get into the basic commands that should be clear if you passed by the previous steps. def smileyMachine(n, pos): smileyModel = loader.loadModel('smiley') smileyModel.setName('Smiley#%d' % n) smileyModel.reparentTo(render) smileyModel.setPos(pos) smileyCollider = smileyModel.attachNewNode( CollisionNode('smileycnode%d' % n)) smileyCollider.node().addSolid(CollisionSphere(0, 0, 0, 1)) # we set here the tag to recognize later all the smileys - just note to remember later that the grouping it belongs is called 'balls' and the value tells it is 'smileys'. smileyCollider.setTag('balls', 'smiley')
def __init__(self, parserClass, mapLoaderClass, modelLoaderClass, mainClass, mapWidth, mapHeight, scrollborder, zoomInSpeed, zoomOutSpeed, zoomMax, zoomMin): self.zoomMax = zoomMax self.zoomMin = zoomMin base.disableMouse() # This disables the default mouse based camera control used by panda. This default control is awkward, and won't be used. base.camera.setPos(10,20,10) base.camera.lookAt(0,0,0) # Gives the camera an initial position and rotation. self.mx,self.my = 0,0 # Sets up variables for storing the mouse coordinates self.orbiting = False # A boolean variable for specifying whether the camera is in orbiting mode. Orbiting mode refers to when the camera is being moved # because the user is holding down the right mouse button. self.target = Vec3() # sets up a vector variable for the camera's target. The target will be the coordinates that the camera is currently focusing on. self.camDist = 20 # A variable that will determine how far the camera is from it's target focus self.panRateDivisor = 100. # This variable is used as a divisor when calculating how far to move the camera when panning. Higher numbers will yield slower panning # and lower numbers will yield faster panning. This must not be set to 0. self.panZoneSize = scrollborder # This variable controls how close the mouse cursor needs to be to the edge of the screen to start panning the camera. It must be less than 1, # and I recommend keeping it less than .2 self.panLimitsX = Vec2(0, 4*mapWidth) self.panLimitsY = Vec2(0, 4*mapHeight) # These two vairables will serve as limits for how far the camera can pan, so you don't scroll away from the map. self.setTarget(0,0,0) # calls the setTarget function to set the current target position to the origin. self.turnCameraAroundPoint(0,0) # calls the turnCameraAroundPoint function with a turn amount of 0 to set the camera position based on the target and camera distance self.accept("mouse2",self.startOrbit) # sets up the camrea handler to accept a right mouse click and start the "drag" mode. self.accept("mouse2-up",self.stopOrbit) # sets up the camrea handler to understand when the right mouse button has been released, and ends the "drag" mode when # the release is detected. # The next pair of lines use lambda, which creates an on-the-spot one-shot function. self.accept("wheel_up",lambda : self.adjustCamDist(zoomInSpeed)) # sets up the camera handler to detet when the mouse wheel is rolled upwards and uses a lambda function to call the # adjustCamDist function with the argument 0.9 self.accept("wheel_down",lambda : self.adjustCamDist(zoomOutSpeed)) # sets up the camera handler to detet when the mouse wheel is rolled upwards and uses a lambda function to call the # adjustCamDist function with the argument 1.1 # ######### self.tileSelected = (0,0) #** Collision events ignition base.cTrav = CollisionTraverser() collisionHandler = CollisionHandlerEvent() self.collisionHandler2 = CollisionHandlerQueue() pickerNode=CollisionNode('mouseraycnode') pickerNP=base.camera.attachNewNode(pickerNode) self.pickerRay=CollisionRay() pickerNode.addSolid(self.pickerRay) base.cTrav.showCollisions(render) # The ray tag pickerNode.setTag('rays','ray1') base.cTrav.addCollider(pickerNP, self.collisionHandler2) self.accept("mouse1", self.mouseClick, [mapLoaderClass]) self.accept("q", self.mineWall, [parserClass, modelLoaderClass, mapLoaderClass, mainClass]) taskMgr.add(self.rayupdate, "blah") ########## taskMgr.add(self.camMoveTask,'camMoveTask')
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()
def init_nodepath(self): # Load the environment model. self.environ = loader.loadModel("models/env03") # water self.water = loader.loadModel('models/square') self.water.setSx(400*2) self.water.setSy(400*2) self.water.setPos(0, 80, -1) # sea level self.water.setTransparency(TransparencyAttrib.MAlpha) newTS = TextureStage('1') self.water.setTexture(newTS, loader.loadTexture('models/water.png')) self.water.setTexScale(newTS, 4) self.water.reparentTo(render) LerpTexOffsetInterval(self.water, 50, (1, 0), (0, 0), textureStage=newTS).loop() # Our sky self.skysphere = loader.loadModel('models/blue-sky-sphere') self.skysphere.setEffect(CompassEffect.make(render)) self.skysphere.setScale(0.05) # NOT render or you'll fly through the sky!: self.skysphere.reparentTo(base.camera) # Reparent the model to render. self.environ.reparentTo(render) # Apply scale and position transforms on the model. self.environ.setScale(1, 1, 1) self.environ.setPos(37, 48, 0) self.environ.setHpr(270, 0, 0) self.environ.setTwoSided(True) # fog colour = (0.1, 0.1, 0.1) expfog = Fog("scene-wide-fog") expfog.setColor(*colour) expfog.setExpDensity(0.01) render.setFog(expfog) # Set Rain Boundaries mapCollision = CollisionNode('mapcnode') mapCollision.setTag('INTO', 'map') self.pt1, self.pt2 = self.environ.getTightBounds() self.deltaX = self.pt2.x - self.pt1.x self.deltaY = self.pt2.y - self.pt1.y self.deltaZ = 1000 # Set up rain effect initialization self.spawnEveryXSeconds = .001 self.spawnXDrops = 4 self.dropDuration = .2 self.percentChanceOfImpactCircle = .8 self.percentChanceOfImpactFog = .5 self.percentChanceOfDoubleDrop = .8 self.percentChanceOfTripleDrop = .2 # base.setBackgroundColor(*colour) self.nodePath = render.attachNewNode('World') self.init_lights() self.init_camera() self.terrain.init_nodepath() for team in self.teams: for character in team.characters: character.init_nodepath() # create rain taskMgr.doMethodLater(0, self.makeItRain, 'make-it-rain')