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__(self, tileMap):
self._tileMap = tileMap
self._groundPlane = Plane(Point3(0, 0, 1), Point3(0, 0, 1))
self._hoveredCoord = None # The coordinates we are hovering over.
self._highlightMode = None # Targeter reference
self._highlightModeParams = None # Targeter params dict
self._highlightedTiles = list() # List of tile highlighted by pointer.
self._previewTiles = list() # List of tiles highlighted by preview.
# Perform mouse raycasting every frame:
taskMgr.add(self._updateHovered, "mouseScanning")
class YourClass(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.disableMouse()
self.pos3d=None
self.nearPoint=None
self.farPoint=None
self.camera.setPos(0, 60, 25)
self.camera.lookAt(0, 0, 0)
z = 0
self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, z))
self.model = loader.loadModel("ralph")
self.model.reparentTo(render)
self.accept("mouse1",self.set)
taskMgr.add(self.__getMousePos, "_YourClass__getMousePos")
def __getMousePos(self, task):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.pos3d = Point3()
self.nearPoint = Point3()
self.farPoint = Point3()
base.camLens.extrude(mpos, self.nearPoint, self.farPoint)
if self.plane.intersectsLine(self.pos3d,
render.getRelativePoint(camera, self.nearPoint),
render.getRelativePoint(camera, self.farPoint)):
print "Mouse ray intersects ground plane at ", self.pos3d
# self.model.setPos(render, pos3d)
return task.again
def set(self):
self.model.setPos(render, self.pos3d)
def load(self):
CogdoGameMovie.load(self)
self.toonDNA = ToonDNA.ToonDNA()
self.toonDNA.newToonFromProperties('dss', 'ss', 'm', 'm', 2, 0, 2, 2,
1, 8, 1, 8, 1, 14)
self.toonHead = Toon.Toon()
self.toonHead.setDNA(self.toonDNA)
self.makeSuit('sc')
self.toonHead.getGeomNode().setDepthWrite(1)
self.toonHead.getGeomNode().setDepthTest(1)
self.toonHead.loop('neutral')
self.toonHead.setPosHprScale(-0.73, 0, -1.27, 180, 0, 0, 0.18, 0.18,
0.18)
self.toonHead.reparentTo(hidden)
self.toonHead.startBlink()
self.cogHead = Suit.Suit()
self.cogDNA = SuitDNA.SuitDNA()
self.cogDNA.newSuit('le')
self.cogHead.setDNA(self.cogDNA)
self.cogHead.getGeomNode().setDepthWrite(1)
self.cogHead.getGeomNode().setDepthTest(1)
self.cogHead.loop('neutral')
self.cogHead.setPosHprScale(-0.74, 0, -1.79, 180, 0, 0, 0.12, 0.14,
0.14)
self.cogHead.reparentTo(hidden)
self.clipPlane = self.toonHead.attachNewNode(PlaneNode('clip'))
self.clipPlane.node().setPlane(Plane(0, 0, 1, 0))
self.clipPlane.setPos(0, 0, 2.45)
audioMgr = base.cogdoGameAudioMgr
self._cogDialogueSfx = audioMgr.createSfx('cogDialogue')
self._toonDialogueSfx = audioMgr.createSfx('toonDialogue')
def start():
camera.wrtReparentTo(render)
self._startUpdateTask()
def end():
self._stopUpdateTask()
introDuration = Globals.Gameplay.IntroDurationSeconds
dialogue = TTLocalizer.CogdoFlyingIntroMovieDialogue
waitDur = introDuration / len(dialogue)
flyDur = introDuration - waitDur * 0.5
flyThroughIval = Parallel(
camera.posInterval(flyDur,
self._exit.getPos(render) + Point3(0, -22, 1),
blendType='easeInOut'),
camera.hprInterval(flyDur, Point3(0, 5, 0), blendType='easeInOut'))
self._ival = Sequence(
Func(start),
Parallel(
flyThroughIval,
Sequence(
Func(self.displayLine, 'cog',
self._getRandomLine(dialogue[0])), Wait(waitDur),
Func(self.displayLine, 'toon',
self._getRandomLine(dialogue[1])), Wait(waitDur),
Func(self.displayLine, 'cog',
self._getRandomLine(dialogue[2])), Wait(waitDur))),
Func(end))
def load(self):
self.notify.debug('load()')
CogdoGameMovie.load(self)
backgroundGui = loader.loadModel('phase_5/models/cogdominium/tt_m_gui_csa_flyThru') # Dialogue Box
self.bg = backgroundGui.find('**/background')
self.chatBubble = backgroundGui.find('**/chatBubble')
self.chatBubble.setScale(6.5, 6.5, 7.2999999999999998)
self.chatBubble.setPos(0.32000000000000001, 0, -0.78000000000000003)
self.bg.setScale(5.2000000000000002)
self.bg.setPos(0.14000000000000001, 0, -0.66669999999999996)
self.bg.reparentTo(aspect2d)
self.chatBubble.reparentTo(aspect2d)
self.frame = DirectFrame(geom = self.bg, relief = None, pos = (0.20000000000000001, 0, -0.66669999999999996))
self.bg.wrtReparentTo(self.frame)
self.gameTitleText = DirectLabel(parent = self.frame, text = TTLocalizer.CogdoExecutiveSuiteTitle, scale = TTLocalizer.MRPgameTitleText * 0.80000000000000004, text_align = TextNode.ACenter, text_font = getSignFont(), text_fg = (1.0, 0.33000000000000002, 0.33000000000000002, 1.0), pos = TTLocalizer.MRgameTitleTextPos, relief = None)
self.chatBubble.wrtReparentTo(self.frame)
self.frame.hide()
backgroundGui.removeNode()
self.toonDNA = ToonDNA.ToonDNA()
self.toonDNA.newToonFromProperties('dss', 'ss', 'm', 'm', 2, 0, 2, 2, 1, 8, 1, 8, 1, 14) # Lowdens DNA
self.toonHead = Toon.Toon()
self.toonHead.setDNA(self.toonDNA)
self.makeSuit('sc')
self.toonHead.getGeomNode().setDepthWrite(1)
self.toonHead.getGeomNode().setDepthTest(1)
self.toonHead.loop('neutral')
self.toonHead.setPosHprScale(-0.72999999999999998, 0, -1.27, 180, 0, 0, 0.17999999999999999, 0.17999999999999999, 0.17999999999999999)
self.toonHead.reparentTo(hidden)
self.toonHead.startBlink()
self.clipPlane = self.toonHead.attachNewNode(PlaneNode('clip'))
self.clipPlane.node().setPlane(Plane(0, 0, 1, 0))
self.clipPlane.setPos(0, 0, 2.4500000000000002)
self._toonDialogueSfx = loader.loadSfx('phase_3.5/audio/dial/AV_dog_long.mp3') # Dog speech
self._camHelperNode = NodePath('CamHelperNode')
self._camHelperNode.reparentTo(render)
dialogue = TTLocalizer.CogdoExecutiveSuiteIntroMessage
def start():
self.frame.show()
base.setCellsAvailable(base.bottomCells + base.leftCells + base.rightCells, 0)
def showShopOwner():
self._setCamTarget(self._shopOwner, -10, offset = Point3(0, 0, 5))
def end():
self._dialogueLabel.reparentTo(hidden)
self.toonHead.reparentTo(hidden)
self.frame.hide()
base.setCellsAvailable(base.bottomCells + base.leftCells + base.rightCells, 1)
self._stopUpdateTask()
self._ival = Sequence(Func(start), Func(self.displayLine, dialogue), Func(showShopOwner), ParallelEndTogether(camera.posInterval(self.cameraMoveDuration, Point3(8, 0, 13), blendType = 'easeInOut'), camera.hprInterval(0.5, self._camHelperNode.getHpr(), blendType = 'easeInOut')), Wait(self.introDuration), Func(end))
self._startUpdateTask()
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 load(self):
self.notify.debug('load()')
CogdoGameMovie.load(self)
backgroundGui = loader.loadModel('phase_5/models/cogdominium/tt_m_gui_csa_flyThru')
self.bg = backgroundGui.find('**/background')
self.chatBubble = backgroundGui.find('**/chatBubble')
self.chatBubble.setScale(6.5, 6.5, 7.3)
self.chatBubble.setPos(0.32, 0, -0.78)
self.bg.setScale(5.2)
self.bg.setPos(0.14, 0, -0.6667)
self.bg.reparentTo(aspect2d)
self.chatBubble.reparentTo(aspect2d)
self.frame = DirectFrame(geom=self.bg, relief=None, pos=(0.2, 0, -0.6667))
self.bg.wrtReparentTo(self.frame)
self.gameTitleText = DirectLabel(parent=self.frame, text=TTLocalizer.CogdoBarrelRoomTitle, scale=TTLocalizer.MRPgameTitleText * 0.8, text_align=TextNode.ACenter, text_font=getSignFont(), text_fg=(1.0, 0.33, 0.33, 1.0), pos=TTLocalizer.MRgameTitleTextPos, relief=None)
self.chatBubble.wrtReparentTo(self.frame)
self.frame.hide()
backgroundGui.removeNode()
self.toonDNA = ToonDNA.ToonDNA()
self.toonDNA.newToonFromProperties('dss', 'ss', 'm', 'm', 2, 0, 2, 2, 1, 8, 1, 8, 1, 14)
self.toonHead = Toon.Toon()
self.toonHead.setDNA(self.toonDNA)
self.makeSuit('sc')
self.toonHead.getGeomNode().setDepthWrite(1)
self.toonHead.getGeomNode().setDepthTest(1)
self.toonHead.loop('neutral')
self.toonHead.setPosHprScale(-0.73, 0, -1.27, 180, 0, 0, 0.18, 0.18, 0.18)
self.toonHead.reparentTo(hidden)
self.toonHead.startBlink()
self.clipPlane = self.toonHead.attachNewNode(PlaneNode('clip'))
self.clipPlane.node().setPlane(Plane(0, 0, 1, 0))
self.clipPlane.setPos(0, 0, 2.45)
self._toonDialogueSfx = loader.loadSfx('phase_3.5/audio/dial/AV_dog_long.ogg')
self._camHelperNode = NodePath('CamHelperNode')
self._camHelperNode.reparentTo(render)
dialogue = TTLocalizer.CogdoBarrelRoomIntroDialog
def start():
self.frame.show()
base.setCellsActive(base.bottomCells + base.leftCells + base.rightCells, 0)
def end():
self._dialogueLabel.reparentTo(hidden)
self.toonHead.reparentTo(hidden)
self.frame.hide()
base.setCellsActive(base.bottomCells + base.leftCells + base.rightCells, 1)
self._stopUpdateTask()
self._ival = Sequence(Func(start), Func(self.displayLine, dialogue), Wait(CogdoBarrelRoomConsts.BarrelRoomIntroTimeout), Func(end))
self._startUpdateTask()
return
def __init__(self):
ShowBase.__init__(self)
self.disableMouse()
self.pos3d=None
self.nearPoint=None
self.farPoint=None
self.camera.setPos(0, 60, 25)
self.camera.lookAt(0, 0, 0)
z = 0
self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, z))
self.model = loader.loadModel("ralph")
self.model.reparentTo(render)
self.accept("mouse1",self.set)
taskMgr.add(self.__getMousePos, "_YourClass__getMousePos")
class CollisionManager:
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 input_init(self):
self.DO = DirectObject()
self.DO.accept('mouse1', self.mouse_click, ["1-down"])
self.DO.accept('mouse1-up', self.mouse_click, ["1-up"])
self.DO.accept('mouse3', self.mouse_click, ["3-down"])
self.DO.accept('0', self.placement_ghost.change_player, [0])
self.DO.accept('1', self.placement_ghost.change_player, [1])
self.DO.accept('2', self.placement_ghost.change_player, [2])
self.DO.accept('a', self.placement_ghost.change_type, ["army"])
self.DO.accept('t', self.placement_ghost.change_type, ["tower"])
self.DO.accept('control-s', base.xml_manager.save)
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-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)
def col_against_object(self, entry):
if entry.getIntoNodePath().getParent() != self.pickable:
np_from = entry.getFromNodePath()
np_into = entry.getIntoNodePath()
self.selected_type = np_into.getTag("type")
self.pickable = np_into.getParent()
def col_in_object(self, entry):
if base.state == "selecting":
np_into = entry.getIntoNodePath()
np_into.getParent().setColor(0.5, 0.5, 0.5, 1)
def col_out_object(self, entry):
np_into = entry.getIntoNodePath()
try:
np_into.getParent().clearColor()
except:
print "ERROR CLEARING COLOUR"
def get_mouse_plane_pos(self, task):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.pos3d = Point3()
nearPoint = Point3()
farPoint = Point3()
base.camLens.extrude(mpos, nearPoint, farPoint)
if self.plane.intersectsLine(
self.pos3d, render.getRelativePoint(camera, nearPoint),
render.getRelativePoint(camera, farPoint)):
#print "Mouse ray intersects ground plane at ", self.pos3d
self.model_node.setPos(render, self.pos3d)
self.placement_ghost.set_position(self.pos3d[0], self.pos3d[1])
return task.again
def ray_update(self, task):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
return task.cont
def task_mouse_place(self, task):
if base.mouseWatcherNode.isButtonDown(MouseButton.one()):
self.placing_object = True
self.place_pos = (self.anchor_x, self.anchor_y)
self.line_dir.remove()
ls = LineSegs()
ls.move_to(self.anchor_x, self.anchor_y, 1)
ls.draw_to(self.model.getX(), self.model.getY(), 1)
node = ls.create()
angle1 = math.atan2(self.anchor_y - self.anchor_y,
self.anchor_x - self.anchor_x + 50)
angle2 = math.atan2(self.anchor_y - self.model.getY(),
self.anchor_x - self.model.getY())
final_angle = angle1 - angle2
self.model.setHpr(final_angle, 0, 0)
self.line_dir = NodePath(node)
self.line_dir.reparentTo(render)
return task.again
else:
self.line_dir.hide()
taskMgr.add(self.task_mouse_press_check, "checkMousePress")
return task.done
def task_mouse_press_check(self, task):
if base.mouseWatcherNode.isButtonDown(MouseButton.one()):
#if self.multi_select == True:
self.anchor_x, self.anchor_y = self.model.getX(), self.model.getY()
taskMgr.add(self.task_mouse_place, "multibox")
return task.done
return task.again
def mouse_click(self, status):
print base.state
if status == "1-down":
if base.state == "placement":
if self.placement_ghost.get_type() == "tower":
obj = self.placement_ghost.place("tower",
self.model.getX(),
self.model.getY())
elif self.placement_ghost.get_type() == "army":
obj = self.placement_ghost.place("army", self.model.getX(),
self.model.getY())
base.details_box.set_object(obj)
base.change_state("modifying")
elif base.state == "moving":
obj = base.details_box.get_object()
obj.set_position(self.pos3d[0], self.pos3d[1])
base.change_state("modifying")
elif base.state == "selecting" and self.pickable != None:
obj = base.get_obj_from_node(self.pickable)
base.details_box.set_object(obj, "selecting")
base.change_state("modifying")
elif status == "1-up":
print "Mouse", status
elif status == "3-down":
if base.state == "placement":
base.change_state("selecting")
elif base.state == "selecting":
base.change_state("placement")
def initMouseRayCollision(self): z = 0 self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, z))
class Utils():
LAST_ASSIGNED_ID = 0
STARTJSON = None
# Node
NODE_SCALE = LVecBase3f(7, 9, 1)
VERT_DEPTH_DIST = 20
VERT_BREADTH_DIST = 30
HORT_DEPTH_DIST = 25
HORT_BREADTH_DIST = 10
VERTICAL_DEPTH = False
CURRENT_NODE_DATA_LIST = None
TEXT_INPUT = None
@staticmethod
def convertToNodes(
jsonData): # Needed to be able to assign parentId(Proof?)
# Utils.test(jsonData)
nodeList = {}
allNodeJsons = [copy.deepcopy(jsonData)]
depth = 0
while len(allNodeJsons) > 0:
nodeJsonsInCurrentDepth = allNodeJsons
allNodeJsons = []
while len(nodeJsonsInCurrentDepth) > 0:
currentJson = nodeJsonsInCurrentDepth[0]
nodeJsonsInCurrentDepth.remove(currentJson)
id = Utils.getIdOrAssignUnique(currentJson)
node = Utils.getNode(currentJson, depth)
nodeList[id] = node
Utils.placeToParentsChildrenList(node, nodeList)
nodeChildren = node.get('children')
if nodeChildren is not None:
allNodeJsons.extend(nodeChildren)
for child in nodeChildren:
child['parentId'] = id
depth += 1
return nodeList
@staticmethod
def placeToParentsChildrenList(node, nodeList):
parentId = node.get("parentId")
if parentId is not None:
nodeJsonSiblings = nodeList[parentId].get("children")
for index, sibling in enumerate(nodeJsonSiblings):
if sibling.get("x") is None:
nodeJsonSiblings.remove(sibling)
nodeJsonSiblings.insert(index, node)
nodeList[parentId]["children"] = nodeJsonSiblings
break
@staticmethod
def getNode(nodeJson, y):
name = nodeJson.get('name')
nodeId = nodeJson.get('id')
parentId = nodeJson.get('parentId')
children = nodeJson.get('children')
node = {
"name": name,
"id": nodeId,
"parentId": parentId,
"children": children,
"x": -1.0,
"y": y,
"mod": 0
}
return node
@staticmethod
def showNodes(nodeList):
for key in nodeList:
node = nodeList[key]
print(
node.get('name') + " id " + str(node.get('id')) +
" parentId " + str(node.get('parentId')) + " x " +
str(node.get("x")) + " y " + str(node.get("y")))
@staticmethod
def getIdOrAssignUnique(nodeJson):
id = nodeJson.get('id')
if id is None:
Utils.LAST_ASSIGNED_ID += 1
id = Utils.LAST_ASSIGNED_ID
nodeJson['id'] = id
return id
@staticmethod
def getUniqueId(nodeDataList, recheckLastId=False):
Utils.LAST_ASSIGNED_ID = Utils.getLastAssignedId(
nodeDataList, recheckLastId)
Utils.LAST_ASSIGNED_ID += 1
return Utils.LAST_ASSIGNED_ID
@staticmethod
def getLastAssignedId(nodeDataList, recheckLastId):
highestIdAssigned = Utils.LAST_ASSIGNED_ID
if Utils.CURRENT_NODE_DATA_LIST != nodeDataList or recheckLastId:
Utils.CURRENT_NODE_DATA_LIST = nodeDataList
for key in nodeDataList:
if key >= highestIdAssigned:
highestIdAssigned = key
return highestIdAssigned
@staticmethod
def showNode(node):
print("name " + str(node.get("name")) + " x " + str(node.get("x")) +
" y " + str(node.get("y")))
@staticmethod
def showDict(argDict):
for key in argDict:
print(str(key) + " " + str(argDict[key]))
@staticmethod
def dictLen(argDict):
if argDict is None:
return 0
return len(argDict)
@staticmethod
def getJson(name): # Deprecated
jsonPath = path.abspath(path.join(__file__, "../../../assets/" + name))
return json.load(open(jsonPath))
@staticmethod
def getAssetPath(fileName):
return path.abspath(path.join(__file__, "../../../assets/" + fileName))
@staticmethod
def getChildren(node, nodeList):
childrenIds = node.get("childrenIds")
if childrenIds is None:
return None
children = []
for id in childrenIds:
children.append(nodeList[id])
return children
@staticmethod
def getChildrenDict(node, nodeList):
childrenIds = node.get("childrenIds")
if childrenIds is None:
return None
children = {}
for id in childrenIds:
children[id] = nodeList[id]
return children
@staticmethod
def createTextInput(pos, onEnterTextCb):
Utils.TEXT_INPUT = TextInput(pos, onEnterTextCb)
@staticmethod
def closeTextInput():
if Utils.TEXT_INPUT is not None:
Utils.TEXT_INPUT.entry.destroy()
Utils.TEXT_INPUT = None
@staticmethod
def getNodePosition(depth, breadth):
if Utils.VERTICAL_DEPTH:
x = breadth * Utils.VERT_BREADTH_DIST
y = float(depth) * Utils.VERT_DEPTH_DIST
else:
y = breadth * Utils.HORT_BREADTH_DIST
x = float(depth) * Utils.HORT_DEPTH_DIST
z = 0 # Should be addressed later on
return LVecBase3f(x, y, z)
@staticmethod
def getNodeDataPointt(nodeData):
depth = nodeData.get("depth")
breadth = nodeData.get("x")
return Utils.getNodePosition(depth, breadth)
# Have to find another way to organize functions
@staticmethod
def removeSelectedField(nodeId, nodeDataSettings):
nodeSettings = nodeDataSettings.get(nodeId)
if nodeSettings is not None:
nodeDataSettings.pop(nodeId, None)
return nodeDataSettings
# Mouse helpers
PLANE = Plane(Vec3(0, 0, 1), Point3(0, 0, 0))
CT = CollisionTraverser()
CHQ = CollisionHandlerQueue()
CN = CollisionNode('mouseRay')
NEW_CN = None
CR = CollisionRay()
@staticmethod
def getMousePosition(showBase):
Utils.initMouseFields(showBase)
return Utils.getMouseCollisionToPlane(showBase, Utils.PLANE)
@staticmethod
def initMouseFields(showBase):
if Utils.NEW_CN is None:
Utils.NEW_CN = showBase.camera.attachNewNode(Utils.CN)
Utils.CN.setFromCollideMask(BitMask32.bit(1))
Utils.CN.addSolid(Utils.CR)
Utils.CT.addCollider(Utils.NEW_CN, Utils.CHQ)
@staticmethod
def getMouseCollisionToPlane(showBase, plane):
mouseWatcherNode = showBase.mouseWatcherNode
if mouseWatcherNode.hasMouse():
mpos = mouseWatcherNode.getMouse()
pos3d = LPoint3()
nearPoint = LPoint3()
farPoint = LPoint3()
showBase.camLens.extrude(mpos, nearPoint, farPoint)
render = showBase.render
camera = showBase.camera
if plane.intersectsLine(pos3d,
render.getRelativePoint(camera, nearPoint),
render.getRelativePoint(camera, farPoint)):
return pos3d
return None
@staticmethod
def getDistSqr2D(point3d1, point3d2):
dx = point3d2.x - point3d1.x
dy = point3d2.y - point3d1.y
return (dx * dx) + (dy * dy)
@staticmethod
def isInRange(sqrDist, rangeDist):
if sqrDist < (rangeDist * rangeDist):
return True
return False
@staticmethod
def collidesRect(p1, p2, width, height):
r1 = Rect(p1.x, p1.y, width, height)
r2 = Rect(p2.x, p2.y, width, height)
result = r1.collidesWith(r2)
# print(str(result))
return result
class CollisionManager:
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 input_init(self):
self.DO=DirectObject()
self.DO.accept('mouse1', self.mouse_click, ["1-down"])
self.DO.accept('mouse1-up', self.mouse_click, ["1-up"])
self.DO.accept('mouse3', self.mouse_click, ["3-down"])
self.DO.accept('0', self.placement_ghost.change_player, [0])
self.DO.accept('1', self.placement_ghost.change_player, [1])
self.DO.accept('2', self.placement_ghost.change_player, [2])
self.DO.accept('a', self.placement_ghost.change_type, ["army"])
self.DO.accept('t', self.placement_ghost.change_type, ["tower"])
self.DO.accept('control-s', base.xml_manager.save)
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-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)
def col_against_object(self,entry):
if entry.getIntoNodePath().getParent() != self.pickable:
np_from=entry.getFromNodePath()
np_into=entry.getIntoNodePath()
self.selected_type = np_into.getTag("type")
self.pickable = np_into.getParent()
def col_in_object(self,entry):
if base.state == "selecting":
np_into=entry.getIntoNodePath()
np_into.getParent().setColor(0.5,0.5,0.5,1)
def col_out_object(self,entry):
np_into=entry.getIntoNodePath()
try:
np_into.getParent().clearColor()
except:
print "ERROR CLEARING COLOUR"
def get_mouse_plane_pos(self, task):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.pos3d = Point3()
nearPoint = Point3()
farPoint = Point3()
base.camLens.extrude(mpos, nearPoint, farPoint)
if self.plane.intersectsLine(self.pos3d,
render.getRelativePoint(camera, nearPoint),
render.getRelativePoint(camera, farPoint)):
#print "Mouse ray intersects ground plane at ", self.pos3d
self.model_node.setPos(render, self.pos3d)
self.placement_ghost.set_position(self.pos3d[0],self.pos3d[1])
return task.again
def ray_update(self,task):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.pickerRay.setFromLens(base.camNode, mpos.getX(),mpos.getY())
return task.cont
def task_mouse_place(self,task):
if base.mouseWatcherNode.isButtonDown(MouseButton.one()):
self.placing_object = True
self.place_pos = (self.anchor_x,self.anchor_y)
self.line_dir.remove()
ls = LineSegs()
ls.move_to(self.anchor_x,self.anchor_y,1)
ls.draw_to(self.model.getX(),self.model.getY(),1)
node = ls.create()
angle1 = math.atan2(self.anchor_y - self.anchor_y,self.anchor_x - self.anchor_x+50)
angle2 = math.atan2(self.anchor_y - self.model.getY(),self.anchor_x - self.model.getY());
final_angle = angle1-angle2;
self.model.setHpr(final_angle,0,0)
self.line_dir = NodePath(node)
self.line_dir.reparentTo(render)
return task.again
else:
self.line_dir.hide()
taskMgr.add(self.task_mouse_press_check, "checkMousePress")
return task.done
def task_mouse_press_check(self,task):
if base.mouseWatcherNode.isButtonDown(MouseButton.one()):
#if self.multi_select == True:
self.anchor_x,self.anchor_y = self.model.getX(),self.model.getY()
taskMgr.add(self.task_mouse_place, "multibox")
return task.done
return task.again
def mouse_click(self,status):
print base.state
if status == "1-down":
if base.state == "placement":
if self.placement_ghost.get_type() == "tower":
obj = self.placement_ghost.place("tower",self.model.getX(),self.model.getY())
elif self.placement_ghost.get_type() == "army":
obj = self.placement_ghost.place("army",self.model.getX(),self.model.getY())
base.details_box.set_object(obj)
base.change_state("modifying")
elif base.state == "moving":
obj = base.details_box.get_object()
obj.set_position(self.pos3d[0],self.pos3d[1])
base.change_state("modifying")
elif base.state == "selecting" and self.pickable != None:
obj = base.get_obj_from_node(self.pickable)
base.details_box.set_object(obj,"selecting")
base.change_state("modifying")
elif status == "1-up":
print "Mouse",status
elif status == "3-down":
if base.state == "placement":
base.change_state("selecting")
elif base.state == "selecting":
base.change_state("placement")
def __init__(self, framework, *args, **kwargs):
self.bullets = []
self.environment = {}
self.colliders = {}
self.task_manager = []
self.bullet_colliders = []
self.remove_bullet_indices = []
super().__init__(*args, **kwargs)
self.f = framework
self.controller = Controller(self.f.accept, self)
self.f.set_background_color(0.2, 0.2, 0.2, 0.6)
if settings.ALLOW_FILTERS:
self.filter = CommonFilters(self.f.win, self.f.cam)
self.filter.set_bloom(mintrigger=0.99, size="small")
# self.filter.set_blur_sharpen(amount=0.99)
self.base_node = NodePath("base")
self.base_node.reparent_to(self.f.render)
# floor
self.plane = self.create_model(settings.egg / "plane",
self.base_node,
"ground-zero",
color=(1, 1, 1, 1))
self.create_model(settings.egg / "house_01",
self.base_node,
"house-01",
position=(20, 50, 0),
scale=1.5)
self.create_model(settings.egg / "house_02",
self.base_node,
"house-02",
position=(-50, 10, 0),
scale=1.5)
self.sun_light_model = self.create_model("models/misc/sphere",
self.base_node,
"sun",
position=(0, -150, 250),
scale=5.0,
color=(1, 1, 1, 1),
_store=False)
tank = self.create_model(settings.egg / "tank",
self.base_node,
"player",
scale=3.0,
position=(0.0, 0.0, 1e-3))
gun = self.create_model("models/misc/sphere",
tank,
"player-gun",
position=(0.0, 4.5, 1.755),
scale=0.1,
_store=False)
self.tank = Tank(tank, gun, framework=self.f)
self._tank = self.tank.tank
enemy = self.create_model(settings.egg / "enemy",
self.base_node,
"enemy",
scale=0.8,
position=(-80.0, 80.0, 1e-3))
self.enemy = EnemyTank(enemy, None, framework=self.f)
# point light for shadows
sun_light = PointLight("sun-light")
sun_light.set_color((0.4, 0.4, 0.4, 1))
self.sun_light_node = self.base_node.attach_new_node(sun_light)
self.sun_light_node.reparent_to(self.sun_light_model)
self.redistribute_light(self.sun_light_node)
self.plane.set_light(self.sun_light_node)
# daylight
if settings.ALLOW_DAYLIGHT:
day_light = DirectionalLight("day-light")
day_light.set_color((1, 1, 1, 1))
self.daylight_node = self.f.render.attach_new_node(day_light)
self.daylight_node.set_p(-20)
self.daylight_node.set_h(10)
self.daylight_node.reparent_to(self.sun_light_model)
self.redistribute_light(self.daylight_node)
# shadows
if settings.ALLOW_SHADOWS:
sun_light.set_shadow_caster(True, 2048, 2048)
self.f.render.set_shader_auto()
# 3rd person camera lock
if settings.TRD_PERSON_CAM:
self.f.camera.reparent_to(self.tank.tank)
self.f.cam.set_pos(0, -25, 10)
self.f.cam.lookAt(self.tank.tank)
self.f.cam.setP(self.f.camera.getP() - 20)
if settings.ALLOW_AMBIENT:
amblight = AmbientLight("ambient-light")
amblight.set_color((0.2, 0.2, 0.2, 1))
self.amblight_node = self.f.render.attach_new_node(amblight)
self.redistribute_light(self.amblight_node)
# colliders
tank_collider = self.environment["player"].attachNewNode(
CollisionNode('player-collider'))
tank_collider.node().addSolid(
CollisionBox(Point3(-1.5, -3, 0), Point3(1.5, 3, 2.25)))
self.colliders['player-collider'] = tank_collider
enemy_collider = self.environment["enemy"].attachNewNode(
CollisionNode('enemy-collider'))
enemy_collider.node().addSolid(
CollisionBox(Point3(-6.5, -13.5, 0), Point3(6.5, 13, 10)))
self.colliders['enemy-collider'] = enemy_collider
house_01_collider = self.environment["house-01"].attachNewNode(
CollisionNode('house-01-collider'))
house_01_collider.node().addSolid(
CollisionBox(Point3(0, 2, 0), Point3(14.5, 16, 17)))
self.colliders['house-01'] = house_01_collider
house_02_collider = self.environment["house-02"].attachNewNode(
CollisionNode('house-02-collider'))
house_02_collider.node().addSolid(
CollisionBox(Point3(0, 0, 0), Point3(21, 27, 37)))
self.colliders['house-02'] = house_02_collider
floor_collider = self.environment["ground-zero"].attachNewNode(
CollisionNode('ground-zero-collider'))
floor_collider.node().addSolid(
CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0))))
self.colliders['ground-zero-collider'] = floor_collider
self.f.pusher.addCollider(tank_collider, self.environment["player"])
self.f.cTrav.addCollider(tank_collider, self.f.pusher)
# show.hide all colliders
if settings.SHOW_COLLIDERS:
for key, value in self.colliders.items():
logger.info(f"collider for {key} is visible")
value.show()
self.f.cTrav.showCollisions(self.f.render)
# uppdate
self.f.cHandler.addInPattern('%fn')
self.f.accept('bullet-collider', self.handle_collision)
self.task_manager.append(self.f.task_mgr.add(self.update))
self.task_manager.append(self.f.task_mgr.add(self.update_bullets))
def __init__(self):
ShowBase.__init__(self)
self.disableMouse()
self.camera.setPos(40, -100, 160)
self.camera.lookAt(40,-44.5,0)
self.rows, self.cols = 9, 8
#Start tile & end tile
self.start, self.end = (0, 0), (8, 7)
self.cellSize = 10
#Plane used for intersection of mouseLine
#To get coords of mouse
self.mousePlane = Plane(Vec3(0, 0, 1), Point3(0, 0, 0))
#No click has been made
self.mousePressed = False
self.displayTextObject = None
#Holds the model for all tiles
self.tiles = []
for row in xrange(self.rows):
self.tiles += [[0]*self.cols]
#Holds the texture for the grass tiles
self.grass = loader.loadTexture("models/textures/sponge.jpg")
#Holds the models for all the towers
self.towerModels = []
for row in xrange(self.rows):
self.towerModels += [[0]*self.cols]
#Holds the G value of each tile for pathing
self.tileNodes = []
for row in xrange(self.rows):
self.tileNodes += [[0]*self.cols]
for row in xrange(self.rows):
for col in xrange(self.cols):
self.tileNodes[row][col] = Tile(self)
#Holds the towers in a 2d array
self.towers = []
for row in xrange(self.rows):
self.towers += [[0]*self.cols]
self.board = [
['s', 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0,'e']
]
self.drawBoard()
self.drawBoardLines()
self.drawBackground()
#Stores all center points of each tile
self.midPoints= []
startX = 5 #X Coordinate of first Square's center
startY = -5 #Y Coordinate of first Square's center
for row in xrange(self.rows):
self.midPoints += [[Point3(0,0,0)]*self.cols]
for row in xrange(self.rows):
for col in xrange(self.cols):
self.midPoints[row][col] = Point3(
startX+col*self.cellSize,
startY-row*self.cellSize,
0)
self.createPath(self.start, self.end)
#Board Information
#Towers
self.arrowTowerModel = loader.loadModel(
"models/towers/arrowTowerFolder/arrowTower")
self.fireTowerModel = loader.loadModel(
"models/towers/fireTowerFolder/fireTower")
self.iceTowerModel = loader.loadModel(
"models/towers/iceTowerFolder/iceTower")
#Main Menu
self.mainFrame = DirectFrame(frameColor=(0, 0, 0, 1),
frameSize=(-2, 2, -2, 2),
pos=(0, 0, 0))
instructionsText = " Stefan Dasbach's Tower Defense\n\n\n"+\
"Monsters move accross the screen\n" +\
"from the green square to the red\nsquare."+\
" Choose and build from among a \nrange" +\
" of towers including Arrow, Fire,\nand" +\
" Ice. Waves of monsters come in \n10 and" +\
" will spawn every 15 seconds. You\ncan" +\
" only build towers when creeps are\nnot" +\
" alive.\n\nPress 'P' to play!"
self.instructionsNode = OnscreenText(
text=instructionsText,
pos = (-0.9, 0.55),
scale = (0.1),
bg = (209/255.0, 168/255.0, 132/255.0, 1),
frame = (1, 0, 0, 1),
align = TextNode.ALeft
)
# self.fireProjectileModel = loader.loadModel(
# "models/projectiles/fireProjectileFolder/fireProjectile")
# self.iceProjectileModel = loader.loadModel(
# "models/projectiles/iceProjectileFolder/iceProjectile")
#
# self.iceProjectileModel.setScale(0.03,0.03,0.03)
# self.iceProjectileModel.setPos(12,-5,0)
# # self.iceProjectileModel.lookAt(15, -5, 0)
# self.iceProjectileModel.reparentTo(self.render)
#Level information
self.level = 1
self.gold = 20
self.lives = 20
self.totalHp = 0
self.arrowTowerCost = 10
self.fireTowerCost = 25
self.iceTowerCost = 30
#Building period, True at beginning of game
self.buildTime = True
#Spawning/killing of creeps period, False at beginning
self.fireTime = False
self.displayGameInfoNode = None
self.displayGameInfoNode1 = None
#Spawn Creeps
self.numberOfCreeps = 10
#Time for building
self.waveTime = 15
self.creeps = []
self.hasSpawnedWave = False
#Delay between spawning of each creep
self.delayTime = 0
self.interval = 0
self.buildTimeDuration = 0
self.alreadyInitedGame = False
self.accept("p", self.initGame)
class TowerDefense(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.disableMouse()
self.camera.setPos(40, -100, 160)
self.camera.lookAt(40,-44.5,0)
self.rows, self.cols = 9, 8
#Start tile & end tile
self.start, self.end = (0, 0), (8, 7)
self.cellSize = 10
#Plane used for intersection of mouseLine
#To get coords of mouse
self.mousePlane = Plane(Vec3(0, 0, 1), Point3(0, 0, 0))
#No click has been made
self.mousePressed = False
self.displayTextObject = None
#Holds the model for all tiles
self.tiles = []
for row in xrange(self.rows):
self.tiles += [[0]*self.cols]
#Holds the texture for the grass tiles
self.grass = loader.loadTexture("models/textures/sponge.jpg")
#Holds the models for all the towers
self.towerModels = []
for row in xrange(self.rows):
self.towerModels += [[0]*self.cols]
#Holds the G value of each tile for pathing
self.tileNodes = []
for row in xrange(self.rows):
self.tileNodes += [[0]*self.cols]
for row in xrange(self.rows):
for col in xrange(self.cols):
self.tileNodes[row][col] = Tile(self)
#Holds the towers in a 2d array
self.towers = []
for row in xrange(self.rows):
self.towers += [[0]*self.cols]
self.board = [
['s', 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0,'e']
]
self.drawBoard()
self.drawBoardLines()
self.drawBackground()
#Stores all center points of each tile
self.midPoints= []
startX = 5 #X Coordinate of first Square's center
startY = -5 #Y Coordinate of first Square's center
for row in xrange(self.rows):
self.midPoints += [[Point3(0,0,0)]*self.cols]
for row in xrange(self.rows):
for col in xrange(self.cols):
self.midPoints[row][col] = Point3(
startX+col*self.cellSize,
startY-row*self.cellSize,
0)
self.createPath(self.start, self.end)
#Board Information
#Towers
self.arrowTowerModel = loader.loadModel(
"models/towers/arrowTowerFolder/arrowTower")
self.fireTowerModel = loader.loadModel(
"models/towers/fireTowerFolder/fireTower")
self.iceTowerModel = loader.loadModel(
"models/towers/iceTowerFolder/iceTower")
#Main Menu
self.mainFrame = DirectFrame(frameColor=(0, 0, 0, 1),
frameSize=(-2, 2, -2, 2),
pos=(0, 0, 0))
instructionsText = " Stefan Dasbach's Tower Defense\n\n\n"+\
"Monsters move accross the screen\n" +\
"from the green square to the red\nsquare."+\
" Choose and build from among a \nrange" +\
" of towers including Arrow, Fire,\nand" +\
" Ice. Waves of monsters come in \n10 and" +\
" will spawn every 15 seconds. You\ncan" +\
" only build towers when creeps are\nnot" +\
" alive.\n\nPress 'P' to play!"
self.instructionsNode = OnscreenText(
text=instructionsText,
pos = (-0.9, 0.55),
scale = (0.1),
bg = (209/255.0, 168/255.0, 132/255.0, 1),
frame = (1, 0, 0, 1),
align = TextNode.ALeft
)
# self.fireProjectileModel = loader.loadModel(
# "models/projectiles/fireProjectileFolder/fireProjectile")
# self.iceProjectileModel = loader.loadModel(
# "models/projectiles/iceProjectileFolder/iceProjectile")
#
# self.iceProjectileModel.setScale(0.03,0.03,0.03)
# self.iceProjectileModel.setPos(12,-5,0)
# # self.iceProjectileModel.lookAt(15, -5, 0)
# self.iceProjectileModel.reparentTo(self.render)
#Level information
self.level = 1
self.gold = 20
self.lives = 20
self.totalHp = 0
self.arrowTowerCost = 10
self.fireTowerCost = 25
self.iceTowerCost = 30
#Building period, True at beginning of game
self.buildTime = True
#Spawning/killing of creeps period, False at beginning
self.fireTime = False
self.displayGameInfoNode = None
self.displayGameInfoNode1 = None
#Spawn Creeps
self.numberOfCreeps = 10
#Time for building
self.waveTime = 15
self.creeps = []
self.hasSpawnedWave = False
#Delay between spawning of each creep
self.delayTime = 0
self.interval = 0
self.buildTimeDuration = 0
self.alreadyInitedGame = False
self.accept("p", self.initGame)
def initGame(self):
if self.alreadyInitedGame == False:
self.instructionsNode.destroy()
self.mainFrame.destroy()
#Handle taskManager
self.timerTask = self.taskMgr.add(self.timerTask, 'timerTask')
self.mouseTask = self.taskMgr.add(self.mouseTask, 'mouseTask')
self.fireTask = self.taskMgr.add(self.fireTask, 'fireTask')
self.hpBarTask = self.taskMgr.add(self.hpBarTask, 'hpBarTask')
self.displayGameInfo()
self.displayTowerInfo()
self.displayControls()
#Selects tile
self.accept("mouse1", self.selectTile)
#Builds arrow Tower
self.accept("a", self.buildTowerArrow)
#Builds Fire Tower
self.accept("f", self.buildTowerFire)
#Builds Ice tower
self.accept("i", self.buildTowerIce)
#Quits the game
self.accept("q", self.quit)
self.alreadyInitedGame = True
#*********************** Board Display ***********************
#Displays a walkable tile or tower
def drawTile(self, row, col):
#Towers
if self.board[row][col] < 0:
if self.board[row][col] == -1: #Arrow Tower
# tileMaker.setColor(0, 0, 0, 1)
self.towerModels[row][col] = BuildArrowTowerModel(
self, self.midPoints[row][col])
elif self.board[row][col] == -2: #Fire tower
# tileMaker.setColor(1, 136.0/255, 0, 1)
self.towerModels[row][col] = BuildFireTowerModel(
self, self.midPoints[row][col])
elif self.board[row][col] == -3: #Ice tower
self.towerModels[row][col] = BuildIceTowerModel(
self, self.midPoints[row][col])
# tileMaker.setColor(0, 0, 1, 1)
#Board Tiles
else:
tileMaker = CardMaker("board")
cellSize = self.cellSize
if self.board[row][col] == 0: #Normal/non-towered tile
tileMaker.setColor(1, 1, 1, 1)
elif self.board[row][col] == "s": #Start
tileMaker.setColor(0, 1, 0, 1)
elif self.board[row][col] == "e": #End
tileMaker.setColor(173.0/255, 0, 0, 1)
tileMaker.setFrame(
col*cellSize, col*cellSize+cellSize,
-row*cellSize-cellSize, -row*cellSize)
self.tiles[row][col] = self.render.attachNewNode(\
tileMaker.generate())
self.tiles[row][col].setTexture(self.grass)
self.tiles[row][col].lookAt(0,0,-1)
#Draws all tiles from self.board
def drawBoard(self):
tileMaker = CardMaker("board")
board = self.board
cellSize = self.cellSize
for row in xrange(len(board)):
for col in xrange(len(board[0])):
self.drawTile(row, col)
#Draws grid line from start and end point
#Basically adds visual separation of tiles
def drawLine(self, start, end, thickness=1.5):
segment = LineSegs()
# segment.setColor(209/255.0, 168/255.0, 132/255.0, 1)
segment.setColor(1, 1, 1, 1)
segment.setThickness(thickness)
segment.moveTo(start)
segment.drawTo(end)
line = self.render.attachNewNode(segment.create())
#Draws all grid lines of the board
def drawBoardLines(self):
#Horizontal grid lines
for row in xrange(self.rows):
self.drawLine(Point3(0, -row*self.cellSize, 0.01),
Point3(self.cellSize*self.cols, -row*self.cellSize, 0.01))
#Vertical grid lines
for col in xrange(self.cols):
self.drawLine(Point3(col*self.cellSize, 0, 0.01),
Point3(col*self.cellSize, -self.cellSize*self.rows, 0.01))
def drawBackground(self):
self.background = loader.loadModel("models/skySphere/skySphere")
self.background.lookAt(0,0,-1)
self.background.reparentTo(self.render)
#************************** A Star **************************
#Determines whether or not tile can be walked on
def isPath(self, coord):
row, col = coord[0], coord[1]
if self.board[row][col] < 0: #Tower
return False
return True #Can walk on path
#Determines if row and col on board or not
def inBounds(self, coord):
row, col = coord[0], coord[1]
if row < len(self.board) and col < len(self.board[0]):
if row >= 0 and col >=0:
return True
return False
#A* Pathfinding Algorithm
def createPath(self, start, end):
#This array of array of objects keeps
#track of the G value of each tile
openList = set()
closedList = set()
parentDict = dict()
openList.add(start)
newTile = start
#If end in closedList, we've found our pathway to end
#Or if we've exhausted all search tiles available (openList is empty)
try:
while (end not in closedList) or len(openList) != 0:
#Lowest f-value among openList
#newTile holds the coordinates of which tile to check
newTile = self.getLowestFInOpen(start, end, openList)
#Make self.tileNodes[newTile[0]][newTile[1]] and currentNode
#Aliases to use currentNode instead to improve clarity
currentNode = self.tileNodes[newTile[0]][newTile[1]]
#Switch newTile to closedList
openList.remove(newTile)
closedList.add(newTile)
#Adjacent tiles
left = (newTile[0], newTile[1]-1)
right = (newTile[0], newTile[1]+1)
up = (newTile[0]-1, newTile[1])
down = (newTile[0]+1, newTile[1])
#Check if adjacent tiles in closedList/openList
#If in closedList, already checked
#If not in closedList, check if already in openList
#If not in openList, add it, and record its parent tile
#Down tile
if self.inBounds(down) and self.isPath(down):
downNode = self.tileNodes[newTile[0]+1][newTile[1]]
#If not already checked
if down not in closedList:
#If should be added to openList
if down not in openList:
downNode.setG(currentNode.getG() + 1)
openList.add(down)
#Assign newTile as down's parent tile
parentDict[down] = (newTile)
else:
newG = currentNode.getG() + 1 #down so plus 1
if downNode.getG() > newG:
downNode.setG(newG)
parentDict[down] = (newTile)
#Right tile
if self.inBounds(right) and self.isPath(right):
rightNode = self.tileNodes[newTile[0]][newTile[1]+1]
if right not in closedList:
if right not in openList:
rightNode.setG(currentNode.getG() + 1)
openList.add(right)
parentDict[right] = (newTile)
else:
newG = currentNode.getG() + 1 #right so plus 1
if rightNode.getG() > newG:
rightNode.setG(newG)
parentDict[right] = (newTile)
#Up tile
if self.inBounds(up) and self.isPath(up):
upNode = self.tileNodes[newTile[0]-1][newTile[1]]
if up not in closedList:
if up not in openList:
upNode.setG(currentNode.getG() + 1)
openList.add(up)
parentDict[up] = (newTile)
else:
newG = currentNode.getG() + 1 #up so plus 1
if upNode.getG() > newG:
upNode.setG(newG)
parentDict[up] = (newTile)
#Left Tile
if self.inBounds(left) and self.isPath(left):
leftNode = self.tileNodes[newTile[0]][newTile[1]-1]
if left not in closedList:
if left not in openList:
leftNode.setG(currentNode.getG() + 1)
openList.add(left)
parentDict[left] = (newTile)
else:
newG = currentNode.getG() + 1 #left so plus 1
if leftNode.getG() > newG:
leftNode.setG(newG)
parentDict[left] = (newTile)
except:
return False
self.tileSequence = self.getSequenceFromDict(parentDict)
self.pathSequence = []
for i in xrange(len(self.tileSequence)):
self.pathSequence += [self.midPoints
[self.tileSequence[i][0]]
[self.tileSequence[i][1]]]
return True
#Finds lowest f value in openList
def getLowestFInOpen(self, start, end, openList):
lowestF = 10000000
newTile = None
for tile in openList:
temp = self.getF(start, end, self.tileNodes[\
tile[0]][tile[1]], tile[0], tile[1])
if temp < lowestF:
lowestF = temp
newTile = tile
return newTile
#Distance from start to current tile
def getG(self, current):
return current.getG()
# return abs(start[0]-current[0]) + abs(start[1]-current[1])
#Distance from current tile to end
def getH(self, start, end, current):
return abs(end[1]-current[1]) + abs(end[0]-current[0])
#Sum of g and h (total presumed distance from start to finish)
def getF(self, start, end, current, row, col):
g = self.getG(current)
h = self.getH(start, end, (row,col))
return g+h
#Get sequence of steps from dictionary of points
#and their parent points
def getSequenceFromDict(self, parentDict):
currentTile = self.end
pathSequence = [currentTile]
while currentTile != self.start:
currentTile = parentDict[currentTile]
pathSequence += [currentTile]
return pathSequence[::-1]
#********************Task Manager***********************
#Handles the switching between
#The building period and
#The creep killing period
def timerTask(self, task):
if self.buildTime == True:
#buildTimeDuration hasn't been set yet
if self.buildTimeDuration == 0:
for row in self.towers:
for tower in row:
#If this has been set to a tower
if tower:
if tower.shootProj != None and\
not tower.shootProj.isGone():
tower.shootProj.remove()
self.buildTimeDuration = task.time + self.waveTime
self.displayBuildTime(self.buildTimeDuration-task.time)
#If a second has passed since updating the time
elif self.buildTimeDuration-task.time < self.currentBuildTimeInt:
self.displayNextWave.destroy()
self.displayNextWaveTime.destroy()
self.displayBuildTime(self.buildTimeDuration-task.time)
#If buildTime has expired
#Initiate fireTime, end buildTime
if task.time > self.buildTimeDuration:
self.displayNextWave.destroy()
self.displayNextWaveTime.destroy()
self.buildTime = False
self.fireTime = True
self.hasSpawnedWave = False
self.buildTimeDuration = 0
self.displayCreepHp = True
return Task.cont
#Start next level
if self.fireTime == True:
#Spawn wave
if self.hasSpawnedWave == False:
self.spawnWave(task)
#Used to display CreepHP as soon as wave spawns
if self.displayCreepHp == True:
if self.displayGameInfoNode1 != None:
self.displayGameInfoNode1.destroy()
self.displayGameInfoNode.destroy()
self.displayGameInfo()
self.displayCreepHp = False
return Task.cont
#If all creeps killed/reached end
#Initiate buildTime, end fireTime
if self.isCreeps() == False:
self.buildTime = True
self.fireTime = False
#Next level
self.levelUp()
return Task.cont
#Manages the tracking of the mouse & its position
def mouseTask(self, task):
if base.mouseWatcherNode.hasMouse():
tempMousePos = base.mouseWatcherNode.getMouse()
pos3d = Point3()
nearPoint = Point3()
farPoint = Point3()
base.camLens.extrude(tempMousePos, nearPoint, farPoint)
if self.mousePlane.intersectsLine(pos3d,
self.render.getRelativePoint(camera, nearPoint),
self.render.getRelativePoint(camera, farPoint)):
self.mousePos = (pos3d[0], pos3d[1])
return Task.cont
#Manages the firing of towers
def fireTask(self, task):
#Are creeps and are towers
if len(self.creeps) > 0 and len(self.towers) > 0:
for row in self.towers:
for tower in row:
#If this has been set to a tower
if tower:
#Tower fire isn't on cooldown
# if not tower.isFiring():
tower.fire(task)
return Task.cont
#Shows and positions hpBar
def hpBarTask(self, task):
for creep in self.creeps:
#Is actually a creep
if creep:
creep.showHpBar(task)
return Task.cont
#*************************Building Objects*************************
#onClick of mouse selects a tile
def selectTile(self):
row, col = self.mousePos[1], self.mousePos[0]
#Check if click is on the grid or not
if (row < 0 and row > -self.rows*self.cellSize) and (
col > 0 and col < self.cols*self.cellSize):
self.mousePressed = True
self.currentRow = abs(int(row/10))
self.currentCol = abs(int(col/10))
#If displayText already exists, destroy and rewrite it
if self.displayTextObject != None:
self.displayTextObject.destroy()
self.displayText()
def buildTowerArrow(self):
#Row and col of tile selected
#A tile is selected
if self.mousePressed == True:
#Makes sure not building while attacking creeps
if self.buildTime == False:
self.displayTextObject.destroy()
self.displayError("You cannot build while attacking")
else:
row = self.currentRow
col = self.currentCol
originalVal = self.board[row][col]
self.board[row][col] = -1
#Checks if the tower is blocking
#Or if tower already built there
#Create path return false if no path
if (not self.createPath(self.start, self.end) or
(row == 0 and col == 0) or
(originalVal < 0) #Already a tower
):
self.board[row][col] = originalVal
self.displayTextObject.destroy()
self.displayError("You can't build there")
elif self.gold < self.arrowTowerCost:
self.board[row][col] = originalVal
self.displayTextObject.destroy()
self.displayError("Not enough gold")
else:
self.towers[row][col] = ArrowTower(
self, self.midPoints[row][col])
#Delete current square
# self.tiles[row][col].removeNode()
#Redraw it as tower
self.drawTile(row, col)
#Built a tower, so no longer highlighting tile
self.mousePressed = False
#No need for text; no tile selected
self.displayTextObject.destroy()
self.createPath(self.start, self.end)
self.gold -= self.arrowTowerCost
if self.displayGameInfoNode1 != None:
self.displayGameInfoNode1.destroy()
self.displayGameInfoNode.destroy()
self.displayGameInfo()
def buildTowerFire(self):
#Row and col of tile selected
#A tile is selected
if self.mousePressed == True:
#Makes sure not building while attacking creeps
if self.buildTime == False:
self.displayTextObject.destroy()
self.displayError("You cannot build while attacking")
else:
row = self.currentRow
col = self.currentCol
originalVal = self.board[row][col]
self.board[row][col] = -2
#Checks if the tower is blocking
#Or if tower already built there
#Create path return false if no path
if (not self.createPath(self.start, self.end) or
(row == 0 and col == 0) or
(originalVal < 0) #Already a tower
):
self.board[row][col] = originalVal
self.displayTextObject.destroy()
self.displayError("You can't build there")
elif self.gold < self.fireTowerCost:
self.board[row][col] = originalVal
self.displayTextObject.destroy()
self.displayError("Not enough gold")
else:
self.towers[row][col] = FireTower(
self, self.midPoints[row][col])
#Delete current square
# self.tiles[row][col].removeNode()
#Redraw it as tower
self.drawTile(row, col)
#Built a tower, so no longer highlighting tile
self.mousePressed = False
#No need for text; no tile selected
self.displayTextObject.destroy()
self.createPath(self.start, self.end)
self.gold -= self.fireTowerCost
if self.displayGameInfoNode1 != None:
self.displayGameInfoNode1.destroy()
self.displayGameInfoNode.destroy()
self.displayGameInfo()
def buildTowerIce(self):
#Row and col of tile selected
#A tile is selected
if self.mousePressed == True:
#Makes sure not building while attacking creeps
if self.buildTime == False:
self.displayTextObject.destroy()
self.displayError("You cannot build while attacking")
else:
row = self.currentRow
col = self.currentCol
originalVal = self.board[row][col]
self.board[row][col] = -3
#Checks if the tower is blocking
#Or if tower already built there
#Create path return false if no path
if (not self.createPath(self.start, self.end) or
(row == 0 and col == 0) or
(originalVal < 0) #Already a tower
):
self.board[row][col] = originalVal
self.displayTextObject.destroy()
self.displayError("You can't build there")
elif self.gold < self.iceTowerCost:
self.board[row][col] = originalVal
self.displayTextObject.destroy()
self.displayError("Not enough gold")
else:
self.towers[row][col] = IceTower(
self, self.midPoints[row][col])
#Delete current square
# self.tiles[row][col].removeNode()
#Redraw it as tower
self.drawTile(row, col)
#Built a tower, so no longer highlighting tile
self.mousePressed = False
#No need for text; no tile selected
self.displayTextObject.destroy()
self.createPath(self.start, self.end)
self.gold -= self.iceTowerCost
if self.displayGameInfoNode1 != None:
self.displayGameInfoNode1.destroy()
self.displayGameInfoNode.destroy()
self.displayGameInfo()
#*************************UI Display*************************
def displayText(self):
text = "Row: " + str(self.currentRow)+\
" Col: " + str(self.currentCol) +\
"\nPress to build ' a ' Arrow Tower" +\
" ' f ' Fire Tower"+\
" ' i ' Ice Tower"
self.displayTextObject = OnscreenText(
text=text,
pos = (0.005, 0.95),
scale = (0.05),
bg = (209/255.0, 168/255.0, 132/255.0, 1),
frame = (1, 0, 0, 1)
)
def displayError(self, text):
text = text
self.displayTextObject = OnscreenText(
text=text,
pos = (0.005, 0.91),
scale = (0.1),
bg = (209/255.0, 168/255.0, 132/255.0, 1),
frame = (1, 0, 0, 1)
)
def displayBuildTime(self, time):
text = "Next wave"
self.displayNextWave = OnscreenText(
text=text,
pos = (1.05, 0.91),
scale = (0.06),
bg = (209/255.0, 168/255.0, 132/255.0, 1),
frame = (1, 0, 0, 1)
)
self.currentBuildTimeInt = int(time)
text = str(self.currentBuildTimeInt)
self.displayNextWaveTime = OnscreenText(
text=text,
pos = (1.0485, 0.69),
scale = (0.2253),
bg = (209/255.0, 168/255.0, 132/255.0, 1),
frame = (1, 0, 0, 1)
)
def displayGameInfo(self):
text = "Level: " + str(self.level) + "\n" +\
"Gold: " + str(self.gold) + "\n" +\
"Lives: " + str(self.lives)
self.displayGameInfoNode = OnscreenText(
text=text,
pos = (-1.3, 0.88),
scale = (0.09),
bg = (209/255.0, 168/255.0, 132/255.0, 1),
frame = (1, 0, 0, 1),
align = TextNode.ALeft
)
#Has a value other than 0
if self.fireTime == True:
text = "Creep HP: " + str(self.totalHp)
self.displayGameInfoNode1 = OnscreenText(
text=text,
pos = (-1.12, 0.55),
scale = (0.06),
bg = (209/255.0, 168/255.0, 132/255.0, 1),
frame = (1, 0, 0, 1)
)
def displayTowerInfo(self):
text = "Arrow\nDmg: 10\nRate: 0.5s\nRange: 30\nCost: 10\n\n" +\
"Fire \nDmg: 7\nRate: 0.2s\nRange: 20\nCost: 25\n\n" +\
"Ice \nDmg: 5\nRate: 0.5s\nRange: 25\nSlow: 60%\nCost: 30"
self.displayTowerInfoNode = OnscreenText(
text=text,
pos = (-1.32, 0.0),
scale = (0.05),
bg = (209/255.0, 168/255.0, 132/255.0, 1),
frame = (1, 0, 0, 1),
align = TextNode.ALeft
)
def displayControls(self):
text = "Select A Tile\n" +\
"a - Arrow Tower\n" +\
"f - Fire Tower\n" +\
"i - Ice Tower\n" +\
"q - quit"
self.displayControlsNode = OnscreenText(
text=text,
pos = (.95, 0),
scale = (0.05),
bg = (209/255.0, 168/255.0, 132/255.0, 1),
frame = (1, 0, 0, 1),
align = TextNode.ALeft
)
def displayGameOver(self):
text = "GAME OVER"
self.displayGameOverNode = OnscreenText(
text=text,
pos = (0, 0),
scale = (0.3),
bg = (0, 0, 1, 1),
frame = (1, 0, 0, 1)
)
sleep(1)
sleep(5)
def quit(self):
sys.exit()
#********************* Spawn Creeps ************************
def spawnWave(self, task):
if self.interval < task.time:
if len(self.creeps) < self.numberOfCreeps:
self.spawnCreep()
self.interval = task.time+1
else:
self.hasSpawnedWave = True
def spawnCreep(self):
if len(self.creeps) < self.numberOfCreeps:
currentCreep = len(self.creeps)
self.creeps.append(Creep(self, self.midPoints, currentCreep))
self.creeps[currentCreep].spawn() #Most recently added creep
self.creeps[currentCreep].move(self.pathSequence)
#Checks to see if any creeps left
def isCreeps(self):
for creep in self.creeps:
#Creep exists
if creep:
return True
self.creeps = []
return False
#********************* Level Handler *********************
def levelUp(self):
self.level += 1
if self.displayGameInfoNode1 != None:
self.displayGameInfoNode1.destroy()
self.displayGameInfoNode.destroy()
self.displayGameInfo()
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()
class CollisionManager:
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 col_army_against_battle(self, entry):
print "Army Joins!"
#base.net_manager.battle_join(bat,army)
army = entry.getFromNodePath()
a_id = int(army.getParent().getTag("id"))
a = base.armies[a_id]
if a.state == "normal":
battle = entry.getIntoNodePath()
b_id = int(battle.getParent().getTag("id"))
if base.single_player == False:
base.net_manager.server_messager(
"battle_armyadd",
[b_id, a_id,
a.node_path.getX(),
a.node_path.getY()])
a = base.armies[a_id]
b = base.battles[b_id]
b.add_army(a)
def col_p1_into_p2(self, entry):
if entry.getFromNodePath().getTag(
"state") == "normal" and entry.getIntoNodePath().getTag(
"state") == "normal" and entry.getIntoNodePath().getTag(
"type") == "army" and entry.getFromNodePath().getTag(
"type") == "army":
#base.net_manager.battle_start(a1,a2)
army1 = entry.getFromNodePath()
army2 = entry.getIntoNodePath()
a1_id = int(army1.getParent().getTag("id"))
a2_id = int(army2.getParent().getTag("id"))
a1 = base.armies[a1_id]
a2 = base.armies[a2_id]
a1.stop()
a2.stop()
base.battles.append(TimObjects.Battle([a1, a2]))
def col_army_against_tower(self, entry):
print "TOWER COLLIDE", entry.getIntoNodePath().getParent().getTag("id")
print entry.getIntoNodePath().getParent().getTag(
"player"), "vs", entry.getFromNodePath().getParent().getTag(
"player")
if entry.getIntoNodePath().getParent().getTag(
"player") != entry.getFromNodePath().getParent().getTag(
"player"):
tower = entry.getIntoNodePath()
tower_id = int(tower.getParent().getTag("id"))
invader = int(entry.getFromNodePath().getParent().getTag("player"))
if base.client == False and base.towers[tower_id].capture_check():
base.towers[tower_id].change_owner(invader)
if base.single_player == False:
base.net_manager.server_messager("tower_capture",
[tower_id, invader])
def col_in_object(self, entry):
np_into = entry.getIntoNodePath()
np_into.getParent().setColor(0.5, 0.5, 0.5, 0.1)
#self.global_text.setText(np_into.getName())
if np_into.getTag("type") == "battle":
print "You're in a battle"
#print "in"
def col_out_object(self, entry):
np_into = entry.getIntoNodePath()
#print "out"
try:
np_into.getParent().setColor(1, 1, 1, 1)
except:
print "ERROR CLEARING COLOUR"
#self.global_text.setText("")
self.pickable = None
self.selected_type = "none"
def col_against_object(self, entry):
if entry.getIntoNodePath().getParent() != self.pickable:
np_from = entry.getFromNodePath()
np_into = entry.getIntoNodePath()
self.selected_type = np_into.getTag("type")
self.pickable = np_into.getParent()
def mouse_click(self, status):
print "click"
in_statbar = base.vis_manager.statbar.mouse_in_bar()
if self.pickable and in_statbar == False:
if status == "down":
if self.selected_type == "army":
if base.armies[int(self.pickable.getTag(
"id"))].state == "normal" or base.armies[int(
self.pickable.getTag("id"))].state == "new":
for obj in self.selecteds:
obj.deselect()
print obj.my_id, "deselected"
self.selecteds = []
self.pickable.setScale(0.95 * 10)
self.selected = int(self.pickable.getTag("id"))
self.selected_node = self.pickable
self.selecteds.append(base.armies[self.selected])
base.armies[self.selected].select()
print "You clicked on Army" + str(self.selected)
base.vis_manager.statbar.show_army(self.selected)
elif self.selected_type == "tower":
for obj in self.selecteds:
obj.deselect()
print obj.my_id, "deselected"
self.selecteds = []
self.selected = int(self.pickable.getTag("id"))
self.selected_node = self.pickable
self.selecteds.append(base.towers[self.selected])
base.towers[self.selected].select()
print "You clicked on a tower"
base.vis_manager.statbar.show_tower(self.selected)
elif self.selected_type == "battle":
self.selected = int(self.pickable.getTag("id"))
self.selected_node = self.pickable
print "You clicked on a battle"
base.vis_manager.statbar.show_battle(self.selected)
if status == "up":
if self.selected_type == "army":
self.pickable.setScale(1.0 * 10)
elif status == "up" and self.multi_select == True:
self.multi_select = False
self.select_all_in_box()
elif in_statbar == True:
print "in box"
elif self.pickable == None:
for obj in self.selecteds:
obj.deselect()
print obj.my_id, "deselected"
self.selecteds = []
self.selected = -1
self.selected_node = None
base.vis_manager.statbar.reset_statbar()
def select_all_in_box(self):
for obj in self.selecteds:
obj.deselect()
print obj.my_id, "deselected"
self.selecteds = []
print "select units in box"
for a in base.armies:
if a.node_col.getTag("type") == "army" and (
a.state == "normal"
or a.state == "new") and a.player == base.player:
x = a.get_x()
y = a.get_y()
if self.box_x < self.model.getX(
) and self.box_y > self.model.getY():
if x < self.model.getX(
) and x > self.box_x and y > self.model.getY(
) and y < self.box_y:
self.selecteds.append(a)
a.select()
elif self.box_x < self.model.getX(
) and self.box_y < self.model.getY():
if x < self.model.getX(
) and x > self.box_x and y < self.model.getY(
) and y > self.box_y:
self.selecteds.append(a)
a.select()
elif self.box_x > self.model.getX(
) and self.box_y < self.model.getY():
if x > self.model.getX(
) and x < self.box_x and y < self.model.getY(
) and y > self.box_y:
self.selecteds.append(a)
a.select()
elif self.box_x > self.model.getX(
) and self.box_y > self.model.getY():
if x > self.model.getX(
) and x < self.box_x and y > self.model.getY(
) and y < self.box_y:
self.selecteds.append(a)
a.select()
def task_select_check(self, task):
if base.mouseWatcherNode.isButtonDown(MouseButton.one()):
#if self.multi_select == True:
self.box_x, self.box_y = self.model.getX(), self.model.getY()
taskMgr.add(self.draw_multiselect_box, "multibox")
return task.done
return task.cont
def draw_multiselect_box(self, task):
if base.mouseWatcherNode.isButtonDown(MouseButton.one()):
self.multi_select = True
self.select_box.remove()
ls = LineSegs()
ls.move_to(self.box_x, self.box_y, 1)
ls.draw_to(self.model.getX(), self.box_y, 1)
ls.draw_to(self.model.getX(), self.model.getY(), 1)
ls.draw_to(self.box_x, self.model.getY(), 1)
ls.draw_to(self.box_x, self.box_y, 1)
node = ls.create()
#text = TextNode('text')
#text.setText(str(self.box_x)+","+str(self.box_y)+"\n"+str(self.model.getX())+","+str(self.model.getY()))
#textnp = NodePath(text)
#textnp.setPos(self.box_x,self.box_y,1)
#textnp.setHpr(0,-90,0)
#textnp.setScale(20.0)
self.select_box = NodePath(node)
#textnp.reparentTo(self.select_box)
self.select_box.reparentTo(render)
return task.cont
else:
self.select_box.hide()
taskMgr.add(self.task_select_check, "updatePicker")
return task.done
def mouse_order(self):
print "mouse_order"
# if self.selected != -1 and base.armies[self.selected].state == "normal":
# print "orders sent"
for a in self.selecteds:
if a.node_col.getTag("type") == "army":
if len(self.selecteds) > 1:
randomness = (len(self.selecteds) - 1) * 10
a.set_target(
True,
self.pos3d.getX() + random.randint(0, randomness) -
randomness / 2,
self.pos3d.getY() + random.randint(0, randomness) -
randomness / 2)
else:
a.set_target(True, self.pos3d.getX(), self.pos3d.getY())
def get_mouse_plane_pos(self, task):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.pos3d = Point3()
nearPoint = Point3()
farPoint = Point3()
base.camLens.extrude(mpos, nearPoint, farPoint)
if self.plane.intersectsLine(
self.pos3d, render.getRelativePoint(camera, nearPoint),
render.getRelativePoint(camera, farPoint)):
#print "Mouse ray intersects ground plane at ", self.pos3d
self.model.setPos(render, self.pos3d)
return task.again
def ray_update(self, task):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
return task.cont
def load(self):
CogdoGameMovie.load(self)
self.toonDNA = ToonDNA.ToonDNA()
self.toonDNA.newToonFromProperties('dss', 'ss', 'm', 'm', 2, 0, 2, 2,
1, 8, 1, 8, 1, 14)
self.toonHead = Toon.Toon()
self.toonHead.setDNA(self.toonDNA)
self.makeSuit('sc')
self.toonHead.getGeomNode().setDepthWrite(1)
self.toonHead.getGeomNode().setDepthTest(1)
self.toonHead.loop('neutral')
self.toonHead.setPosHprScale(-0.73, 0, -1.27, 180, 0, 0, 0.18, 0.18,
0.18)
self.toonHead.reparentTo(hidden)
self.toonHead.startBlink()
self.cogHead = Suit.Suit()
self.cogDNA = SuitDNA.SuitDNA()
self.cogDNA.newSuit('ms')
self.cogHead.setDNA(self.cogDNA)
self.cogHead.getGeomNode().setDepthWrite(1)
self.cogHead.getGeomNode().setDepthTest(1)
self.cogHead.loop('neutral')
self.cogHead.setPosHprScale(-0.73, 0, -1.46, 180, 0, 0, 0.14, 0.14,
0.14)
self.cogHead.reparentTo(hidden)
self.clipPlane = self.toonHead.attachNewNode(PlaneNode('clip'))
self.clipPlane.node().setPlane(Plane(0, 0, 1, 0))
self.clipPlane.setPos(0, 0, 2.45)
audioMgr = base.cogdoGameAudioMgr
self._cogDialogueSfx = audioMgr.createSfx('cogDialogue')
self._toonDialogueSfx = audioMgr.createSfx('toonDialogue')
suitData = Globals.SuitData[Globals.SuitTypes.Boss]
bossSuit = Suit.Suit()
d = SuitDNA.SuitDNA()
d.newSuit(suitData['dnaName'])
bossSuit.setDNA(d)
bossSuit.setScale(suitData['scale'])
bossSuit.loop('neutral')
bossSuit.reparentTo(render)
bossSuit.setPos(self._exit, -5, -5, 0)
bossSuit.lookAt(self._exit)
self._suits.append(bossSuit)
self._camHelperNode = NodePath('CamHelperNode')
self._camHelperNode.reparentTo(render)
dialogue = TTLocalizer.CogdoMazeIntroMovieDialogue
introDuration = Globals.IntroDurationSeconds
waitDuration = introDuration / len(dialogue)
def start():
camera.wrtReparentTo(render)
self._exit.open(animate=False)
def showBoss():
self._setCamTarget(bossSuit,
20,
offset=Point3(0, 0, 7),
angle=Point3(0, 15, 0))
bossSuit.loop('victory')
self._state = 1
def showExit():
self._setCamTarget(self._exit,
10,
offset=Point3(0, 0, 0),
angle=Point3(0, 60, 0))
self._exit.close()
self._state = 2
showExitIval = Parallel(
camera.posInterval(waitDuration * 0.5, (10, -25, 20),
other=self._exit,
blendType='easeInOut'),
Sequence(
Wait(waitDuration * 0.25), Func(bossSuit.play, 'effort'),
camera.hprInterval(waitDuration * 0.25, (30, -30, 0),
blendType='easeInOut'),
Func(self._exit.close), Wait(waitDuration * 0.5)))
def showWaterCooler():
wc = self._maze.getWaterCoolers()[0]
self._setCamTarget(wc, 25, angle=Point3(-30, 60, 0))
camera.wrtReparentTo(self._camHelperNode)
self._state = 3
def end():
self._stopUpdateTask()
self._ival = Sequence(
Func(start),
Func(self.displayLine, 'toon', self._getRandomLine(dialogue[0])),
showExitIval, Func(showWaterCooler),
Func(self.displayLine, 'toon', self._getRandomLine(dialogue[1])),
Wait(waitDuration), Func(showBoss),
bossSuit.hprInterval(1.0,
bossSuit.getHpr() + Point3(180, 0, 0),
blendType='easeInOut'),
Func(self.displayLine, 'toon', self._getRandomLine(dialogue[2])),
Wait(waitDuration - 1.0), Func(end))
self._startUpdateTask()
class PointerSystem():
"""
Handles user pointer (mouse) input. Contains information and
functionality related to selecting and highlighting tiles.
"""
def __init__(self, tileMap):
self._tileMap = tileMap
self._groundPlane = Plane(Point3(0, 0, 1), Point3(0, 0, 1))
self._hoveredCoord = None # The coordinates we are hovering over.
self._highlightMode = None # Targeter reference
self._highlightModeParams = None # Targeter params dict
self._highlightedTiles = list() # List of tile highlighted by pointer.
self._previewTiles = list() # List of tiles highlighted by preview.
# Perform mouse raycasting every frame:
taskMgr.add(self._updateHovered, "mouseScanning")
def _updateHovered(self, task):
"""
Updates the position of the Highlighter selector based on mouse
position.
Only updates if the value should change. Should not call every frame
unless the user can shake his/her mouse really fast between tiles.
"""
if base.mouseWatcherNode.hasMouse(): # If mouse is in the window:
# Draw a line from the point on screen through the camera to the
# imaginary plane and check for intersections:
mPos = base.mouseWatcherNode.getMouse()
pos3D = Point3() # Output stored here.
nearPoint = Point3()
farPoint = Point3()
base.camLens.extrude(mPos, nearPoint, farPoint) # Create a line
# Check for intersection:
if self._groundPlane.intersectsLine(
pos3D, render.getRelativePoint(base.cam, nearPoint),
render.getRelativePoint(base.cam, farPoint)):
highlCoords = Point2D(int(pos3D.x), int(pos3D.y))
# Ensure the calculated position is a valid tile:
if self._hoveredCoord != highlCoords and\
self._tileMap.isFloor(highlCoords):
self._hoveredCoord = highlCoords
self._highlightTiles()
elif self._hoveredCoord != None and\
not self._tileMap.isFloor(highlCoords):
self._hoveredCoord = None
self._highlightTiles()
return task.cont
def setHighightMode(self, mode, params=None):
"""
Sets the current method of highlighting nodes given a mode.
Params allow for customizations specific to each mode, such as range
or AOE size.
"""
self._highlightMode = mode
self._highlightModeParams = params
# For special cases, show a preview highlight:
if self._highlightMode == Targeter.SelfReachPosition:
origin = self._highlightModeParams['origin']
reach = self._highlightModeParams['reach']
tiles = getAreaTiles(origin, self._tileMap, reach)
self._highlightPreviewTiles(tiles)
def resetHighlightMode(self):
"""
Resets highlight mode to None and removes all highlighted tiles.
"""
self._highlightMode = None
self._highlightModeParams = dict()
# Remove all previous highlights:
while len(self._highlightedTiles) > 0:
selector = self._highlightedTiles.pop(0)
selector.destroy()
while len(self._previewTiles) > 0:
selector = self._previewTiles.pop(0)
selector.destroy()
def _highlightPreviewTiles(self, coordsList):
"""
Preview highlights the given positions. Assumes valid positions.
"""
# Remove all previous highlights:
while len(self._previewTiles) > 0:
selector = self._previewTiles.pop(0)
selector.destroy()
# Create new previewers for each position:
count = 0
for coord in coordsList:
newHighlight = Selector("PreviewH %d" % count, PREVIEWER_TINT,
True)
newHighlight.showAt(coord)
self._previewTiles.append(newHighlight)
count += 1
def _highlightTiles(self):
"""
Highlights the tiles given by list of tile positions as highlighted
by the player's pointer.
Highlights in different ways depending on the highlightMode
"""
# Remove all previous highlights:
while len(self._highlightedTiles) > 0:
selector = self._highlightedTiles.pop(0)
selector.destroy()
# Depending on the highlight mode, fill a list of highlighted positions:
coordsList = list() # List of Point2D()
if self._highlightMode == Targeter.SelfPath and\
self._hoveredCoord != None:
# coordsList is the path to the tile from the current position.
fromPos = self._highlightModeParams['origin']
if self._hoveredCoord != fromPos:
coordsList = findTilesFromTo(fromPos, self._hoveredCoord,
self._tileMap)
elif self._highlightMode == Targeter.SelfReachPosition and\
self._hoveredCoord != None:
if tileWithinRange(self._highlightModeParams['origin'],
self._highlightModeParams['reach'],
self._hoveredCoord):
# Note, user is allowed to hit themselves!
coordsList.append(self._hoveredCoord)
if coordsList != None:
count = 0
for coord in coordsList:
newHighlight = Selector("HighL %d" % count, HIGHLIGHTER_TINT)
newHighlight.showAt(coord)
self._highlightedTiles.append(newHighlight)
count += 1
def getHovered(self):
return self._hoveredCoord
