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')
