def leftClick(self):
self.mouse1Down = True
#Collision traversal
pickerNode = CollisionNode('mouseRay')
pickerNP = base.camera.attachNewNode(pickerNode)
pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
pickerRay = CollisionRay()
pickerNode.addSolid(pickerRay)
myTraverser = CollisionTraverser()
myHandler = CollisionHandlerQueue()
myTraverser.addCollider(pickerNP, myHandler)
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
myTraverser.traverse(render)
# Assume for simplicity's sake that myHandler is a CollisionHandlerQueue.
if myHandler.getNumEntries() > 0:
# This is so we get the closest object
myHandler.sortEntries()
pickedObj = myHandler.getEntry(0).getIntoNodePath()
objTag = pickedObj.findNetTag('mouseCollisionTag').getTag('mouseCollisionTag')
if objTag and len(objTag)>0:
messenger.send('object_click',[objTag])
pickerNP.remove()
def leftClick(self):
self.mouse1Down = True
#Collision traversal
pickerNode = CollisionNode('mouseRay')
pickerNP = base.camera.attachNewNode(pickerNode)
pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
pickerRay = CollisionRay()
pickerNode.addSolid(pickerRay)
myTraverser = CollisionTraverser()
myHandler = CollisionHandlerQueue()
myTraverser.addCollider(pickerNP, myHandler)
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
myTraverser.traverse(render)
# Assume for simplicity's sake that myHandler is a CollisionHandlerQueue.
if myHandler.getNumEntries() > 0:
# This is so we get the closest object
myHandler.sortEntries()
pickedObj = myHandler.getEntry(0).getIntoNodePath()
objTag = pickedObj.findNetTag('mouseCollisionTag').getTag(
'mouseCollisionTag')
if objTag and len(objTag) > 0:
messenger.send('object_click', [objTag])
pickerNP.remove()
class RepairMousePicker:
def __init__(self):
self.pickerNode = CollisionNode('RepairMousePicker.pickerNode')
self.pickerNP = base.cam2d.attachNewNode(self.pickerNode)
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
self.collisionTraverser = CollisionTraverser()
self.collisionHandler = CollisionHandlerQueue()
self.collisionTraverser.addCollider(self.pickerNP, self.collisionHandler)
self.clearCollisionMask()
self.orthographic = True
def destroy(self):
del self.pickerNode
self.pickerNP.removeNode()
del self.pickerNP
del self.pickerRay
del self.collisionTraverser
del self.collisionHandler
def setOrthographic(self, ortho):
self.orthographic = ortho
def setCollisionMask(self, mask):
self.pickerNode.setFromCollideMask(mask)
def clearCollisionMask(self):
self.pickerNode.setFromCollideMask(BitMask32.allOff())
def getCollisions(self, traverseRoot, useIntoNodePaths = False):
if not base.mouseWatcherNode.hasMouse():
return []
mpos = base.mouseWatcherNode.getMouse()
if self.orthographic:
self.pickerRay.setFromLens(base.cam2d.node(), 0, 0)
self.pickerNP.setPos(mpos.getX(), 0.0, mpos.getY())
else:
self.pickerRay.setFromLens(base.cam2d.node(), mpos.getX(), mpos.getY())
self.pickerNP.setPos(0.0, 0.0, 0.0)
self.collisionTraverser.traverse(traverseRoot)
pickedObjects = []
if useIntoNodePaths:
for i in range(self.collisionHandler.getNumEntries()):
pickedObjects.append(self.collisionHandler.getEntry(i).getIntoNodePath())
else:
for i in range(self.collisionHandler.getNumEntries()):
pickedObjects.append(self.collisionHandler.getEntry(i))
return pickedObjects
class RepairMousePicker:
def __init__(self):
self.pickerNode = CollisionNode('RepairMousePicker.pickerNode')
self.pickerNP = base.cam2d.attachNewNode(self.pickerNode)
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
self.collisionTraverser = CollisionTraverser()
self.collisionHandler = CollisionHandlerQueue()
self.collisionTraverser.addCollider(self.pickerNP,
self.collisionHandler)
self.clearCollisionMask()
self.orthographic = True
def destroy(self):
del self.pickerNode
self.pickerNP.removeNode()
del self.pickerNP
del self.pickerRay
del self.collisionTraverser
del self.collisionHandler
def setOrthographic(self, ortho):
self.orthographic = ortho
def setCollisionMask(self, mask):
self.pickerNode.setFromCollideMask(mask)
def clearCollisionMask(self):
self.pickerNode.setFromCollideMask(BitMask32.allOff())
def getCollisions(self, traverseRoot, useIntoNodePaths=False):
if not base.mouseWatcherNode.hasMouse():
return []
mpos = base.mouseWatcherNode.getMouse()
if self.orthographic:
self.pickerRay.setFromLens(base.cam2d.node(), 0, 0)
self.pickerNP.setPos(mpos.getX(), 0.0, mpos.getY())
else:
self.pickerRay.setFromLens(base.cam2d.node(), mpos.getX(),
mpos.getY())
self.pickerNP.setPos(0.0, 0.0, 0.0)
self.collisionTraverser.traverse(traverseRoot)
pickedObjects = []
if useIntoNodePaths:
for i in range(self.collisionHandler.getNumEntries()):
pickedObjects.append(
self.collisionHandler.getEntry(i).getIntoNodePath())
else:
for i in range(self.collisionHandler.getNumEntries()):
pickedObjects.append(self.collisionHandler.getEntry(i))
return pickedObjects
class Selector(object):
'''A Selector listens for mouse clicks and then runs select. Select then
broadcasts the selected tag (if there is one)'''
def __init__(self):
''' Should the traverser be shared? '''
LOG.debug("[Selector] Initializing")
# The collision traverser does the checking of solids for collisions
self.cTrav = CollisionTraverser()
# The collision handler queue is a simple handler that records all
# detected collisions during traversal
self.cHandler = CollisionHandlerQueue()
self.pickerNode = CollisionNode('mouseRay')
self.pickerNP = camera.attachNewNode(self.pickerNode)
self.pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
self.cTrav.addCollider(self.pickerNP, self.cHandler)
# Start listening to clicks
self.resume()
def select(self, event):
LOG.debug("[Selector] Selecting ")
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
self.cTrav.traverse(render) # TODO - change this to a lower node
if self.cHandler.getNumEntries() > 0:
#LOG.debug("[Selector] Entries=%d"%self.cHandler.getNumEntries())
self.cHandler.sortEntries()
selectionNP = self.cHandler.getEntry(0).getIntoNodePath()
selection = selectionNP.findNetTag('SelectorTag').getTag(
'SelectorTag')
if selection is not '':
LOG.debug("[Selector] Collision with %s" % selection)
Event.Dispatcher().broadcast(
Event.Event('E_EntitySelect', src=self,
data=selection))
else:
LOG.debug("[Selector] No collision")
#Event.Dispatcher().broadcast(Event.Event('E_EntityUnSelect', src=self, data=selection))
def pause(self):
Event.Dispatcher().unregister(self, 'E_Mouse_1')
def resume(self):
print("unpausing selector")
Event.Dispatcher().register(self, 'E_Mouse_1', self.select)
class Selector(object):
'''A Selector listens for mouse clicks and then runs select. Select then
broadcasts the selected tag (if there is one)'''
def __init__(self):
''' Should the traverser be shared? '''
LOG.debug("[Selector] Initializing")
# The collision traverser does the checking of solids for collisions
self.cTrav = CollisionTraverser()
# The collision handler queue is a simple handler that records all
# detected collisions during traversal
self.cHandler = CollisionHandlerQueue()
self.pickerNode = CollisionNode('mouseRay')
self.pickerNP = camera.attachNewNode(self.pickerNode)
self.pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
self.cTrav.addCollider(self.pickerNP, self.cHandler)
# Start listening to clicks
self.resume()
def select(self, event):
LOG.debug("[Selector] Selecting ")
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
self.cTrav.traverse(render) # TODO - change this to a lower node
if self.cHandler.getNumEntries() > 0:
#LOG.debug("[Selector] Entries=%d"%self.cHandler.getNumEntries())
self.cHandler.sortEntries()
selectionNP = self.cHandler.getEntry(0).getIntoNodePath()
selection = selectionNP.findNetTag('SelectorTag').getTag('SelectorTag')
if selection is not '':
LOG.debug("[Selector] Collision with %s" % selection)
Event.Dispatcher().broadcast(Event.Event('E_EntitySelect', src=self, data=selection))
else:
LOG.debug("[Selector] No collision")
#Event.Dispatcher().broadcast(Event.Event('E_EntityUnSelect', src=self, data=selection))
def pause(self):
Event.Dispatcher().unregister(self, 'E_Mouse_1')
def resume(self):
print("unpausing selector")
Event.Dispatcher().register(self, 'E_Mouse_1', self.select)
class Picker(object):
'''
classdocs
'''
def __init__(self, camera, mouseWatcherNode, camNode, things):
'''
Constructor
'''
self.mouseWatcherNode = mouseWatcherNode
self.camNode = camNode
self.things = things
self.pickerRay = CollisionRay()
self.pickerNode = CollisionNode('mouseRay')
self.pickerNode.setFromCollideMask(BitMask32.bit(1))
self.pickerNode.addSolid(self.pickerRay)
self.pickerNP = camera.attachNewNode(self.pickerNode)
self.pq = CollisionHandlerQueue()
self.picker = CollisionTraverser()
self.picker.addCollider(self.pickerNP, self.pq)
def getMouseOn(self, mouse_x, mouse_y):
#Set the position of the ray based on the mouse position
self.pickerRay.setFromLens(self.camNode, mouse_x, mouse_y)
self.picker.traverse(self.things.node)
if self.pq.getNumEntries() > 0:
#if we have hit something, sort the hits so that the closest
#is first, and highlight that node
self.pq.sortEntries()
selectedNode = self.pq.getEntry(0).getIntoNode()
selectedNodeId = selectedNode.getTag('nodeId')
thingId = selectedNode.getTag('ID')
mouseOnInfo = MouseOnInfo(self.things.getById(thingId), thingId, selectedNode, selectedNodeId, mouse_x, mouse_y)
return mouseOnInfo
class mouseControl(DirectObject):
def __init__(self):
self.picker = CollisionTraverser()
self.pickerQ = CollisionHandlerQueue()
pickerCollN = CollisionNode('mouseRay')
pickerCamN = base.camera.attachNewNode(pickerCollN)
pickerCollN.setFromCollideMask(BitMask32.bit(1))
pickerCollN.setIntoCollideMask(BitMask32.allOff())
self.pickerRay = CollisionRay()
pickerCollN.addSolid(self.pickerRay)
self.picker.addCollider(pickerCamN, self.pickerQ)
self.accept('mouse1',self.pick)
def pick(self):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
self.picker.traverse(render)
for i in xrange(self.pickerQ.getNumEntries()):
entry=self.pickerQ.getEntry(i)
player.control('replace_wp', ('goto', Vec3(entry.getSurfacePoint(render))))
class Gui3D:
def __init__(self, game_data, gfx_manager):
self.game_data = game_data
self.gui_traverser = CollisionTraverser()
self.handler = CollisionHandlerQueue()
self.selectable_objects = {}
for cid, model in gfx_manager.character_models.items():
new_collision_node = CollisionNode('person_' + str(cid))
new_collision_node.addSolid(
CollisionTube(0, 0, 0.5, 0, 0, 1.5, 0.5))
new_collision_nodepath = model.attachNewNode(new_collision_node)
new_collision_nodepath.setTag("type", "character")
new_collision_nodepath.setTag("id", str(cid))
picker_node = CollisionNode('mouseRay')
picker_np = camera.attachNewNode(picker_node)
self.picker_ray = CollisionRay()
picker_node.addSolid(self.picker_ray)
self.gui_traverser.addCollider(picker_np, self.handler)
self.floor = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0)))
self.floor_np = render.attachNewNode(CollisionNode('floor'))
self.floor_np.setTag("type", "ground")
self.floor_np.node().addSolid(self.floor)
def mouse_click(self):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.picker_ray.setFromLens(base.camNode, mpos.getX(), mpos.getY())
self.gui_traverser.traverse(render)
num_entries = self.handler.getNumEntries()
if num_entries > 0:
self.handler.sortEntries()
entry = self.handler.getEntry(0)
selected = entry.getIntoNodePath()
selected_type = selected.getTag("type")
if selected_type == "character":
self.game_data.select_character(int(selected.getTag("id")))
elif selected_type == "ground":
self.game_data.click_point(entry.getSurfacePoint(render))
class Gui3D:
def __init__(self, game_data, gfx_manager):
self.game_data = game_data
self.gui_traverser = CollisionTraverser()
self.handler = CollisionHandlerQueue()
self.selectable_objects = {}
for cid, model in gfx_manager.character_models.items():
new_collision_node = CollisionNode('person_' + str(cid))
new_collision_node.addSolid(CollisionTube(0, 0, 0.5, 0, 0, 1.5, 0.5))
new_collision_nodepath = model.attachNewNode(new_collision_node)
new_collision_nodepath.setTag("type","character")
new_collision_nodepath.setTag("id",str(cid))
picker_node = CollisionNode('mouseRay')
picker_np = camera.attachNewNode(picker_node)
self.picker_ray = CollisionRay()
picker_node.addSolid(self.picker_ray)
self.gui_traverser.addCollider(picker_np, self.handler)
self.floor = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0)))
self.floor_np = render.attachNewNode(CollisionNode('floor'))
self.floor_np.setTag("type", "ground")
self.floor_np.node().addSolid(self.floor)
def mouse_click(self):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.picker_ray.setFromLens(base.camNode, mpos.getX(), mpos.getY())
self.gui_traverser.traverse(render)
num_entries = self.handler.getNumEntries()
if num_entries > 0:
self.handler.sortEntries()
entry = self.handler.getEntry(0)
selected = entry.getIntoNodePath()
selected_type = selected.getTag("type")
if selected_type == "character":
self.game_data.select_character(int(selected.getTag("id")))
elif selected_type == "ground":
self.game_data.click_point(entry.getSurfacePoint(render))
class Mouse(DirectObject):
def __init__(self, app):
self.app = app
self.init_collide()
self.has_mouse = None
self.prev_pos = None
self.pos = None
self.drag_start = None
self.hovered_object = None
self.button2 = False
self.mouseTask = taskMgr.add(self.mouse_task, 'mouseTask')
self.task = None
self.accept('mouse1', self.mouse1)
self.accept('mouse1-up', self.mouse1_up)
self.accept('mouse2', self.rotateCamera)
self.accept('mouse2-up', self.stopCamera)
self.accept('wheel_up', self.zoomIn)
self.accept('wheel_down', self.zoomOut)
def init_collide(self):
from pandac.PandaModules import CollisionTraverser, CollisionNode
from pandac.PandaModules import CollisionHandlerQueue, CollisionRay
self.cTrav = CollisionTraverser('MousePointer')
self.cQueue = CollisionHandlerQueue()
self.cNode = CollisionNode('MousePointer')
self.cNodePath = base.camera.attachNewNode(self.cNode)
self.cNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.cRay = CollisionRay()
self.cNode.addSolid(self.cRay)
self.cTrav.addCollider(self.cNodePath, self.cQueue)
def find_object(self):
if self.app.world.nodePath:
self.cRay.setFromLens(base.camNode, self.pos.getX(), self.pos.getY())
self.cTrav.traverse(self.app.world.terrain.nodePath)
if self.cQueue.getNumEntries() > 0:
self.cQueue.sortEntries()
return self.cQueue.getEntry(0).getIntoNodePath()
return None
def mouse_task(self, task):
action = task.cont
self.has_mouse = base.mouseWatcherNode.hasMouse()
if self.has_mouse:
self.pos = base.mouseWatcherNode.getMouse()
if self.prev_pos:
self.delta = self.pos - self.prev_pos
else:
self.delta = None
if self.task:
action = self.task(task)
else:
self.pos = None
if self.pos:
self.prev_pos = Point2(self.pos.getX(), self.pos.getY())
return action
def hover(self, task):
if self.hovered_object:
self.hovered_object.unhover()
self.hovered_object = None
if self.button2:
self.camera_drag()
hovered_nodePath = self.find_object()
if hovered_nodePath:
tile = hovered_nodePath.findNetTag('tile')
if not tile.isEmpty():
tag = tile.getTag('tile')
coords = tag.split(',')
(x, y) = [int(n) for n in coords]
self.hovered_object = self.app.world.terrain.rows[x][y]
self.hovered_object.hover()
character = hovered_nodePath.findNetTag('char')
if not character.isEmpty():
tag = character.getTag('char')
(team_index, char_id) = [int(n) for n in tag.split(',')]
self.hovered_object = self.app.world.teams[team_index].characters_dict[char_id]
self.hovered_object.hover()
return task.cont
def mouse1(self):
self.app.state.request('mouse1')
def mouse1_up(self):
self.app.state.request('mouse1-up')
def camera_drag(self):
if self.delta:
old_heading = base.camera.getH()
new_heading = old_heading - self.delta.getX() * 180
base.camera.setH(new_heading % 360)
old_pitch = base.camera.getP()
new_pitch = old_pitch + self.delta.getY() * 90
new_pitch = max(-90, min(0, new_pitch))
base.camera.setP(new_pitch)
def rotateCamera(self):
self.button2 = True
def stopCamera(self):
self.button2 = False
def zoomIn(self):
lens = base.cam.node().getLens()
size = lens.getFilmSize()
lens.setFilmSize(size / 1.2)
def zoomOut(self):
lens = base.cam.node().getLens()
size = lens.getFilmSize()
lens.setFilmSize(size * 1.2)
class Mouse(DirectObject):
def __init__(self, app):
# local variables for mouse class
self.app = app
self.init_collide()
self.has_mouse = None
self.prev_pos = None
self.pos = None
self.drag_start = None
self.hovered_object = None
self.button2 = False
self.mouseTask = taskMgr.add(self.mouse_task, 'mouseTask')
self.task = None
# set up event and response to this event
self.accept('mouse1', self.mouse1)
self.accept('mouse1-up', self.mouse1_up)
# change the mouse to accept 'right-click' to rotate camera
self.accept('mouse3', self.rotateCamera)
self.accept('mouse3-up', self.stopCamera)
self.accept('wheel_up', self.zoomIn)
self.accept('wheel_down', self.zoomOut)
# set up the collision for object
def init_collide(self):
# why the heck he import within method
from pandac.PandaModules import CollisionTraverser, CollisionNode
from pandac.PandaModules import CollisionHandlerQueue, CollisionRay
# init and import collision for object
self.cTrav = CollisionTraverser('MousePointer')
self.cQueue = CollisionHandlerQueue()
self.cNode = CollisionNode('MousePointer')
self.cNodePath = base.camera.attachNewNode(self.cNode)
self.cNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.cRay = CollisionRay()
self.cNode.addSolid(self.cRay)
self.cTrav.addCollider(self.cNodePath, self.cQueue)
# by the collision methods mouse is able to find out which tile mouse is at
def find_object(self):
if self.app.world.nodePath:
self.cRay.setFromLens(base.camNode, self.pos.getX(),
self.pos.getY())
self.cTrav.traverse(self.app.world.terrain.nodePath)
if self.cQueue.getNumEntries() > 0:
self.cQueue.sortEntries()
return self.cQueue.getEntry(0).getIntoNodePath()
return None
# setting task for mouse
def mouse_task(self, task):
action = task.cont
# if the current tile has a mouse point to this
self.has_mouse = base.mouseWatcherNode.hasMouse()
if self.has_mouse:
self.pos = base.mouseWatcherNode.getMouse()
if self.prev_pos:
self.delta = self.pos - self.prev_pos
else:
self.delta = None
if self.task:
action = self.task(task)
else:
self.pos = None
if self.pos:
self.prev_pos = Point2(self.pos.getX(), self.pos.getY())
return action
# when mouse hover over this hexagon
def hover(self, task):
if self.hovered_object:
self.hovered_object.unhover()
self.hovered_object = None
if self.button2:
self.camera_drag()
hovered_nodePath = self.find_object()
if hovered_nodePath:
tile = hovered_nodePath.findNetTag('tile')
if not tile.isEmpty():
tag = tile.getTag('tile')
coords = tag.split(',')
(x, y) = [int(n) for n in coords]
# set the hovered target to be the corresponding hexagon on terrain
self.hovered_object = self.app.world.terrain.rows[x][y]
self.hovered_object.hover()
character = hovered_nodePath.findNetTag('char')
if not character.isEmpty():
tag = character.getTag('char')
(team_index, char_id) = [int(n) for n in tag.split(',')]
self.hovered_object = self.app.world.teams[
team_index].characters_dict[char_id]
self.hovered_object.hover()
ghost = hovered_nodePath.findNetTag('ghost')
if not ghost.isEmpty():
tag = ghost.getTag('ghost')
(team_index, char_id) = [int(n) for n in tag.split(',')]
for ghostInstance in self.app.ghosts:
if (ghostInstance.team.index
== team_index) and (ghostInstance.id == char_id):
self.hovered_object = ghostInstance
self.hovered_object.hover()
return task.cont
def mouse1(self):
self.app.state.request('mouse1')
def mouse1_up(self):
self.app.state.request('mouse1-up')
def camera_drag(self):
if self.delta:
old_heading = base.camera.getH()
new_heading = old_heading - self.delta.getX() * 180
base.camera.setH(new_heading % 360)
old_pitch = base.camera.getP()
new_pitch = old_pitch + self.delta.getY() * 90
new_pitch = max(-90, min(-10, new_pitch))
base.camera.setP(new_pitch)
def rotateCamera(self):
self.button2 = True
def stopCamera(self):
self.button2 = False
def zoomIn(self):
lens = base.cam.node().getLens()
size = lens.getFilmSize()
if size.length() >= 75:
lens.setFilmSize(size / 1.2)
def zoomOut(self):
lens = base.cam.node().getLens()
size = lens.getFilmSize()
if size.length() <= 250:
lens.setFilmSize(size * 1.2)
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")
class World(DirectObject):
def __init__(self):
self.keyMap = {"left":0, "right":0, "forward":0, "backward":0, "shoot":0}
base.win.setClearColor(Vec4(0,0,0,1))
# Post the instructions
self.inst6 = addInstructions(0.95, "Mad Max's Revenge!")
self.inst1 = addInstructions(0.90, "[ESC]: Quit")
self.inst2 = addInstructions(0.85, "[a]: Left Turn")
self.inst3 = addInstructions(0.80, "[d]: Right Turn")
self.inst4 = addInstructions(0.75, "[w]: Drive Forward")
self.inst4 = addInstructions(0.70, "[s]: Reverse")
self.inst5 = addInstructions(0.65, "[mouse]: Fire Rocket")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("Assets/Models/env") #models/environment
self.environ.reparentTo(render)
self.environ.setPos(0,0,0)
self.sky = loader.loadModel("Assets/Models/sky") #models/environment
self.sky.reparentTo(render)
self.sky.setPos(0,0,0)
# Create the main character, player
playerStartPos = Point3(8,14,1) #self.environ.find("**/start_point").getPos()
enemyStartPos = Point3(-7,-8,1) #self.environ.find("**/start_point").getPos()
#~ print enemyStartPos
enemyStartPos.addX(1.0)
enemyStartPos.addY(1.0)
#~ print enemyStartPos
self.player = Actor("Assets/Models/player_model", {"drive":"Assets/Models/player_drive", "fire":"Assets/Models/player_turret", "drivefire":"Assets/Models/player_both"})
self.player.reparentTo(render)
self.player.setScale(0.1)
self.player.setPos(playerStartPos)
#~ self.playerdrive=self.player.actorInterval("drive")
#~ self.playerfire=self.player.actoraaaaaaaInterval("fire")
#~ self.playerdrivefire=self.player.actorInterval("drivefire")
# Create the enemy, Enemy
self.enemy = Actor("Assets/Models/enemy_model", {"drive":"Assets/Models/enemy_drive", "fire":"Assets/Models/enemy_turret", "drivefire":"Assets/Models/enemy_both"})
self.enemy.reparentTo(render)
self.enemy.setScale(0.1)
tex = loader.loadTexture("Assets/Models/cartexture1.png")
self.enemy.setTexture(tex, 1)
self.enemy.setPos(enemyStartPos)
self.enemyrockettiming = globalClock.getFrameTime()
#print self.enemy.getCurrentAnim()
#print self.enemy.getCurrentAnim()
#~ self.enemydrive=self.enemy.actorInterval("drive")
#~ self.enemyfire=self.enemy.actorInterval("fire")
#~ self.enemydrivefire=self.enemy.actorInterval("drivefire")
self.music = loader.loadMusic("Assets/Sound/music.mp3")
SoundInterval(self.music).loop()
audio3d.attachSoundToObject(EnemyRunning, self.enemy)
audio3d.attachSoundToObject(EnemyIdling, self.enemy)
backward = self.enemy.getNetTransform().getMat().getRow3(1)
backward.setZ(0)
backward.normalize()
#self.enemy.setPos(self.enemy.getPos() - backward*(50))
#Set up the lighting
self.playerleftlight=self.player.attachNewNode(Spotlight("playerheadleft"))
self.playerleftlight.node().setColor(Vec4(0.75, 0.75, 0.75, 1))
self.playerleftlight.node().setLens( PerspectiveLens() )
self.playerleftlight.node().getLens().setFov( 50, 50)
self.playerleftlight.node().setAttenuation( Vec3( 0.1, 0.005, 0.0 ) )
self.playerleftlight.node().setExponent( 60.0 )
self.playerleftlight.setPos(-1, -0.1, 1.5)
self.playerleftlight.setHpr(180, -10, 0)
render.setLight(self.playerleftlight)
self.playerrightlight=self.player.attachNewNode(Spotlight("playerheadright"))
self.playerrightlight.node().setColor(Vec4(0.75, 0.75, 0.75, 1))
self.playerrightlight.node().setLens( PerspectiveLens() )
self.playerrightlight.node().getLens().setFov( 50, 50)
self.playerrightlight.node().setAttenuation( Vec3( 0.1, 0.005, 0.0 ) )
self.playerrightlight.node().setExponent( 60.0 )
self.playerrightlight.setPos(1, -0.1, 1.5)
self.playerrightlight.setHpr(180, -10, 0)
render.setLight(self.playerrightlight)
self.playerlightson=1
self.enemyleftlight=self.enemy.attachNewNode(Spotlight("enemyheadleft"))
self.enemyleftlight.node().setColor(Vec4(0.75, 0.75, 0.75, 1))
self.enemyleftlight.node().setLens( PerspectiveLens() )
self.enemyleftlight.node().getLens().setFov( 50, 50)
self.enemyleftlight.node().setAttenuation( Vec3( 0.1, 0.005, 0.0 ) )
self.enemyleftlight.node().setExponent( 60.0 )
self.enemyleftlight.setPos(-1, -0.1, 1.5)
self.enemyleftlight.setHpr(180, -10, 0)
render.setLight(self.enemyleftlight)
self.enemyrightlight=self.enemy.attachNewNode(Spotlight("enemyheadright"))
self.enemyrightlight.node().setColor(Vec4(0.75, 0.75, 0.75, 1))
self.enemyrightlight.node().setLens( PerspectiveLens() )
self.enemyrightlight.node().getLens().setFov( 50, 50)
self.enemyrightlight.node().setAttenuation( Vec3( 0.1, 0.005, 0.0 ) )
self.enemyrightlight.node().setExponent( 60.0 )
self.enemyrightlight.setPos(1, -0.1, 1.5)
self.enemyrightlight.setHpr(180, -10, 0)
render.setLight(self.enemyrightlight)
self.enemylightson=1
self.spotlight=camera.attachNewNode(PointLight("spotlight"))
#self.spotlight.setPos(0, 3, 0.5)
#self.spotlight.setHpr(0, 0, 0)
self.spotlight.node().setColor(Vec4(1, 1, 1, 1))
#self.spotlight.node().setLens( PerspectiveLens() )
#self.spotlight.node().getLens().setFov( 180, 120)
self.spotlight.node().setAttenuation( Vec3( 1, 0, 0.05 ))
#self.spotlight.node().setExponent( 60.0 )
render.setLight(self.spotlight)
self.playerlight=self.player.attachNewNode(PointLight("spotlight"))
self.playerlight.node().setColor(Vec4(1, 1, 1, 1))
#self.spotlight.node().setLens( PerspectiveLens() )
#self.spotlight.node().getLens().setFov( 180, 120)
self.playerlight.node().setAttenuation( Vec3( 1, 0, 0.05 ))
#self.spotlight.node().setExponent( 60.0 )
render.setLight(self.playerlight)
self.ambientlight=self.sky.attachNewNode(AmbientLight("ambientLight"))
self.ambientlight.node().setColor(Vec4(1, 1, 1, 1))
self.sky.setLight(self.ambientlight)
# Create a floater object. We use the "floater" as a temporary
# variable in a variety of calculations.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("a", self.setKey, ["left",1])
self.accept("d", self.setKey, ["right",1])
self.accept("w", self.setKey, ["forward",1])
self.accept("s", self.setKey, ["backward",1])
self.accept("a-up", self.setKey, ["left",0])
self.accept("d-up", self.setKey, ["right",0])
self.accept("w-up", self.setKey, ["forward",0])
self.accept("s-up", self.setKey, ["backward",0])
self.accept("l", self.playerLights,[])
self.accept("mouse1", self.setKey, ["shoot", 1])
self.accept("mouse1-up", self.setKey, ["shoot", 0]) #self.shootRocketshootRocket
taskMgr.add(self.playerMove,"moveTask")
taskMgr.add(self.enemyMove,"moveTask")
taskMgr.add(self.shoot,"shootTask")
taskMgr.add(self.rocketCollision,"rocketCollision")
# Game state variables
self.prevtime = 0
self.isMoving = False
self.prevShotTime = 0
self.prevEnemyMoveTime = 0
# Set up the camera
base.disableMouse()
base.camera.setPos(self.player.getX(),self.player.getY()+10,2)
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above player's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.playerGroundRay = CollisionRay()
self.playerGroundRay.setOrigin(0,0,1000)
self.playerGroundRay.setDirection(0,0,-1)
self.playerGroundCol = CollisionNode('playerRay')
self.playerGroundCol.addSolid(self.playerGroundRay)
self.playerGroundCol.setFromCollideMask(BitMask32.bit(3))
self.playerGroundCol.setIntoCollideMask(BitMask32.allOff())
self.playerGroundColNp = self.player.attachNewNode(self.playerGroundCol)
self.playerGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.playerGroundColNp, self.playerGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0,0,1000)
self.camGroundRay.setDirection(0,0,-1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(3))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
#self.playerGroundColNp.show()
#self.camGroundColNp.show()
#Uncomment this line to show a visual representation of the
#collisions occuring
#self.cTrav.showCollisions(render)
#Code for Enemy player
self.enemyGroundRay = CollisionRay()
self.enemyGroundRay.setOrigin(0,0,1000)
self.enemyGroundRay.setDirection(0,0,-1)
self.enemyGroundCol = CollisionNode('enemyRay')
self.enemyGroundCol.addSolid(self.enemyGroundRay)
self.enemyGroundCol.setFromCollideMask(BitMask32.bit(3))
self.enemyGroundCol.setIntoCollideMask(BitMask32.allOff())
self.enemyGroundColNp = self.enemy.attachNewNode(self.enemyGroundCol)
self.enemyGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.enemyGroundColNp, self.enemyGroundHandler)
self.cRocketHandler = CollisionHandlerQueue()
self.worldEdge = CollisionInvSphere(0, 0, 0, 50)
cNode = CollisionNode("worldEdge")
cNode.addSolid(self.worldEdge)
cNode.setFromCollideMask(BitMask32.allOff())
cNode.setIntoCollideMask(BitMask32.allOn())
self.worldEdgeNp=self.environ.attachNewNode(cNode)
#self.cTrav.addCollider(self.worldEdgeNp, self.cRocketHandler)
#cNP = render.attachNewNode(cNode)
cNode2 = CollisionNode("wall")
cNode2.addSolid(CollisionPlane(Plane(Vec3(-1,0,0), Point3(22.5,0,0))))
cNode2.addSolid(CollisionPlane(Plane(Vec3(1,0,0), Point3(-22.5,0,0))))
cNode2.addSolid(CollisionPlane(Plane(Vec3(0,-1,0), Point3(0,22.5,0))))
cNode2.addSolid(CollisionPlane(Plane(Vec3(0,1,0), Point3(0,-22.5,0))))
cNode2.setFromCollideMask(BitMask32.allOff())
cNode2.setIntoCollideMask(BitMask32.allOn())
cNP2=self.environ.attachNewNode(cNode2)
self.picker = CollisionTraverser() #Make a traverser
self.pq = CollisionHandlerQueue() #Make a handler
#Make a collision node for our picker ray
self.pickerNode = CollisionNode('mouseRay')
#Attach that node to the camera since the ray will need to be positioned
#relative to it
self.pickerNP = camera.attachNewNode(self.pickerNode)
#Everything to be picked will use bit 1. This way if we were doing other
#collision we could seperate it
self.pickerNode.setFromCollideMask(BitMask32.allOn())
self.pickerRay = CollisionRay() #Make our ray
self.pickerNode.addSolid(self.pickerRay) #Add it to the collision node
#Register the ray as something that can cause collisions
self.picker.addCollider(self.pickerNP, self.pq)
self.playerrocket = None
self.enemyrocket = None
self.enemyTurn = 0
self.enemyDestAng = 180
self.enemyHp = 3
self.playerHp = 3
#Collisions
self.setupCollisions()
self.playermoving = False
#setup hud
self.drawHud()
def drawHud(self):
#Player
OnscreenText(text="Player Health", style=1, fg=(1,1,1,1), pos=(0.85, 0.9), align=TextNode.ALeft, scale = .08)
self.playerHealthImg = OnscreenImage(image = 'Assets/Images/healthFull.png', pos = (1.05, 0, .84), scale = .12)
self.playerHealthImg.setTransparency(TransparencyAttrib.MAlpha)
#Enemy
OnscreenText(text="Enemy Health", style=1, fg=(1,1,1,1), pos=(0.85, 0.7), align=TextNode.ALeft, scale = .08)
self.enemyHealthImg = OnscreenImage(image = 'Assets/Images/healthFull.png', pos = (1.05, 0, .64), scale = .12)
self.enemyHealthImg.setTransparency(TransparencyAttrib.MAlpha)
def updateGui(self):
#player bar
if self.playerHp == 2:
self.playerHealthImg.setImage('Assets/Images/healthMedium.png')
self.playerHealthImg.setTransparency(TransparencyAttrib.MAlpha)
elif self.playerHp == 1:
self.playerHealthImg.setImage('Assets/Images/healthLow.png')
self.playerHealthImg.setTransparency(TransparencyAttrib.MAlpha)
#enemy bar
if self.enemyHp == 2:
self.enemyHealthImg.setImage('Assets/Images/healthMedium.png')
self.enemyHealthImg.setTransparency(TransparencyAttrib.MAlpha)
elif self.enemyHp == 1:
self.enemyHealthImg.setImage('Assets/Images/healthLow.png')
self.enemyHealthImg.setTransparency(TransparencyAttrib.MAlpha)
def setupCollisions(self):
#player sphere
cPlayerSphere = CollisionSphere(Point3(0, 0, .5), 10)
cPlayerNode = CollisionNode("Player")
cPlayerNode.addSolid(cPlayerSphere)
cPlayerNode.setFromCollideMask(BitMask32.bit(4))
cPlayerNode.setIntoCollideMask(BitMask32(20))
cPlayerNP = self.player.attachNewNode(cPlayerNode)
self.cTrav.addCollider(cPlayerNP, self.playerGroundHandler)
#self.cTrav.addCollider(cPlayerNP, self.cRocketHandler)
#cPlayerNP.show()
#enemy sphere
cEnemySphere = CollisionSphere(Point3(0, 0, .5), 10)
cEnemyNode = CollisionNode("Enemy")
cEnemyNode.addSolid(cEnemySphere)
cEnemyNode.setFromCollideMask(BitMask32.bit(4))
cEnemyNode.setIntoCollideMask(BitMask32(18))
cEnemyNP = self.enemy.attachNewNode(cEnemyNode)
self.cTrav.addCollider(cEnemyNP, self.enemyGroundHandler)
#self.cTrav.addCollider(cEnemyNP, self.cRocketHandler)
#cEnemyNP.show()
def rocketCollision(self, task):
"""Check for rocket collisions with players and objects"""
toRemove = []
for i in range(self.cRocketHandler.getNumEntries()):
entry = self.cRocketHandler.getEntry(i)
#~ print entry
if entry.getFromNode().getName() == "PlayerRocket" and entry.getIntoNode().getName() == "Enemy":
self.enemyHp -= 1
self.updateGui()
if self.enemyHp == 0:
print "Victory!"
OnscreenText(text="Victory!", style=2, fg=(0,1,0,1),
pos=(-0.6, 0), align=TextNode.ALeft, scale = .5, shadow=(0,0,0,0))
self.playerHp += 5
#LerpFunc(end_game, fromData = 0, toData = 1, duration = 3.0,
#blendType = 'noBlend', extraArgs = [], name = None)
taskMgr.remove("moveTask")
taskMgr.remove("shootTask")
#print "GAME OVER, YOU WIN"
#sys.exit(0)
elif entry.getFromNode().getName() == "EnemyRocket" and entry.getIntoNode().getName() == "Player":
self.playerHp -= 1
self.updateGui()
if self.playerHp == 0:
#~ print "GAME OVER, YOU LOSE"
OnscreenText(text="Failure!", style=2, fg=(1,0,0,1),
pos=(-0.6, 0), align=TextNode.ALeft, scale = .5, shadow=(0,0,0,0))
self.enemyHp += 5
taskMgr.remove("moveTask")
taskMgr.remove("shootTask")
#Add to remove list
if entry.getFromNodePath() not in toRemove:
toRemove.append(entry.getFromNodePath())
#remove
for np in toRemove:
if np.getNode(0).getName() == "PlayerRocket":
if self.playerrocket:
self.playerrocket.kill_light()
#~ print "BOOM!, PLAYER ROCKET EXPLODED"
BoomSound.play()
RocketFire.stop()
Explosion.Explosion(self.playerrocket.rocket.getPos(), render)
self.playerrocket = None
np.getParent().remove()
else:
if self.enemyrocket:
self.enemyrocket.kill_light()
#~ print "BOOM!, ENEMY ROCKET EXPLODED"
BoomSound.play()
RocketFire.stop()
Explosion.Explosion(self.enemyrocket.rocket.getPos(), render)
self.enemyrocket = None
np.getParent().remove()
self.cRocketHandler.clearEntries()
return Task.cont
def shootPlayerRocket(self):
"""Shoot a player rocket"""
#Check to see if we can access the mouse. We need it to do anything else
if base.mouseWatcherNode.hasMouse():
#get the mouse position
mpos = base.mouseWatcherNode.getMouse()
#Set the position of the ray based on the mouse position
self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
#Do the actual collision pass
pickerpoint=Point3(0,0,0)
self.picker.traverse(render)
for i in range(self.pq.getNumEntries()):
entry = self.pq.getEntry(i)
if entry.getFromNode().getName() == "mouseRay" and entry.getIntoNode().getName()=="terrain":
pickerpoint=entry.getSurfacePoint(render)
direction=pickerpoint-Point3(self.player.getX(), self.player.getY(), self.player.getZ()+0.5)
#~ if self.playerrocket is None:
#~ angle = math.radians(self.player.getH())
playerpos=self.player.getPos()
self.playerrocket = Rocket.Rocket(Point3(playerpos.getX(), playerpos.getY(), playerpos.getZ()+0.5), direction, "PlayerRocket", render)
self.playerrocket.setupCollision(self.cTrav, self.cRocketHandler)
RocketFire.play()
if self.player.getCurrentAnim()=="drive":
self.player.play("drivefire")
else:
self.player.play("fire")
def shootEnemyRocket(self):
"""Shoot a enemy rocket"""
if not (self.enemyrocket) and self.enemyrockettiming <= globalClock.getFrameTime() :
#~ angle = math.radians(self.enemy.getH())
#~ self.enemyrocket = Rocket.Rocket(self.enemy.getPos(), angle, "EnemyRocket", render)
#~ self.enemyrocket.setupCollision(self.cTrav, self.cRocketHandler)
direction = self.player.getPos() - self.enemy.getPos()
enemyPos = self.enemy.getPos()
self.enemyrocket = Rocket.Rocket(enemyPos + Point3(0,0,.5),direction,"EnemyRocket",render)
self.enemyrocket.setupCollision(self.cTrav, self.cRocketHandler)
RocketFire.play()
self.enemy.play("drivefire")
self.enemyrockettiming = globalClock.getFrameTime() + 2.0
#Records the state of the arrow keys
def setKey(self, key, value):
self.keyMap[key] = value
def shoot(self, task):
elapsed = task.time - self.prevShotTime
if(self.keyMap["shoot"]!=0 and elapsed > 1):
self.shootPlayerRocket()
self.prevShotTime = task.time
return Task.cont
def playerLights(self):
if self.playerlightson:
self.playerleftlight.node().setColor(Vec4(0,0,0,1))
self.playerrightlight.node().setColor(Vec4(0,0,0,1))
self.playerlightson=0
else:
self.playerleftlight.node().setColor(Vec4(0.75,0.75,0.75,1))
self.playerrightlight.node().setColor(Vec4(0.75,0.75,0.75,1))
self.playerlightson=1
def enemyLights(self):
if self.enemylightson:
self.enemyleftlight.node().setColor(Vec4(0,0,0,1))
self.enemyrightlight.node().setColor(Vec4(0,0,0,1))
self.enemylightson=0
else:
self.enemyleftlight.node().setColor(Vec4(0.75,0.75,0.75,1))
self.enemyrightlight.node().setColor(Vec4(0.75,0.75,0.75,1))
self.enemylightson=1
def enemyMove(self, task):
elapsed = task.time - self.prevEnemyMoveTime
startpos = self.enemy.getPos()
#Calculate distance to the enemy
distvec = self.player.getPos() - self.enemy.getPos()
distvec.setZ(0)
dist = distvec.length()
backward = self.enemy.getNetTransform().getMat().getRow3(1)
backward.setZ(0)
backward.normalize()
#Drive!
if self.enemy.getCurrentAnim() is None:
self.enemy.loop("drive")
#Find the vector from the enemy to the player, then find the angle of that vector
vec = self.enemy.getPos() - self.player.getPos()
angle = math.degrees(math.atan2(vec.getX(), vec.getY()))
#Find the angle left to turn according to the enemy's current angle
angleToPlayer = (-self.enemy.getH() - angle) % 360
#Fire rocket if within 60 degree arc of player
#~ print angleToPlayer
if angleToPlayer < 30 or angleToPlayer > 330:
self.shootEnemyRocket()
#AI control code starts here
#enemyTurn is zero for heading straight, -1 to turn full left, +1 to turn full right
#Turning rate is currently maxed at 100 degrees per second
#drivedir is for forward (1) or backward (-1)
#Wall avoidance stuff
enemyTurn=0
myh=self.player.getH()%360
print myh
if abs(self.enemy.getPos().getX())>19 or abs(self.enemy.getPos().getX())>19:
drivedir=-1.0
else:
drivedir=1.0
if self.playerrocket:
playerpos=self.player.getPos()
if playerpos.getX()>12.5 and (myh<90 or myh>270):
self.enemyTurn = -(0.5+0.05*(self.enemy.getX()-12.5))*sign(myh-180)
print 1
elif playerpos.getX()<12.5 and not (myh<90 or myh>270):
self.enemyTurn = -(0.5+0.05*(12.5-self.enemy.getX()))*sign(myh-180)
print 2
elif playerpos.getY()>12.5 and myh<180:
self.enemyTurn = -(0.5+0.05*(self.enemy.getY()-12.5))*sign(myh-90)
print 3
elif playerpos.getY()<12.5 and myh>180:
self.enemyTurn = -(0.5+0.05*(12.5-self.enemy.getY()))*sign(myh-270)
print 4
elif self.enemy.getPos().getX()>12.5 and (myh<90 or myh>270):
self.enemyTurn = -(0.5+0.05*(self.enemy.getX()-12.5))*sign(myh-180)
print 5
elif self.enemy.getPos().getX()<-12.5 and not (myh<90 or myh>270):
self.enemyTurn = -(0.5+0.05*(12.5-self.enemy.getX()))*sign(myh-180)
print 6
elif self.enemy.getPos().getY()>12.5 and myh<180:
self.enemyTurn = -(0.5+0.05*(self.enemy.getY()-12.5))*sign(myh-90)
print 7
elif self.enemy.getPos().getY()<-12.5 and myh>180:
self.enemyTurn = -(0.5+0.05*(12.5-self.enemy.getY()))*sign(myh-270)
print 8
elif not(math.fabs(self.enemyDestAng - angleToPlayer) > 3 and math.fabs(self.enemyDestAng - angleToPlayer) < 357):
print 9
self.enemyTurn = 0
else:
print 10
if dist > 5:
self.enemyDestAng = 0
if angleToPlayer > 1 and angleToPlayer <= 180:
#Turn left
self.enemyTurn = -0.5
elif angleToPlayer > 180 and angleToPlayer < 359:
#Turn right
self.enemyTurn = 0.5
elif dist < 5:
self.enemyDestAng = 180
if angleToPlayer >= 0 and angleToPlayer < 179:
#Turn left
self.enemyTurn = 0.5
elif angleToPlayer > 181 and angleToPlayer < 360:
#Turn right
self.enemyTurn = -0.5
#Replace later
#drivedir=1.0
#End of AI code
#Enemy always tries to move forward, regardless of where the player is
self.enemy.setPos(self.enemy.getPos() - backward*(drivedir*elapsed*5))
self.enemy.setH(self.enemy.getH() - elapsed *100.0*self.enemyTurn)
EnemyRunning.play()
self.cTrav.traverse(render)
entries = []
terrain = []
for i in range(self.enemyGroundHandler.getNumEntries()):
entry = self.enemyGroundHandler.getEntry(i)
if entry.getFromNode().getName() == "enemyRay":
terrain.append(entry)
elif entry.getFromNode().getName() == "Enemy" and entry.getIntoNode().getName() != "terrain":
entries.append(entry)
terrain.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(),
x.getSurfacePoint(render).getZ()))
if (len(entries)>0):
self.enemy.setPos(startpos)
if (len(terrain)>0) and (terrain[0].getIntoNode().getName() == "terrain"):
self.enemy.setZ(terrain[0].getSurfacePoint(render).getZ()+.5)
else:
self.enemy.setPos(startpos)
# Store the task time and continue.
self.prevEnemyMoveTime = task.time
return Task.cont
# Accepts arrow keys to move either the player or the menu cursor,
# Also deals with grid checking and collision detection
def playerMove(self, task):
elapsed = task.time - self.prevtime
base.camera.lookAt(self.player)
camright = base.camera.getNetTransform().getMat().getRow3(0)
camright.normalize()
# save player's initial position so that we can restore it,
# in case he falls off the map or runs into something.
startpos = self.player.getPos()
# If a move-key is pressed, move player in the specified direction.
if ((self.keyMap["left"]!=0) & (self.keyMap["forward"]!=0)):
self.player.setH(self.player.getH() + elapsed*50)
Idling.stop()
Running.play()
self.playermoving = True
elif((self.keyMap["left"]!=0) & (self.keyMap["backward"]!=0)):
self.player.setH(self.player.getH() - elapsed*50)
Idling.stop()
Running.play()
self.playermoving = True
if ((self.keyMap["right"]!=0) & (self.keyMap["forward"]!=0)):
self.player.setH(self.player.getH() - elapsed*50)
Idling.stop()
Running.play()
self.playermoving = True
elif ((self.keyMap["right"]!=0) & (self.keyMap["backward"]!=0)):
self.player.setH(self.player.getH() + elapsed*50)
Idling.stop()
Running.play()
self.playermoving = True
if (self.keyMap["forward"]!=0):
backward = self.player.getNetTransform().getMat().getRow3(1)
backward.setZ(0)
backward.normalize()
self.player.setPos(self.player.getPos() - backward*(elapsed*5))
Running.play()
Idling.stop()
self.playermoving = True
if (self.keyMap["backward"]!=0):
backward = self.player.getNetTransform().getMat().getRow3(1)
backward.setZ(0)
backward.normalize()
self.player.setPos(self.player.getPos() + backward*(elapsed*5))
Idling.stop()
Running.play()
self.playermoving = True
if (self.keyMap["backward"]==0 and self.keyMap["forward"]==0 and self.keyMap["left"]==0 and self.keyMap["right"]==0):
Running.stop()
Idling.play()
self.playermoving = False
if self.player.getCurrentAnim()=="drive":
self.player.stop()
#print "STOP MOVING"
#DRIVE!
if self.player.getCurrentAnim() is None and self.playermoving:
self.player.loop("drive")
#print "DRIVE ON!"
dist = 10.0
angle = math.radians(self.player.getH()) + math.pi
dx = dist * math.sin(angle)
dy = dist * -math.cos(angle)
dest = Point3(self.player.getX() + dx, self.player.getY() + dy, self.player.getZ()+1)
base.camera.setPos(dest)
# If player is moving, loop the run animation.
# If he is standing still, stop the animation.
if (self.keyMap["forward"]!=0) or (self.keyMap["left"]!=0) or (self.keyMap["right"]!=0):
if self.isMoving is False:
#self.player.loop("run")
self.isMoving = True
else:
if self.isMoving:
#self.player.stop()
#self.player.pose("walk",5)
self.isMoving = False
# If the camera is too far from player, move it closer.
# If the camera is too close to player, move it farther.
camvec = self.player.getPos() - base.camera.getPos()
camvec.setZ(0)
camdist = camvec.length()
camvec.normalize()
if (camdist > 20.0):
base.camera.setPos(base.camera.getPos() + camvec*(camdist-20))
camdist = 20.0
if (camdist < 10.0):
base.camera.setPos(base.camera.getPos() - camvec*(10-camdist))
camdist = 10.0
# Now check for collisions.
self.cTrav.traverse(render)
# Adjust player's Z coordinate. If player's ray hit terrain,
# update his Z. If it hit anything else, or didn't hit anything, put
# him back where he was last frame.
terrain = []
entries = []
for i in range(self.playerGroundHandler.getNumEntries()):
entry = self.playerGroundHandler.getEntry(i)
if entry.getFromNode().getName() == "playerRay":
terrain.append(entry)
elif entry.getFromNode().getName() == "Player" and entry.getIntoNode().getName() != "terrain":
entries.append(entry)
terrain.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(),
x.getSurfacePoint(render).getZ()))
if (len(entries)>0):
self.player.setPos(startpos)
elif (len(terrain)>0) and (terrain[0].getIntoNode().getName() == "terrain"):
self.player.setZ(terrain[0].getSurfacePoint(render).getZ()+.5)
else:
self.player.setPos(startpos)
# Keep the camera at one foot above the terrain,
# or two feet above player, whichever is greater.
entries = []
for i in range(self.camGroundHandler.getNumEntries()):
entry = self.camGroundHandler.getEntry(i)
entries.append(entry)
entries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(),
x.getSurfacePoint(render).getZ()))
if (len(entries)>0) and (entries[0].getIntoNode().getName() == "terrain"):
base.camera.setZ(entries[0].getSurfacePoint(render).getZ()+ 1.5)
if (base.camera.getZ() < self.player.getZ() + 2.5):
base.camera.setZ(self.player.getZ() + 2.5)
# The camera should look in player's direction,
# but it should also try to stay horizontal, so look at
# a floater which hovers above player's head.
self.floater.setPos(self.player.getPos())
self.floater.setZ(self.floater.getZ()+1)
base.camera.lookAt(self.floater)
# Store the task time and continue.
self.prevtime = task.time
return Task.cont
class MousePicker( p3d.SingleTask ):
"""
Class to represent a ray fired from the input camera lens using the mouse.
"""
def __init__( self, *args, **kwargs ):
p3d.SingleTask.__init__( self, *args, **kwargs )
self.fromCollideMask = kwargs.pop( 'fromCollideMask', None )
self.node = None
self.collEntry = None
# Create collision nodes
self.collTrav = CollisionTraverser()
#self.collTrav.showCollisions( render )
self.collHandler = CollisionHandlerQueue()
self.pickerRay = CollisionRay()
# Create collision ray
pickerNode = CollisionNode( self.name )
pickerNode.addSolid( self.pickerRay )
pickerNode.setIntoCollideMask( BitMask32.allOff() )
pickerNp = self.camera.attachNewNode( pickerNode )
self.collTrav.addCollider( pickerNp, self.collHandler )
# Create collision mask for the ray if one is specified
if self.fromCollideMask is not None:
pickerNode.setFromCollideMask( self.fromCollideMask )
# Bind mouse button events
eventNames = ['mouse1', 'control-mouse1', 'mouse1-up']
for eventName in eventNames:
self.accept( eventName, self.FireEvent, [eventName] )
def OnUpdate( self, task ):
# Update the ray's position
if self.mouseWatcherNode.hasMouse():
mp = self.mouseWatcherNode.getMouse()
self.pickerRay.setFromLens( self.camera.node(), mp.getX(), mp.getY() )
# Traverse the hierarchy and find collisions
self.collTrav.traverse( self.rootNp )
if self.collHandler.getNumEntries():
# If we have hit something, sort the hits so that the closest is first
self.collHandler.sortEntries()
collEntry = self.collHandler.getEntry( 0 )
node = collEntry.getIntoNode()
# If this node is different to the last node, send a mouse leave
# event to the last node, and a mouse enter to the new node
if node != self.node:
if self.node is not None:
messenger.send( '%s-mouse-leave' % self.node.getName(), [self.collEntry] )
messenger.send( '%s-mouse-enter' % node.getName(), [collEntry] )
# Send a message containing the node name and the event over name,
# including the collision entry as arguments
messenger.send( '%s-mouse-over' % node.getName(), [collEntry] )
# Keep these values
self.collEntry = collEntry
self.node = node
elif self.node is not None:
# No collisions, clear the node and send a mouse leave to the last
# node that stored
messenger.send( '%s-mouse-leave' % self.node.getName(), [self.collEntry] )
self.node = None
def FireEvent( self, event ):
"""
Send a message containing the node name and the event name, including
the collision entry as arguments.
"""
if self.node is not None:
messenger.send( '%s-%s' % ( self.node.getName(), event ), [self.collEntry] )
def GetFirstNodePath( self ):
"""
Return the first node in the collision queue if there is one, None
otherwise.
"""
if self.collHandler.getNumEntries():
collEntry = self.collHandler.getEntry( 0 )
return collEntry.getIntoNodePath()
return None
class cWorld:
def __init__( self ):
# set background color
base.setBackgroundColor( 0, 0, 0 )
# create target
self.createTarget( )
# create boids
self.createBoids( )
# setup camera
self.setupCamera( )
# setup lights
self.setupLights( )
# setup collision detection
self.setupCollision( )
# add task
taskMgr.add( self.steer, 'steer' ) # steer task
taskMgr.add( self.moveTarget, 'moveTarget' ) # mouse move target task
def createBoids( self ):
self.redBoid = cBoid( ) # create red boid
# setup blue boid with model path, starting location, max force, and max speed
self.redBoid.setup( 'assets/models/boid_one.egg', Vec3( 0.0, 0.0, 0.0 ), 4.0, 0.1 )
# create blue boid
self.blueBoid = cBoid( )
# setup blue boid with model path, starting location, max force, and max speed
self.blueBoid.setup( 'assets/models/boid_two.egg', Vec3( 0.0, 0.0, 0.0 ), 4.0, 1.0 )
def createTarget( self ):
# load in model file
self.target = loader.loadModel( 'assets/models/target.egg' )
# parent
self.target.reparentTo( render )
# set location
self.target.setPos( Vec3( 0.0, 0.0, 0.0 ) )
def setupCamera( self ):
# disable auto controls
base.disableMouse()
# set position, heading, pitch, and roll
camera.setPosHpr( Vec3( 0.0, -45.0, 45.0), Vec3( 0.0, -45.0, 0 ) )
def setupLights( self ):
# create a point light
plight = PointLight( 'plight' )
# set its color
plight.setColor( VBase4( 1.0, 1.0, 1.0, 1 ) )
# attach the light to the render
plnp = render.attachNewNode( plight )
# set position
plnp.setPos( 0.0, 0.0, 2.0 )
# turn on light
render.setLight( plnp )
def setupCollision( self ):
# create collision traverser
self.picker = CollisionTraverser( )
# create collision handler
self.pq = CollisionHandlerQueue( )
# create collision node
self.pickerNode = CollisionNode( 'mouseRay' ) # create collision node
# attach new collision node to camera node
self.pickerNP = camera.attachNewNode( self.pickerNode ) # attach collision node to camera
# set bit mask to one
self.pickerNode.setFromCollideMask( BitMask32.bit( 1 ) ) # set bit mask
# create a collision ray
self.pickerRay = CollisionRay( ) # create collision ray
# add picker ray to the picker node
self.pickerNode.addSolid( self.pickerRay ) # add the collision ray to the collision node
# make the traverser know about the picker node and its even handler queue
self.picker.addCollider( self.pickerNP, self.pq ) # add the colision node path and collision handler queue
#self.picker.showCollisions( render ) # render or draw the collisions
#self.pickerNP.show( ) # render picker ray
# create col node
self.colPlane = CollisionNode( 'colPlane' )
# add solid to col node plane
self.colPlane.addSolid( CollisionPlane( Plane( Vec3( 0, 0, 1 ), Point3( 0, 0, 0 ) ) ) )
# attach new node to the render
self.colPlanePath = render.attachNewNode( self.colPlane )
#self.colPlanePath.show( ) # render node
# make the col plane look at the camera
# this makes it alway look at the camera no matter the orientation
# we need this because the ray nees to intersect a plane parallel
# to the camera
self.colPlanePath.lookAt( camera )
# prop up the col plane
self.colPlanePath.setP( -45 )
# set bit mask to one
# as I understand it, this makes all col nodes with bit mask one
# create collisions while ignoring others of other masks
self.colPlanePath.node( ).setIntoCollideMask( BitMask32.bit( 1 ) )
def steer( self, Task ):
# seek after target
self.redBoid.seek( Vec3( self.target.getPos( ) ) )
# run the algorithm
self.redBoid.run( )
# arrive at the target
self.blueBoid.arrive( Vec3( self.target.getPos( ) ) )
# run the algorithm
self.blueBoid.run( )
return Task.cont # continue task
def moveTarget( self, Task ):
# traverse through the render tree
self.picker.traverse( render )
# go through the queue of collisions
for i in range( self.pq.getNumEntries( ) ):
entry = self.pq.getEntry( i ) # get entry
surfacePoint = entry.getSurfacePoint( render ) # get surface point of collision
self.target.setPos( surfacePoint ) # set surface point to target's position
if base.mouseWatcherNode.hasMouse( ): # if we have a mouse
mpos = base.mouseWatcherNode.getMouse( ) # get the path to the mouse
# shoot ray from camera
# based on X & Y coordinate of mouse
self.pickerRay.setFromLens( base.camNode, mpos.getX( ), mpos.getY( ) )
return Task.cont # continue task
class Mouse(DirectObject):
def __init__(self, app):
# local variables for mouse class
self.app = app
self.init_collide()
self.has_mouse = None
self.prev_pos = None
self.pos = None
self.drag_start = None
self.hovered_object = None
self.button2 = False
self.mouseTask = taskMgr.add(self.mouse_task, 'mouseTask')
self.task = None
# set up event and response to this event
self.accept('mouse1', self.mouse1)
self.accept('mouse1-up', self.mouse1_up)
# change the mouse to accept 'right-click' to rotate camera
self.accept('mouse3', self.rotateCamera)
self.accept('mouse3-up', self.stopCamera)
self.accept('wheel_up', self.zoomIn)
self.accept('wheel_down', self.zoomOut)
# set up the collision for object
def init_collide(self):
# why the heck he import within method
from pandac.PandaModules import CollisionTraverser, CollisionNode
from pandac.PandaModules import CollisionHandlerQueue, CollisionRay
# init and import collision for object
self.cTrav = CollisionTraverser('MousePointer')
self.cQueue = CollisionHandlerQueue()
self.cNode = CollisionNode('MousePointer')
self.cNodePath = base.camera.attachNewNode(self.cNode)
self.cNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.cRay = CollisionRay()
self.cNode.addSolid(self.cRay)
self.cTrav.addCollider(self.cNodePath, self.cQueue)
# by the collision methods mouse is able to find out which tile mouse is at
def find_object(self):
if self.app.world.nodePath:
self.cRay.setFromLens(base.camNode, self.pos.getX(), self.pos.getY())
self.cTrav.traverse(self.app.world.terrain.nodePath)
if self.cQueue.getNumEntries() > 0:
self.cQueue.sortEntries()
return self.cQueue.getEntry(0).getIntoNodePath()
return None
# setting task for mouse
def mouse_task(self, task):
action = task.cont
# if the current tile has a mouse point to this
self.has_mouse = base.mouseWatcherNode.hasMouse()
if self.has_mouse:
self.pos = base.mouseWatcherNode.getMouse()
if self.prev_pos:
self.delta = self.pos - self.prev_pos
else:
self.delta = None
if self.task:
action = self.task(task)
else:
self.pos = None
if self.pos:
self.prev_pos = Point2(self.pos.getX(), self.pos.getY())
return action
# when mouse hover over this hexagon
def hover(self, task):
if self.hovered_object:
self.hovered_object.unhover()
self.hovered_object = None
if self.button2:
self.camera_drag()
hovered_nodePath = self.find_object()
if hovered_nodePath:
tile = hovered_nodePath.findNetTag('tile')
if not tile.isEmpty():
tag = tile.getTag('tile')
coords = tag.split(',')
(x, y) = [int(n) for n in coords]
# set the hovered target to be the corresponding hexagon on terrain
self.hovered_object = self.app.world.terrain.rows[x][y]
self.hovered_object.hover()
character = hovered_nodePath.findNetTag('char')
if not character.isEmpty():
tag = character.getTag('char')
(team_index, char_id) = [int(n) for n in tag.split(',')]
self.hovered_object = self.app.world.teams[team_index].characters_dict[char_id]
self.hovered_object.hover()
ghost = hovered_nodePath.findNetTag('ghost')
if not ghost.isEmpty():
tag = ghost.getTag('ghost')
(team_index, char_id) = [int(n) for n in tag.split(',')]
for ghostInstance in self.app.ghosts:
if (ghostInstance.team.index == team_index) and (ghostInstance.id == char_id):
self.hovered_object = ghostInstance
self.hovered_object.hover()
return task.cont
def mouse1(self):
self.app.state.request('mouse1')
def mouse1_up(self):
self.app.state.request('mouse1-up')
def camera_drag(self):
if self.delta:
old_heading = base.camera.getH()
new_heading = old_heading - self.delta.getX() * 180
base.camera.setH(new_heading % 360)
old_pitch = base.camera.getP()
new_pitch = old_pitch + self.delta.getY() * 90
new_pitch = max(-90, min(-10, new_pitch))
base.camera.setP(new_pitch)
def rotateCamera(self):
self.button2 = True
def stopCamera(self):
self.button2 = False
def zoomIn(self):
lens = base.cam.node().getLens()
size = lens.getFilmSize()
if size.length() >= 75:
lens.setFilmSize(size / 1.2)
def zoomOut(self):
lens = base.cam.node().getLens()
size = lens.getFilmSize()
if size.length() <= 250:
lens.setFilmSize(size * 1.2)
class cWorld:
def __init__(self):
# set background color
base.setBackgroundColor(0, 0, 0)
# create target
self.createTarget()
# create boids
self.createBoids()
# setup camera
self.setupCamera()
# setup lights
self.setupLights()
# setup collision detection
self.setupCollision()
# add task
taskMgr.add(self.steer, 'steer') # steer task
taskMgr.add(self.moveTarget, 'moveTarget') # mouse move target task
def createBoids(self):
self.redBoid = cBoid() # create red boid
# setup blue boid with model path, starting location, max force, and max speed
self.redBoid.setup('assets/models/boid_one.egg', Vec3(0.0, 0.0, 0.0),
4.0, 0.1)
# create blue boid
self.blueBoid = cBoid()
# setup blue boid with model path, starting location, max force, and max speed
self.blueBoid.setup('assets/models/boid_two.egg', Vec3(0.0, 0.0, 0.0),
4.0, 1.0)
def createTarget(self):
# load in model file
self.target = loader.loadModel('assets/models/target.egg')
# parent
self.target.reparentTo(render)
# set location
self.target.setPos(Vec3(0.0, 0.0, 0.0))
def setupCamera(self):
# disable auto controls
base.disableMouse()
# set position, heading, pitch, and roll
camera.setPosHpr(Vec3(0.0, -45.0, 45.0), Vec3(0.0, -45.0, 0))
def setupLights(self):
# create a point light
plight = PointLight('plight')
# set its color
plight.setColor(VBase4(1.0, 1.0, 1.0, 1))
# attach the light to the render
plnp = render.attachNewNode(plight)
# set position
plnp.setPos(0.0, 0.0, 2.0)
# turn on light
render.setLight(plnp)
def setupCollision(self):
# create collision traverser
self.picker = CollisionTraverser()
# create collision handler
self.pq = CollisionHandlerQueue()
# create collision node
self.pickerNode = CollisionNode('mouseRay') # create collision node
# attach new collision node to camera node
self.pickerNP = camera.attachNewNode(
self.pickerNode) # attach collision node to camera
# set bit mask to one
self.pickerNode.setFromCollideMask(BitMask32.bit(1)) # set bit mask
# create a collision ray
self.pickerRay = CollisionRay() # create collision ray
# add picker ray to the picker node
self.pickerNode.addSolid(
self.pickerRay) # add the collision ray to the collision node
# make the traverser know about the picker node and its even handler queue
self.picker.addCollider(
self.pickerNP,
self.pq) # add the colision node path and collision handler queue
#self.picker.showCollisions( render ) # render or draw the collisions
#self.pickerNP.show( ) # render picker ray
# create col node
self.colPlane = CollisionNode('colPlane')
# add solid to col node plane
self.colPlane.addSolid(
CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0))))
# attach new node to the render
self.colPlanePath = render.attachNewNode(self.colPlane)
#self.colPlanePath.show( ) # render node
# make the col plane look at the camera
# this makes it alway look at the camera no matter the orientation
# we need this because the ray nees to intersect a plane parallel
# to the camera
self.colPlanePath.lookAt(camera)
# prop up the col plane
self.colPlanePath.setP(-45)
# set bit mask to one
# as I understand it, this makes all col nodes with bit mask one
# create collisions while ignoring others of other masks
self.colPlanePath.node().setIntoCollideMask(BitMask32.bit(1))
def steer(self, Task):
# seek after target
self.redBoid.seek(Vec3(self.target.getPos()))
# run the algorithm
self.redBoid.run()
# arrive at the target
self.blueBoid.arrive(Vec3(self.target.getPos()))
# run the algorithm
self.blueBoid.run()
return Task.cont # continue task
def moveTarget(self, Task):
# traverse through the render tree
self.picker.traverse(render)
# go through the queue of collisions
for i in range(self.pq.getNumEntries()):
entry = self.pq.getEntry(i) # get entry
surfacePoint = entry.getSurfacePoint(
render) # get surface point of collision
self.target.setPos(
surfacePoint) # set surface point to target's position
if base.mouseWatcherNode.hasMouse(): # if we have a mouse
mpos = base.mouseWatcherNode.getMouse(
) # get the path to the mouse
# shoot ray from camera
# based on X & Y coordinate of mouse
self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
return Task.cont # continue task
class Input(DirectObject):
def __init__(self,model):
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
self.Text = OnscreenText(text="Set PanRate",pos=(-1.25,-0.15),scale=0.1)
self.slider = DirectSlider(range=(20,100), value=50, pageSize=2, pos=(-1.25,0,-0.2),scale= (0.2,0.2,0.2), command=self.setScrollSpeed)
def Attack(self,pos):
self.atk.setWeil(self.model)
self.atk.setTarg(self.dumm)
self.atk.setDist(self.mini)
if self.mini<=60:
self.Animate=self.atk.ATT()
else:
messenger.send('mouse3')
if self.mini<=60:
self.atk.ATT()
def setScrollSpeed(self):
SCROLLSPEED=self.slider['value']
def MousePos(self, task): #This Took me 1.5 Months to Learn
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)):
pass
return task.again
def MoveHero(self):
self.startR=self.model.getHpr()
self.target=self.pos3d
x2,y2,z2=self.target.getX(),self.target.getY(),self.target.getZ()
h1,p1,r1=self.model.getH(),self.model.getP(),self.model.getR()
self.dist=sqrt(pow(self.x1-x2,2)+pow(self.y1-y2,2))
self.sptime=self.dist/(30)
self.hall=270-degrees(y2/x2)
# self.model.setPos(self.model,self.spd,0,self.spd)
Inter=LerpPosHprInterval(self.model,self.sptime,pos=self.target ,startPos=self.model.getPos(),startHpr=self.startR,hpr=self.startR)#(h1,p1,self.hall))
#Inter2=Func(self.model.lookAt(self.target),Wait(0.3))
self.heroPace = Sequence(Inter,name="heroPace")
self.heroPace.start()
def Move(self,task):
self.x1,self.y1=self.model.getX(),self.model.getY()
self.x2,self.y2=self.dumm.getX(),self.dumm.getY()
self.mini=sqrt(pow(self.x1-self.x2,2)+pow(self.y1-self.y2,2))
Debug2(self,str(self.mini))
elapsed = globalClock.getDt()
self.dt=elapsed
self.setAnim()
if (self.keyMap["left"]!=0):
self.model.setH(self.model.getH() + self.dt*300)
if (self.keyMap["right"]!=0):
self.model.setH(self.model.getH() - self.dt*300)
if (self.keyMap["forward"]!=0):
self.model.setX(self.model, +(self.dt*25*SPEED))
# base.camera.lookAt(self.model)
self.floater.setPos(self.model.getPos())
# base.camera.lookAt(self.floater)
return task.cont
def Setup(self):
self.accept("arrow_left", self.setKey1, ["left",1,True])
self.accept("arrow_right", self.setKey1, ["right",1,True])
self.accept("arrow_up", self.setKey1, ["forward",1,True])
self.accept("arrow_left-up", self.setKey1, ["left",0,False])
self.accept("arrow_right-up", self.setKey1, ["right",0,False])
self.accept("arrow_up-up", self.setKey1, ["forward",0,False])
self.accept("mouse1",self.ObjectClick)
self.accept("mouse3",self.MoveHero)
def setKey1(self, key, value,value2):
self.keyMap[key] = value
self.Change=value2
def setAnim(self):
if self.Change: #(self.keyMap["forward"]!=0) or (self.keyMap["left"]!=0) or (self.keyMap["right"]!=0):
if self.isMoving is False:
self.model.loop("run")
self.isMoving = True
else:
if self.isMoving:
self.model.stop()
self.model.pose("walk",5)
self.isMoving = False
if self.Animate:
pass
#set the attack anim here
def Coll(self):
base.cTrav = CollisionTraverser()
self.collHandler = CollisionHandlerQueue()
self.pickerNode = CollisionNode('mouseRay')
self.pickerNP = camera.attachNewNode(self.pickerNode)
self.pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
base.cTrav.addCollider(self.pickerNP, self.collHandler)
def ObjectClick(self):
mpos = base.mouseWatcherNode.getMouse()
self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
base.cTrav.traverse(render) # Assume for simplicity's sake that myHandler is a CollisionHandlerQueue.
if self.collHandler.getNumEntries() > 0: # This is so we get the closest object.
self.collHandler.sortEntries()
self.pickedObj = self.collHandler.getEntry(0).getIntoNodePath()
self.pickedObj = self.pickedObj.findNetTag('Unit')
if not self.pickedObj.isEmpty():
self.Attack(self.pickedObj.getPos())
class Mode(object):
"""This is the base Mode class"""
def __init__(self, game):
self.name = "MODE"
self.guiMediaPath = '../Packages/anw/gui/media/'
self.alive = 1
self.enableMouseCamControl = 1
self.enableScrollWheelZoom = 1
self.canSelectFlags = {}
self.messagePositions = []
self.selectTypes = []
self.gui = []
self.sims = []
self.game = game
self.depth = 20.0
self.zoomCameraDepth = 10.0
self.zoomCameraOutDepth = -10.0
self.zoomSpeed = 5
self.panSpeed = 1.0
self.runningTasks = []
if globals.serverMode == 0:
self.setMyBackground()
camera.setHpr(0,0,0)
self.mainmenu = None
self.scrollSpeed = 0.1
if globals.serverMode == 0:
self.setMousePicker()
self.setCameraPosition()
self.selector = None
self.selector2 = None
self.log = logging.getLogger('mode')
self.entryFocusList = ('anw.gui.mainmenubuttons','anw.gui.industryvalue',
'anw.gui.cityindustry','anw.gui.weapondirection',
'anw.gui.scrollvalue','anw.gui.shipdesignvalue',
'anw.gui.systemmenu','anw.gui.tradevalue',
'anw.gui.designmenu','anw.gui.shipyardmenu', 'anw.gui.mimenu',
'anw.gui.textentry', 'anw.gui.marketsystemsellvalue',
'anw.gui.sendcreditsvalue')
def __getstate__(self):
odict = self.__dict__.copy() # copy the dict since we change it
del odict['log'] # remove stuff not to be pickled
return odict
def __setstate__(self,dict):
log=logging.getLogger('mode')
self.__dict__.update(dict)
self.log=log
def setMousePicker(self):
self.picker = CollisionTraverser()
self.pq = CollisionHandlerQueue()
self.pickerNode = CollisionNode('mouseRay')
self.pickerNP = camera.attachNewNode(self.pickerNode)
self.pickerNode.setFromCollideMask(BitMask32.bit(1))
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
self.picker.addCollider(self.pickerNP, self.pq)
self.selectable = render.attachNewNode("selectable")
def setCameraPosition(self):
self.cameraPos = (camera.getX(), camera.getY(), camera.getZ())
self.cameraMoving = 0
def setCanSelectFlag(self, key):
"""Set the Flag"""
self.clearAllCanSelectFlags()
self.canSelectFlags[key] = 1
def clearAllCanSelectFlags(self):
"""Clear any selection flags"""
for key in self.canSelectFlags.keys():
self.canSelectFlags[key] = 0
def isAnyFlagSelected(self):
"""Return 1 if any flags are selected"""
for key in self.canSelectFlags.keys():
if self.canSelectFlags[key] == 1:
return 1
return 0
def validateSelection(self):
"""Can something be selected right now"""
if self.cameraMoving == 0:
return 1
else:
return 0
def removeMyGui(self, myGuiName):
"""Remove gui"""
myGui = getattr(self, myGuiName)
if myGui in self.gui:
self.gui.remove(myGui)
if myGui != None:
myGui.destroy()
setattr(self, myGuiName, None)
def createMainMenu(self, key):
self.mainmenu = mainmenubuttons.MainMenuButtons(self.guiMediaPath)
self.mainmenu.setMyGame(self.game)
self.mainmenu.setMyMode(self)
self.mainmenu.enableLastButton(key)
self.mainmenu.checkDisableButton(key)
self.mainmenu.writeGameInfo()
self.mainmenu.acceptSpaceBarKey()
self.gui.append(self.mainmenu)
def removeMainMenu(self):
if self.mainmenu != None:
self.mainmenu.destroyMe()
self.mainmenu = None
def centerCameraOnSim(self, sim):
"""Center the camera on the sim position"""
self.game.app.disableMouseCamControl()
camera.setPos(sim.getX(), camera.getY(), sim.getZ())
camera.setHpr(0,0,0)
if self.enableMouseCamControl == 1:
self.game.app.enableMouseCamControl()
def drawBox(self, x, y, width, height, color='guiblue1', lineWidth=0.15, glow=1):
"""Draw a box"""
#LEFT
myLine = line.Line(self.guiMediaPath,(x,y),(x,y+height), 'square_grey', lineWidth, glow)
myLine.sim.setColor(globals.colors[color])
self.gui.append(myLine)
#TOP
myLine = line.Line(self.guiMediaPath,(x,y+height),(x+width,y+height), 'square_grey', lineWidth, glow)
myLine.sim.setColor(globals.colors[color])
self.gui.append(myLine)
#RIGHT
myLine = line.Line(self.guiMediaPath,(x+width,y+height),(x+width,y), 'square_grey', lineWidth, glow)
myLine.sim.setColor(globals.colors[color])
self.gui.append(myLine)
#BOTTOM
myLine = line.Line(self.guiMediaPath,(x+width,y),(x,y), 'square_grey', lineWidth, glow)
myLine.sim.setColor(globals.colors[color])
self.gui.append(myLine)
def stopCameraTasks(self):
taskMgr.remove('zoomInCameraTask')
taskMgr.remove('zoomOutCameraTask')
self.cameraMoving = 0
self.game.app.enableMouseCamControl()
self.enableMouseCamControl=1
def resetCamera(self):
self.game.app.disableMouseCamControl()
camera.setPos(self.cameraPos[0], self.zoomCameraOutDepth, self.cameraPos[2])
# I don't really understand why this doesn't reset the view when having a planet selected and hitting spacebar?
camera.setHpr(0,0,0)
if self.enableMouseCamControl == 1:
self.game.app.enableMouseCamControl()
def zoomInCamera(self):
if camera.getY() <= self.zoomCameraDepth:
self.game.app.disableMouseCamControl()
taskMgr.add(self.zoomInCameraTask, 'zoomInCameraTask', extraArgs=[self.zoomCameraDepth])
self.runningTasks.append('zoomInCameraTask')
def zoomInCameraAmount(self, amount):
"""Zoom in Camera a certain amount specified"""
depth = camera.getY()+amount
self.game.app.disableMouseCamControl()
taskMgr.add(self.zoomInCameraTask, 'zoomInCameraTask', extraArgs=[depth])
self.runningTasks.append('zoomInCameraTask')
def zoomInCameraTask(self, depth):
"""Zoom in the camera until its at depth"""
y = camera.getY()
if y + 0.1 >= depth: # or y >= 8.0: # TODO: tacking this on will mess with the design screen but prevents you from zooming in too close everywhere else.
self.cameraMoving = 0
if self.enableMouseCamControl == 1:
self.game.app.enableMouseCamControl()
camera.setY(y)
return Task.done
else:
camera.setY(y+self.getZoomSpeed(y, depth))
self.cameraMoving = 1
return Task.cont
def getZoomSpeed(self, y, depth):
"""Make Camera zoom in faster if camera is further away"""
diff = depth-y
return diff/5.0
def zoomOutCamera(self):
if camera.getY() >= self.zoomCameraOutDepth:
self.game.app.disableMouseCamControl()
taskMgr.add(self.zoomOutCameraTask, 'zoomOutCameraTask', extraArgs=[self.zoomCameraOutDepth])
self.runningTasks.append('zoomOutCameraTask')
def zoomOutCameraAmount(self, amount):
"""Zoom out Camera a certain amount sepecified"""
depth = camera.getY()-amount
self.game.app.disableMouseCamControl()
taskMgr.add(self.zoomOutCameraTask, 'zoomOutCameraTask', extraArgs=[depth])
self.runningTasks.append('zoomOutCameraTask')
def zoomOutCameraTask(self, depth):
"""Zoom out the camera until its at 0 Depth"""
y = camera.getY()
if y - 0.1 <= depth:
self.cameraMoving = 0
if self.enableMouseCamControl == 1:
self.game.app.enableMouseCamControl()
camera.setY(y)
return Task.done
else:
camera.setY(y+self.getZoomSpeed(y, depth))
self.cameraMoving = 1
return Task.cont
def panCameraLeft(self, amount):
"""Pan Camera"""
pos = camera.getX()-amount
self.game.app.disableMouseCamControl()
taskMgr.add(self.panCameraLeftTask, 'panCameraLeftTask', extraArgs=[pos])
self.runningTasks.append('panCameraLeftTask')
def panCameraLeftTask(self, pos):
"""pan the camera to new position"""
x = camera.getX()
if x <= pos:
self.cameraMoving = 0
if self.enableMouseCamControl == 1:
self.game.app.enableMouseCamControl()
return Task.done
else:
camera.setX(x-self.panSpeed)
self.cameraMoving = 1
return Task.cont
def panCameraRight(self, amount):
"""Pan Camera"""
pos = camera.getX()+amount
self.game.app.disableMouseCamControl()
taskMgr.add(self.panCameraRightTask, 'panCameraRightTask', extraArgs=[pos])
self.runningTasks.append('panCameraRightTask')
def panCameraRightTask(self, pos):
"""pan the camera to new position"""
x = camera.getX()
if x >= pos:
self.cameraMoving = 0
if self.enableMouseCamControl == 1:
self.game.app.enableMouseCamControl()
return Task.done
else:
camera.setX(x+self.panSpeed)
self.cameraMoving = 1
return Task.cont
def panCameraUp(self, amount):
"""Pan Camera"""
pos = camera.getZ()+amount
self.game.app.disableMouseCamControl()
taskMgr.add(self.panCameraUpTask, 'panCameraUpTask', extraArgs=[pos])
self.runningTasks.append('panCameraUpTask')
def panCameraUpTask(self, pos):
"""pan the camera to new position"""
z = camera.getZ()
if z >= pos:
self.cameraMoving = 0
if self.enableMouseCamControl == 1:
self.game.app.enableMouseCamControl()
return Task.done
else:
camera.setZ(z+self.panSpeed)
self.cameraMoving = 1
return Task.cont
def panCameraDown(self, amount):
"""Pan Camera"""
pos = camera.getZ()-amount
self.game.app.disableMouseCamControl()
taskMgr.add(self.panCameraDownTask, 'panCameraDownTask', extraArgs=[pos])
self.runningTasks.append('panCameraDownTask')
def panCameraDownTask(self, pos):
"""pan the camera to new position"""
z = camera.getZ()
if z <= pos:
self.cameraMoving = 0
if self.enableMouseCamControl == 1:
self.game.app.enableMouseCamControl()
return Task.done
else:
camera.setZ(z-self.panSpeed)
self.cameraMoving = 1
return Task.cont
def createSelector(self,type='select',speed=2.0):
"""Create selector for indication of selected objects"""
self.selector = self.loadObject(type, scale=2, parent=render, transparency=True, pos=Point2(0,0), glow=1)
self.selector.hide()
ival = self.selector.hprInterval((speed), Vec3(0, 0, 360))
ival.loop()
def createSelector2(self,type='select',speed=2.0):
"""Create selector2 for indication of secondary selected objects"""
self.selector2 = self.loadObject(type, scale=2, parent=render, transparency=True, pos=Point2(0,0), glow=1)
self.selector2.hide()
ival = self.selector2.hprInterval((speed), Vec3(0, 0, 360))
ival.loop()
def playSound(self, soundName):
"""Play a Sound based on soundName given, call app"""
if globals.serverMode == 0:
self.game.app.playSound(soundName)
def askForHelp(self):
"""Ask the Server to analyse Player and provide help"""
try:
serverResult = self.game.server.askForHelp(self.game.authKey)
if type(serverResult) == types.ListType:
(message, self.game.myEmpire['help']) = serverResult
self.modeMsgBox(message)
else:
self.modeMsgBox(serverResult)
except:
self.modeMsgBox('askForHelp->Connection to Server Lost')
def assignSelector(self, myObj, scale):
"""create the Selector and assign to myObj at scale"""
if self.selector == None:
self.createSelector()
self.selector.show()
self.selector.setPos(myObj.getX(), myObj.getY(), myObj.getZ())
self.selector.setScale(scale)
def assignSelector2(self, myObj, scale):
"""create the Selector2 and assign to myObj at scale"""
if self.selector2 == None:
self.createSelector2()
self.selector2.show()
self.selector2.setPos(myObj.getX(), myObj.getY(), myObj.getZ())
self.selector2.setScale(scale)
##def checkEndTurn(self):
##"""Do a Server Assesment of turn before ending the turn"""
##try:
##if 'EndTurn' in self.game.myEmpire['help']:
### turn not ended yet
##(serverResult, self.game.myEmpire['help']) = self.game.server.askForHelp(self.game.authKey)
##if serverResult == 'Server Assessment: WARNINGS:0, CRITICAL:0 (Check Mail for Assesment)':
### server assessment is good, end the turn without asking
##self.endMyTurn()
##else:
### server assessment has not come back without warnings ask for confirmation
##self.modeYesNoBox('%s - Do you still want to end your turn?' % serverResult, 'endturnYes', 'yesNoBoxNo')
##else:
### turn already ended, unend turn
##self.modeYesNoBox('Do you want to cancel your end turn?' , 'endturnYes', 'yesNoBoxNo')
##except:
##self.modeMsgBox('checkEndTurn->Connection to Server Lost, Login Again')
def exitGame(self, doLogout=True):
"""Exit the game"""
self.setEmpireDefaults(self.game.authKey)
if doLogout:
self.setLogout(self.game.authKey)
self.alive = 0
self.game.app.quit()
def getCreditInfoFromServer(self):
self.getEmpireUpdate(['CR'])
def refreshCredit(self):
"""Ask the Server for an updated Credit Info"""
self.mainmenu.updateCR()
def getEmpireUpdate(self, listAttr):
"""Ask the Server for updated Empire info"""
try:
serverResult = self.game.server.getEmpireUpdate(self.game.authKey, listAttr)
if type(serverResult) == types.StringType:
self.modeMsgBox(serverResult)
else:
for key, value in serverResult.iteritems():
self.game.myEmpire[key] = value
except:
self.modeMsgBox('getEmpireUpdate->Connection to Server Lost')
def getMailUpdate(self):
"""Ask the Server for any updated mail"""
try:
myMailDict = self.game.myEmpire['mailBox']
serverResult = self.game.server.getMailUpdate(self.game.authKey, myMailDict.keys())
if type(serverResult) == types.StringType:
self.modeMsgBox(serverResult)
else:
for key, value in serverResult.iteritems():
myMailDict[key] = value
except:
self.modeMsgBox('getMailUpdate->Connection to Server Lost')
def getGalaxyUpdate(self, listAttr):
"""Ask the Server for updated Galaxy info"""
try:
serverResult = self.game.server.getGalaxyUpdate(listAttr, self.game.authKey)
if type(serverResult) == types.StringType:
self.modeMsgBox(serverResult)
else:
for key, value in serverResult.iteritems():
self.game.myGalaxy[key] = value
except:
self.modeMsgBox('getGalaxyUpdate->Connection to Server Lost')
def getSystemUpdate(self, listAttr, systemID):
"""Ask the Server for updated System info"""
try:
serverResult = self.game.server.getSystemUpdate(listAttr, systemID, self.game.authKey)
if type(serverResult) == types.StringType:
self.modeMsgBox(serverResult)
else:
mySystemDict = self.game.allSystems[systemID]
for key, value in serverResult.iteritems():
mySystemDict[key] = value
except:
self.modeMsgBox('getSystemUpdate->Connection to Server Lost')
def enterMode(self):
"""Enter the mode."""
self.alive = 1
self.setShortcuts()
def setShortcuts(self):
"""Set the default mode shortcuts"""
self.game.app.accept('mouse1', self.onMouse1Down)
self.game.app.accept('mouse3', self.onMouse2Down)
self.game.app.accept('space', self.onSpaceBarClear)
if self.enableMouseCamControl == 1:
self.game.app.accept('wheel_up', self.onMouseWheelUp)
self.game.app.accept('wheel_down', self.onMouseWheelDown)
def exitMode(self):
"""Exit the mode"""
self.removeMySims()
self.removeAllGui()
self.game.app.ignoreAll()
self.removeAllTasks()
self.alive = 0
def removeAllTasks(self):
"""Remove and Stop any tasks running"""
for taskName in self.runningTasks:
taskMgr.remove(taskName)
def removeMySims(self):
"""Remove all sims in mode"""
for sim in self.sims:
try:
sim.destroy()
except:
sim.removeNode()
def removeAllGui(self):
"""Remove all DirectGUI"""
for gui in self.gui:
gui.destroy()
def setPlanePickable(self, obj, dictName):
"""Set the plane model itself to be collideable with the mouse ray"""
obj.sim.reparentTo(self.selectable)
obj.sim.find('**/pPlane1').node().setIntoCollideMask(BitMask32.bit(1))
obj.sim.find('**/pPlane1').node().setTag(dictName, obj.id)
def setSpherePickable(self, obj, dictName):
"""Set the sphere model itself to be collideable with the mouse ray"""
obj.sim.reparentTo(self.selectable)
obj.sim.find('**/pSphere1').node().setIntoCollideMask(BitMask32.bit(1))
obj.sim.find('**/pSphere1').node().setTag(dictName, obj.id)
def setMySelector(self, x, y, z, scale):
"""Show selector if it is not in current position else return false"""
selectorPos = (self.selector.getX(), self.selector.getY(), self.selector.getZ())
if selectorPos != (x,y,z):
self.selector.setPos(x,y,z)
self.selector.show()
self.selector.setScale(scale)
return 1
else:
self.selector.setPos(-1,-1,-1)
return 0
#self.enableScrollWheelZoom = 0
def getListButton(self, id, myScrolledList):
"""Return Button selected from buttonList gui based on id"""
for button in myScrolledList.buttonsList:
if button['extraArgs'][1] == id:
return button
def setMySelector2(self, x, y, z, scale):
"""Show selector2 if it is not in current position else return false"""
selectorPos = (self.selector2.getX(), self.selector2.getY(), self.selector2.getZ())
if selectorPos != (x,y,z):
self.selector2.setPos(x,y,z)
self.selector2.show()
self.selector2.setScale(scale)
return 1
else:
self.selector2.setPos(-1,-1,-1)
return 0
#self.enableScrollWheelZoom = 0
def hideMySelector(self):
"""Hide the selector, move its position"""
self.selector.setPos(-1,-1,-1)
self.selector.hide()
if self.selector2 != None:
self.selector2.hide()
def onMouse1Down(self):
"""Allow dynamic picking of an object within mode"""
#Check to see if we can access the mouse. We need it to do anything else
if base.mouseWatcherNode.hasMouse():
#get the mouse position
mpos = base.mouseWatcherNode.getMouse()
#Set the position of the ray based on the mouse position
self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
#Do the actual collision pass (Do it only on the selectable for
#efficiency purposes)
self.picker.traverse(self.selectable)
if self.pq.getNumEntries() > 0:
#if we have hit something, sort the hits so that the closest
#is first, and highlight that node
self.pq.sortEntries()
for selectable in self.selectTypes:
name = self.pq.getEntry(0).getIntoNode().getTag(selectable)
if name != '':
self.clearAnyGui()
mySelectedDict = getattr(self, selectable)
mySelected = mySelectedDict[name]
myMethod = getattr(self, '%sSelected' % selectable)
if self.validateSelection():
myMethod(mySelected)
break
def onMouseWheelUp(self):
""" zoom out """
if self.enableScrollWheelZoom:
self.stopCameraTasks()
self.zoomInCameraAmount(20.0)
def onMouseWheelDown(self):
""" zoom in """
if self.enableScrollWheelZoom:
self.stopCameraTasks()
self.zoomOutCameraAmount(20.0)
def onMouse2Down(self):
"""clear"""
self.onSpaceBarClear()
def onSpaceBarClear(self):
"""Space bar should reset the view in the mode"""
if self.validateSelection():
self.resetCamera()
self.clearMouseSelection()
self.zoomOutCamera()
self.setShortcuts()
self.enableScrollWheelZoom = 1
def clearMouseSelection(self):
"""Clear mouse selection before selecting something new"""
pass
def clearAnyGui(self):
pass
def update(self, interval):
"""update the mode, return the status, 0 means stop game"""
return self.alive
def setMyBackground(self):
"""Set the Background of mode"""
base.setBackgroundColor(globals.colors['guiblue3'])
def setEmpireDefaults(self, clientKey):
"""Read the defaults currently set and change them in the database"""
try:
# setup attributes to send to server
defaults = ['viewIndustry', 'viewMilitary', 'viewResources', 'viewTradeRoutes']
d = {}
for item in defaults:
d[item] = self.game.myEmpire[item]
serverResult = self.game.server.setEmpire(clientKey, d)
if serverResult == 1:
print 'Setup Empire Defaults Success'
else:
self.modeMsgBox(serverResult)
except:
self.modeMsgBox('SetEmpireDefaults->Connection to Server Lost, Login Again')
def setEmpireValues(self, dValues):
"""Update Empire with d = key: empire attribute name,
value = new value"""
try:
serverResult = self.game.server.setEmpire(self.game.authKey, dValues)
if serverResult == 1:
for key, value in dValues.iteritems():
self.game.myEmpire[key] = value
print 'Empire Update Success'
else:
self.modeMsgBox(serverResult)
except:
self.modeMsgBox('setEmpireValues->Connection to Server Lost, Login Again')
def setLogout(self, clientKey):
"""Send a Logout Request to the Server"""
try:
serverResult = self.game.server.logout(clientKey)
if serverResult == 1:
print 'Logout Successful, Exit Program'
else:
self.modeMsgBox(serverResult)
except:
self.modeMsgBox('setLogout->Connection to Server Lost, Login Again')
def submitDesign(self, name):
"""Take Ship Design and submit it to Server for verification and storage"""
(oldName, hullID, compDict, weaponDict) = self.myShipDesign.getMyDesign()
dOrder = {'name':name, 'hullID':hullID, 'compDict':compDict, 'weaponDict':weaponDict}
try:
serverResult = self.game.server.addShipDesign(self.game.authKey, dOrder)
if type(serverResult) == types.StringType:
self.modeMsgBox(serverResult)
else:
# design has been accepted by server, retrieve design ID and add to client
(ID,name) = serverResult
self.game.shipDesigns[ID] = (name, hullID, compDict, weaponDict)
self.getEmpireUpdate(['designsLeft'])
except:
self.modeMsgBox('submitDesign->Connection to Server Lost, Login Again')
def destroyTempFrames(self):
"""Destroy any Temp Frames"""
for frame in self.tempFrames:
frame.destroy()
self.tempFrames = []
def modeMsgBox(self, messageText):
"""Create a message for the user"""
self.createMessage(messageText)
def createMessage(self, text):
"""Create a new message for user"""
myMessage = fadingtext.FadingText(self.guiMediaPath, text, self.messagePositions)
self.messagePositions.append(myMessage.getMyPosition())
self.playSound('beep03')
def writeToScreen(self, myText, x, z, scale=0.2,
color='default', font=3, wordwrap=10):
if color == 'default':
color = Vec4(.1,.1,.8,.8)
text = textonscreen.TextOnScreen(self.guiMediaPath, myText, scale,font=3)
text.writeTextToScreen(x, self.depth, z, wordwrap=wordwrap)
text.setColor(color)
self.gui.append(text)
def loadObject(self, tex=None, pos='default', depth=55, scale=1,
transparency=True, parent='cam', model='plane', glow=0):
if pos == 'default':
pos = Point2(0,0)
if parent == 'cam':
parent = camera
scaleX = 187.5
scaleZ = 117.1875
obj = loader.loadModelCopy('%s%s' % (self.guiMediaPath, model)) #default object uses the plane model
if parent:
obj.reparentTo(parent) #Everything is parented to the camera so
#that it faces the screen
obj.setPos(Point3(pos.getX(), depth, pos.getY())) #Set initial position
obj.setSx(scaleX)
obj.setSz(scaleZ)
obj.setBin("unsorted", 0) #This tells Panda not to worry about the
#order this is drawn in. (it prevents an
#effect known as z-fighting)
if transparency: obj.setTransparency(1) #All of our objects are trasnparent
if tex:
tex = loader.loadTexture('%s%s.png' % (self.guiMediaPath, tex)) #Load the texture
obj.setTexture(tex, 1) #Set the texture
self.sims.append(obj)
obj.setShaderInput('glow',Vec4(glow,0,0,0),glow)
return obj
def onEntryFocus(self):
"""When a text Entry is in focus disable all shortcut keys"""
for gui in self.gui:
if gui.__module__ in self.entryFocusList:
gui.ignoreShortcuts()
def onEntryOutFocus(self):
"""When an text Entry is out of focus enable all shortcut keys"""
for gui in self.gui:
if gui.__module__ in self.entryFocusList:
gui.setShortcuts()
class MousePicker( gizmo_core.Object ):
"""
Class to represent a ray fired from the input camera lens using the mouse.
"""
def __init__( self, name, camera=None, rootNp=None, fromCollideMask=None, pickTag=None ):
gizmo_core.Object.__init__( self, name, camera, rootNp )
self.fromCollideMask = fromCollideMask
self.pickTag = pickTag
self.selection = []
self.node = None
self.collEntry = None
# Create a marquee
self.marquee = gizmo_core.Marquee( '%sMarquee' % self.name )
# Create collision nodes
self.collTrav = CollisionTraverser()
#self.collTrav.showCollisions( render )
self.collHandler = CollisionHandlerQueue()
self.pickerRay = CollisionRay()
# Create collision ray
pickerNode = CollisionNode( self.name )
pickerNode.addSolid( self.pickerRay )
pickerNode.setIntoCollideMask( BitMask32.allOff() )
pickerNp = camera.attachNewNode( pickerNode )
self.collTrav.addCollider( pickerNp, self.collHandler )
# Create collision mask for the ray if one is specified
if self.fromCollideMask is not None:
pickerNode.setFromCollideMask( self.fromCollideMask )
# Bind mouse button events
eventNames = ['mouse1', 'control-mouse1', 'mouse1-up']
for eventName in eventNames:
self.accept( eventName, self.FireEvent, [eventName] )
def FireEvent( self, event ):
# Send a message containing the node name and the event name, including
# the collision entry as arguments
if self.node is not None:
messenger.send( '%s-%s' % ( self.node.getName(), event ), [self.collEntry] )
def UpdateTask( self, task ):
# Traverse the hierarchy and find collisions
self.collTrav.traverse( self.rootNp )
if self.collHandler.getNumEntries():
# If we have hit something, sort the hits so that the closest is first
self.collHandler.sortEntries()
collEntry = self.collHandler.getEntry( 0 )
node = collEntry.getIntoNode()
# If this node is different to the last node, send a mouse leave
# event to the last node, and a mouse enter to the new node
if node != self.node:
if self.node is not None:
messenger.send( '%s-mouse-leave' % self.node.getName(), [self.collEntry] )
messenger.send( '%s-mouse-enter' % node.getName(), [collEntry] )
# Send a message containing the node name and the event over name,
# including the collision entry as arguments
messenger.send( '%s-mouse-over' % node.getName(), [collEntry] )
# Keep these values
self.collEntry = collEntry
self.node = node
elif self.node is not None:
# No collisions, clear the node and send a mouse leave to the last
# node that stored
messenger.send( '%s-mouse-leave' % self.node.getName(), [self.collEntry] )
self.node = None
# Update the ray's position
if base.mouseWatcherNode.hasMouse():
mp = base.mouseWatcherNode.getMouse()
self.pickerRay.setFromLens( self.camera.node(), mp.getX(), mp.getY() )
return task.cont
def StartSelection( self, clearSelection=True ):
# Start the marquee
self.marquee.Start()
# Clear selection list if required
if clearSelection:
self.selection = []
def StopSelection( self ):
# Stop the marquee
self.marquee.Stop()
nodes = []
for node in self.rootNp.findAllMatches( '**' ):
if self.marquee.IsPoint3Inside( self.camera, self.rootNp, node.getPos() ):
if self.pickTag is not None:
if node.getTag( self.pickTag ):
nodes.append( node )
else:
nodes.append( node )
# Add any node which was under the mouse to the selection
if self.collHandler.getNumEntries():
collEntry = self.collHandler.getEntry( 0 )
node = collEntry.getIntoNodePath().getParent()
nodes.append( node )
# If the node was already in the selection then remove it, otherwise
# add the node to the selection
for node in nodes:
if node in self.selection:
self.selection.remove( node )
else:
self.selection.append( node )
# Remove duplicated
self.selection = list( set( self.selection ) )
class objectIdPicklingClass:
def __init__( self, bit=[PICKABLE] ):
global OBJECTIDMAPPING
#Since we are using collision detection to do picking, we set it up like
#any other collision detection system with a traverser and a handler
self.picker = CollisionTraverser() #Make a traverser
self.pq = CollisionHandlerQueue() #Make a handler
#Make a collision node for our picker ray
self.pickerNode = CollisionNode('mouseRay')
#Attach that node to the camera since the ray will need to be positioned
#relative to it
self.pickerNP = base.camera.attachNewNode(self.pickerNode)
#Everything to be picked will use bit 1. This way if we were doing other
#collision we could seperate it
self.pickerNode.setFromCollideMask(bitMaskOr(bit))
self.pickerRay = CollisionRay() #Make our ray
self.pickerNode.addSolid(self.pickerRay) #Add it to the collision node
#Register the ray as something that can cause collisions
self.picker.addCollider(self.pickerNP, self.pq)
#self.picker.showCollisions(render)
def mousePick( self ):
#Check to see if we can access the mouse. We need it to do anything else
if base.mouseWatcherNode.hasMouse():
#get the mouse position
mpos = base.mouseWatcherNode.getMouse()
#Set the position of the ray based on the mouse position
self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
#Do the actual collision pass (Do it only on the squares for
#efficiency purposes)
self.picker.traverse( render )
if self.pq.getNumEntries() > 0:
#if we have hit something, sort the hits so that the closest
#is first, and highlight that node
self.pq.sortEntries()
pickedObj = self.pq.getEntry(0).getIntoNodePath()
#print pickedObj
pickedObjObjectId = pickedObj.findNetTag( 'objectId' )
if pickedObj.hasNetTag( 'objectId' ):
return pickedObj.getNetTag( 'objectId' )
else:
print "pickedObj.hasNetTag( 'objectId' ) failed"
return None
else:
print "self.pq.getNumEntries() = %i" % self.pq.getNumEntries()
return None
else:
print "base.mouseWatcherNode.hasMouse() failed"
return None
def getPickerRayDirection( self, mousePos=None ): #posX, posY ):
''' return the direction of the ray sent trought the mouse
'''
# the pickerRay cannot be changed anyway once it has been set in a frame (BUG?)
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
#mousePos = (mpos.getX(), mpos.getY())
self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
# make a copy of the ray
direction = self.pickerRay.getDirection()
mouseRayDirection = Point3(direction.getX(), direction.getY(), direction.getZ())
# and normalize it
mouseRayDirection.normalize()
return mouseRayDirection
def getObjectMousePick( self ):
objectId = self.mousePick()
if OBJECTIDMAPPING.has_key( objectId ):
return OBJECTIDMAPPING[objectId]
else:
return None
class mouseHandler(DirectObject.DirectObject):
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 rayUpdate(self, task):
if base.mouseWatcherNode.hasMouse():
self.entries = []
for i in range(self.collisionHandler2.getNumEntries()):
entry = self.collisionHandler2.getEntry(i)
self.entries.append(entry)
self.entries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(),
x.getSurfacePoint(render).getZ()))
mpos=base.mouseWatcherNode.getMouse()
# this function will set our ray to shoot from the actual camera lenses off the 3d scene, passing by the mouse pointer position, making magically hit what is pointed by it in the 3d space
self.pickerRay.setFromLens(base.camNode, mpos.getX(),mpos.getY())
return task.cont
def selectUnit(self, unitID, mainClass):
self.clearSelection(mainClass)
self.unitSelected = unitID
self.tempJob = mainClass.unitHandler.gameUnits[self.unitSelected].job
mainClass.unitHandler.gameUnits[self.unitSelected].job = "selected"
mainClass.unitHandler.gameUnits[self.unitSelected].select.show()
if (mainClass.unitHandler.gameUnits[self.unitSelected].AIBehaviors.behaviorStatus('pathfollow') != 'done'):
mainClass.unitHandler.gameUnits[self.unitSelected].AIBehaviors.pauseAi("pathfollow")
print 'UNIT'
def selectWall(self, tilePos, tempNodeName, mainClass):
self.clearSelection(mainClass)
if (tempNodeName[0:17] != 'render/solid roof') or (tempNodeName[0:20] != 'render/solid corner2'):
x = tilePos[0]
y = tilePos[1]
mainClass.GUI.showWall(mainClass.mapLoaderClass.tileArray[y][x], mainClass)
if (mainClass.mapLoaderClass.tileArray[y][x].selectable == True): # If it is selectable, then select it
mainClass.mapLoaderClass.tileArray[self.tileSelected[1]][self.tileSelected[0]].model.setColor(1,1,1,1)
mainClass.mapLoaderClass.tileArray[y][x].model.setColor(0.5,1,0.5,1)
self.tileSelected = (x, y)
def mouseClick1(self, mainClass):
if (len(self.entries)>0):
print str(self.entries[0].getIntoNodePath())
tempNodeName = str(self.entries[0].getIntoNodePath()) # Gets the node path of whatever is clicked on
print tempNodeName, tempNodeName[len(tempNodeName)-3:len(tempNodeName)]
if (tempNodeName[0:12] == "render/solid") or (tempNodeName[0:12] == "render/tile ") or (tempNodeName[0:12] == "render/water") or (tempNodeName[0:11] == "render/lava"): # If a tile or a solid
x = int(self.entries[0].getIntoNode().getName()[len(self.entries[0].getIntoNode().getName())-6:len(self.entries[0].getIntoNode().getName())-4])
y = int(self.entries[0].getIntoNode().getName()[len(self.entries[0].getIntoNode().getName())-2:])
self.selectWall((x,y), tempNodeName, mainClass)
elif (tempNodeName[0:11] == "render/unit"): # If a unit
self.selectUnit(int(tempNodeName[12:15]), mainClass)
# elif (tempNodeName[0:15] == 'render/building'):
# self.selectBuilding(int(tempNodeName[16:19]), mainClass)
def mouseClick3(self, mainClass): # Deselects a wall
if (self.tileSelected != (0,0)):
self.clearSelection(mainClass)
# mainClass.mapLoaderClass.tileArray[self.tileSelected[1]][self.tileSelected[0]].model.setColor(1,1,1,1)
#
# self.tileSelected = (0,0)
elif (self.unitSelected != None):
if (len(self.entries) > 0):
# mainClass.unitHandler.gameUnits[self.unitSelected].select.hide()
tempNodeName = str(self.entries[0].getIntoNodePath())
if (tempNodeName[0:12] == "render/tile ") or (tempNodeName[0:12] == "render/water") or (tempNodeName[0:11] == "render/lava"): # If a tile
mainClass.unitHandler.moveTo(mainClass, (self.entries[0].getSurfacePoint(render).getX(), self.entries[0].getSurfacePoint(render).getY()), self.unitSelected, userJob = True)
mainClass.unitHandler.gameUnits[self.unitSelected].AIBehaviors.resumeAi("pathfollow")
self.clearSelection(mainClass)
#mainClass.mapLoaderClass.tileArray[self.tileSelected[1]][self.tileSelected[0]].model.setColor(1,1,1,1)
# self.tileSelected = (0,0)
else:
mainClass.unitHandler.gameUnits[self.unitSelected].AIBehaviors.removeAi("pathfollow")
self.unitSelected = None
def clearSelection(self, mainClass):
# mainClass.GUI.hideAll()
if (self.tileSelected != (0,0)):
mainClass.mapLoaderClass.tileArray[self.tileSelected[1]][self.tileSelected[0]].model.setColor(1,1,1,1)
self.tileSelected = (0,0)
if (self.unitSelected != None):
mainClass.unitHandler.gameUnits[self.unitSelected].select.hide()
if (self.tempJob != None):
mainClass.unitHandler.gameUnits[self.unitSelected].job = self.tempJob
if (mainClass.unitHandler.gameUnits[self.unitSelected].AIBehaviors.behaviorStatus('pathfollow') == 'paused'):
mainClass.unitHandler.gameUnits[self.unitSelected].AIBehaviors.resumeAi("pathfollow")
self.unitSelected = None
if (self.buildingSelected != None):
mainClass.buildingHandler.buildings[self.buildingSelected].modelNode.setColor(1,1,1,1)
self.buildingSelected = None
def mineWall(self, mainClass):
if (self.tileSelected != (0,0)):
pass
# mainClass.mineWall(mainClass.mapLoaderClass.tileArray[self.tileSelected[1]][self.tileSelected[0]])
# self.b1.hide()
# self.tileSelected = (0,0)
def getMousePos(self):
#if (len(self.entries) >= 1):
return Vec3(self.entries[0].getSurfacePoint(render).getX(), self.entries[0].getSurfacePoint(render).getY(), self.entries[0].getSurfacePoint(render).getZ())
class StrategyGame(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.camera_control()
self.REGION_MAP = "maps/italy_provs.png"
self.TEXTURE_MAP = "maps/italy_terrain2.png"
self.WORLD_MAP = "maps/italy_map.xml"
self.SCENARIO_MAP = "scenarios/italy_scen.xml"
self.terrainScale = 1 # Currently Broken
self.keyboard_setup()
self.drawTerrain()
self.xml_load_map(self.WORLD_MAP,"WorldMap")
self.xml_load_map(self.SCENARIO_MAP,"Scenario")
self.init_collisions()
self.pickingEnabledObject = None
self.taskMgr.add(self.camera_update, "UpdateCameraTask")
self.generate_models()
self.txtBox = OnscreenText("<No province>")
self.setup_collision_calcs()
taskMgr.add(self.rayUpdate, "updatePicker")
taskMgr.doMethodLater(0.2,self.task_calendar, "calendar")
self.init_variables()
self.interface()
def init_variables(self):
self.armies = [[],[]]
for n in range(len(self.nations)):
self.armies.append(n)
self.target = 0
self.army_count = 0
self.selected_prov = -1
self.months = ["January","February","March","April","May","June",
"July","August","September","October","November","December"]
self.adce = "AD"
self.player = 1
self.money_inc = 0
for p in range(len(self.provs)):
if self.provs_owner[p] == self.player:
self.money_inc += self.provs_money[p]
self.men_inc = 0
for p in range(len(self.provs)):
if self.provs_owner[p] == self.player:
self.men_inc += self.provs_men[p]
def draw_card(self,x,y,width,height,colour):
cm = CardMaker("CardMaker")
cm.setFrame(x, x+width,y+height, y)
card = render2d.attachNewNode(cm.generate())
card.setColor(colour)
return (card)
def interface(self):
self.interface_back = self.draw_card(-0.8,-1,1.6,0.4,(100,100,100,100))
self.txt_name = OnscreenText(text = "", pos = (-0.8,-0.7,-0.8))
self.txt_money = OnscreenText(text = "", pos = (-0.8,-0.8,-0.8))
self.txt_men = OnscreenText(text = "", pos = (-0.8,-0.9,-0.8))
self.txt_nation = OnscreenText(text = self.nations[self.player-1], pos = (-1.2,0.9,-0.8))
self.txt_nation_money = OnscreenText(text = "Coin: " + str(self.nations_money[self.player-1])+" +"+str(self.money_inc), pos = (-0.4,0.9,-0.8))
self.txt_nation_men = OnscreenText(text = "Manpower: " + str(self.nations_men[self.player-1])+" +"+str(self.men_inc), pos = (0.4,0.9,-0.8))
self.txt_date = OnscreenText(text = str(self.day)+" of "+self.months[self.month-1]+" "+str(self.year)+self.adce, pos = (-1.0,0.8,-0.8))
def task_calendar(self,task):
#task.delayTime = 5
if (self.month == 1 or self.month == 3 or self.month == 5 or
self.month == 7 or self.month == 8 or self.month == 10 or self.month == 12):
if self.day == 31 and self.month == 12:
self.day = 1
self.month = 1
self.year += 1
elif self.day == 31:
self.day = 1
self.month += 1
else:
self.day += 1
elif (self.month == 4 or self.month == 6 or self.month == 9 or self.month == 11):
if self.day == 30:
self.day = 1
self.month += 1
else:
self.day += 1
elif (self.month == 2):
# if isleap:
# print self.year/4
# print "LEAP YEAR"
# if self.day == 29:
# self.day = 1
# self.month = 3
# else:
# self.day += 1
# else:
print "IS NOT A LEAP YEAR"
if self.day == 28:
self.day = 1
self.month = 3
else:
self.day += 1
self.daypass()
return Task.again
def daypass(self):
self.nations_money[self.player-1] += self.money_inc
self.nations_men[self.player-1] += self.men_inc
self.update_interface()
def update_interface(self):
self.txt_date.setText(str(self.day)+" of "+self.months[self.month-1]+" "+str(self.year)+self.adce)
self.txt_nation_money.setText("Coin: " + str(self.nations_money[self.player-1])+" +"+str(self.money_inc))
self.txt_nation_men.setText("Manpower: " + str(self.nations_men[self.player-1])+" +"+str(self.men_inc))
if self.selected_prov != -1:
self.txt_name.setText("Province: "+self.provs[self.selected_prov])
self.txt_money.setText("Income: "+str(self.provs_money[self.selected_prov]))
self.txt_men.setText("Manpower: "+str(self.provs_men[self.selected_prov]))
self.interface_back.setColor(self.format_colour_tuple(self.nations_rgb[self.provs_owner[self.selected_prov]-1]))
else:
self.txt_name.setText("")
self.txt_money.setText("")
self.txt_men.setText("")
self.interface_back.setColor((255,255,255,255))
def army_create(self):
id = self.army_count+1
army = self.loader.loadModel("models/man.x")
self.armies[0].append(id)
army.reparentTo(self.render)
army.setName(str(id))
army.setScale(1, 1, 1)
x = 50
y = 50
target = self.target
target_x = float(self.provs_x[target])
target_y = 257-float(self.provs_y[target])
target_z = float(self.getObjectZ(target_x,target_y)-1)
oArmyCol = army.attachNewNode(CollisionNode("BuildingCNode%d"%id))
oArmyCol.setScale((2,2,2))
oArmyCol.node().addSolid(CollisionSphere(0,0,0,1))
oArmyCol.setTag("unit","army")
oArmyCol.show()
point1 = Point3(x,y,0)
point2 = Point3(target_x,target_y,target_z)
distance = (point1.getXy() - point2.getXy()).length()
myInterval = army.posInterval(distance/10, Point3(target_x,target_y, target_z))
mySequence = Sequence(myInterval)
mySequence.start()
army.setPos(x, y, self.getObjectZ(x,y)-1)
army.setTag("target",str(target))
self.army_count += 1
if (self.target<len(self.provs)-1):
self.target += 1
else:
self.target = 0
#taskMgr.add()
def army_update(self,id):
point1 = self.armies[0][id-1].getPos()
point2 = Point3(target_x,target_y,target_z)
distance = (point1.getXy() - point2.getXy()).length()
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 setup_collision_calcs(self):
self.cHandler.addInPattern("%(rays)ft-into-%(prov)it")
self.cHandler.addOutPattern("%(rays)ft-out-%(prov)it")
self.cHandler.addAgainPattern("ray_again_all%(""rays"")fh%(""prov"")ih")
self.DO=DirectObject()
self.DO.accept('ray1-into-city', self.collideInBuilding)
self.DO.accept('ray1-out-city', self.collideOutBuilding)
self.DO.accept('ray_again_all', self.collideAgainstBuilds)
self.pickingEnabledOject=None
self.DO.accept('mouse1', self.mouseClick, ["down"])
self.DO.accept('mouse1-up', self.mouseClick, ["up"])
def camera_control(self):
base.disableMouse()
self.camera = base.camera
self.cam_speed = 3
self.cam_drag = 0.01
self.cam_x_moving = False
self.cam_y_moving = False
self.cam_z_moving = False
self.cam_x_inc = 0
self.cam_y_inc = 0
self.cam_z_inc = 0
self.cameraDistance = -50
self.camHeight = 25
self.camXAngle = 0
self.camYAngle = -25
self.camZAngle = 0
self.camX = 0
self.camY = 0
self.camZ = 100
def camera_update(self,task):
if self.cam_x_moving:
self.camX+=self.cam_x_inc
elif self.cam_x_inc != 0:
if (self.cam_x_inc > 0 and self.cam_x_inc-self.cam_drag <= 0) or (self.cam_x_inc < 0 and self.cam_x_inc+self.cam_drag >= 0):
self.cam_x_inc = 0
elif self.cam_x_inc > 0:
self.cam_x_inc -= self.cam_drag
elif self.cam_x_inc < 0:
self.cam_x_inc -= self.cam_drag
else:
print "FUCKUP WITH CAM X INC"
if self.cam_y_moving:
self.camY+=self.cam_y_inc
elif self.cam_y_inc != 0:
if (self.cam_y_inc > 0 and self.cam_y_inc-self.cam_drag <= 0) or (self.cam_y_inc < 0 and self.cam_y_inc+self.cam_drag >= 0):
self.cam_y_inc = 0
elif self.cam_y_inc > 0:
self.cam_y_inc -= self.cam_drag
elif self.cam_y_inc < 0:
self.cam_y_inc -= self.cam_drag
else:
print "FUCKUP WITH CAM Y INC"
if self.cam_z_moving:
self.camZ+=self.cam_z_inc
elif self.cam_z_inc != 0:
if (self.cam_z_inc > 0 and self.cam_z_inc-self.cam_drag <= 0) or (self.cam_z_inc < 0 and self.cam_z_inc+self.cam_drag >= 0):
self.cam_z_inc = 0
elif self.cam_z_inc > 0:
self.cam_z_inc -= self.cam_drag
elif self.cam_z_inc < 0:
self.cam_z_inc -= self.cam_drag
else:
print "FUCKUP WITH CAM Z INC"
self.camera.setPos(self.camX, self.camY, self.camZ)
self.camera.setHpr(self.camXAngle, self.camYAngle, self.camZAngle)
return Task.cont
def camera_move(self, status):
if status == "up":
self.cam_y_moving = True
self.cam_y_inc = self.cam_speed
if status == "down":
self.cam_y_moving = True
self.cam_y_inc = -self.cam_speed
if status == "left":
self.cam_x_moving = True
self.cam_x_inc = -self.cam_speed
if status == "right":
self.cam_x_moving = True
self.cam_x_inc = self.cam_speed
if status == "stopX":
self.cam_x_moving = False
if status == "stopY":
self.cam_y_moving = False
def keyboard_setup(self):
self.accept("w", self.keyW)
self.accept("w-up", self.stop_y)
self.accept("s", self.keyS)
self.accept("s-up", self.stop_y)
self.accept("a", self.keyA)
self.accept("a-up", self.stop_x)
self.accept("d", self.keyD)
self.accept("d-up", self.stop_x)
self.accept("+", self.ZoomIn)
self.accept("c", self.createArmy)
def createArmy(self):
self.army_create()
def ZoomIn(self):
self.camZ -= 1
def keyW( self ):
self.camera_move("up")
def keyS( self ):
self.camera_move("down")
def keyA( self ):
self.camera_move("left")
def keyD( self ):
self.camera_move("right")
def stop_x( self ):
self.camera_move("stopX")
def stop_y( self ):
self.camera_move("stopY")
def generate_models(self):
for p in range(len(self.provs)):
print "Making",self.provs[p]
city = self.loader.loadModel("models/house2.x")
city.reparentTo(self.render)
city.setName(self.provs[p])
city.setScale(2, 2, 2)
x = float(self.provs_x[p]*self.terrainScale)
y = 257*self.terrainScale-float(self.provs_y[p]*self.terrainScale)
city.setPos(x, y, self.getObjectZ(x,y)-1)
oCityCol = city.attachNewNode(CollisionNode("BuildingCNode%d"%p))
oCityCol.setScale((3,3,3))
oCityCol.node().addSolid(CollisionSphere(0,0,0,1))
oCityCol.setTag("prov","city")
city.setTag("id",str(p+1))
#oCityCol.show()
def collideInBuilding(self,entry):
np_into=entry.getIntoNodePath()
np_into.getParent().setColor(.6,.5,1.0,1)
def collideOutBuilding(self,entry):
np_into=entry.getIntoNodePath()
np_into.getParent().setColor(1.0,1.0,1.0,1)
self.pickingEnabledObject = None
self.txtBox.setText("<No province>")
def collideAgainstBuilds(self,entry):
if entry.getIntoNodePath().getParent() <> self.pickingEnabledOject:
np_from=entry.getFromNodePath()
np_into=entry.getIntoNodePath()
self.pickingEnabledObject = np_into.getParent()
self.txtBox.setText(self.pickingEnabledObject.getName())
def mouseClick(self,status):
if self.pickingEnabledObject:
if status == "down":
self.pickingEnabledObject.setScale(0.95*2)
print self.pickingEnabledObject.getTag("id"),self.provs[int(self.pickingEnabledObject.getTag("id"))-1]
self.selected_prov = int(self.pickingEnabledObject.getTag("id"))-1
self.update_interface()
if status == "up":
self.pickingEnabledObject.setScale(1.0*2)
elif self.pickingEnabledObject == None:
self.selected_prov = -1
self.update_interface()
def rayUpdate(self,task):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.pickerRay.setFromLens(base.camNode, mpos.getX(),mpos.getY())
return task.cont
def getObjectZ(self, x, y):
if ((x > 0) and (x < 257) and (y > 0) and (y < 257)):
return(self.terrain.getElevation(x,y)*self.terrainSize)
else:
return 0
def format_colour_tuple(self,colour):
col = string.split(colour)
tuple = (int(col[0]),int(col[1]),int(col[2]),255)
return tuple
def drawTerrain(self):
self.terrainSize = 5
heightmap = "maps/italy_heightmap.png"
colmap = self.TEXTURE_MAP
self.terrain = GeoMipTerrain("terrain")
self.terrain.setHeightfield(heightmap)
self.terrain.setColorMap(colmap)
self.terrain.setBlockSize(64)
#self.terrain.setNear(40)
#self.terrain.setFar(120)
#self.terrain.setMinLevel(1)
self.terrain.setBruteforce(True)
self.terrain.generate()
self.terrain.setAutoFlatten(self.terrain.AFMLight)
self.root = self.terrain.getRoot()
self.root.reparentTo(render)
self.root.setSz(self.terrainSize)
#self.root.setScale(self.terrainScale,self.terrainScale,1)
def xml_load_map(self,file,type):
if type == "WorldMap":
tree = xml.parse(file)
root = tree.getroot()
self.provs = []
self.provs_x = []
self.provs_y = []
self.provs_rgb = []
self.provs_owner = []
self.provs_money = []
self.provs_men = []
counter = 1
for p in root.findall("province"):
self.provs.append(self.get_tag(root,"province", counter, "name"))
self.provs_x.append(self.get_tag(root, "province", counter, "x"))
self.provs_y.append(self.get_tag(root, "province", counter, "y"))
self.provs_rgb.append(self.get_tag(root, "province", counter, "rgb"))
self.provs_owner.append(0)
self.provs_money.append(0)
self.provs_men.append(0)
counter+=1
elif type == "Scenario":
tree = xml.parse(file)
root = tree.getroot()
self.day = 0
self.month = 0
self.year = 0
self.adce = 0
self.day = int(root.attrib["day"])
self.month = int(root.attrib["month"])
self.year = int(root.attrib["year"])
self.nations = []
self.nations_rgb = []
self.nations_capital = []
self.nations_money = []
self.nations_men = []
self.nations_provs_id = []
counter = 0
for p in root.findall("province"):
print p.attrib["id"]
for n in root.findall("nation"):
for p in n.findall("province"):
self.provs_owner[int(p.attrib["id"])-1] = int(p.find("owner").text)
self.provs_money[int(p.attrib["id"])-1] = int(p.find("money").text)
self.provs_men[int(p.attrib["id"])-1] = int(p.find("men").text)
print self.provs_owner[int(p.attrib["id"])-1]
counter+=1
counter = 1
for n in root.findall("nation"):
self.nations.append(self.get_tag(root, "nation", counter, "name"))
self.nations_capital.append(n.attrib["capital"])
#print self.nations_capital
self.nations_rgb.append(self.get_tag(root, "nation", counter, "rgb"))
self.nations_money.append(int(self.get_tag(root, "nation", counter, "money")))
self.nations_men.append(int(self.get_tag(root, "nation", counter, "men")))
counter += 1
def get_tag(self,root,str_tag,prov_id, prov_tag):
prov = root.find('.//'+str_tag+'[@id="'+str(prov_id)+'"]')
tag = prov.find(prov_tag).text
return tag
class mouseHandler(DirectObject.DirectObject):
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 rayUpdate(self, task):
if base.mouseWatcherNode.hasMouse():
self.entries = []
for i in range(self.collisionHandler2.getNumEntries()):
entry = self.collisionHandler2.getEntry(i)
self.entries.append(entry)
self.entries.sort(lambda x, y: cmp(
y.getSurfacePoint(render).getZ(),
x.getSurfacePoint(render).getZ()))
mpos = base.mouseWatcherNode.getMouse()
# this function will set our ray to shoot from the actual camera lenses off the 3d scene, passing by the mouse pointer position, making magically hit what is pointed by it in the 3d space
self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
return task.cont
def selectUnit(self, unitID, mainClass):
self.clearSelection(mainClass)
self.unitSelected = unitID
self.tempJob = mainClass.unitHandler.gameUnits[self.unitSelected].job
mainClass.unitHandler.gameUnits[self.unitSelected].job = "selected"
mainClass.unitHandler.gameUnits[self.unitSelected].select.show()
if (mainClass.unitHandler.gameUnits[self.unitSelected].AIBehaviors.
behaviorStatus('pathfollow') != 'done'):
mainClass.unitHandler.gameUnits[
self.unitSelected].AIBehaviors.pauseAi("pathfollow")
print 'UNIT'
def selectWall(self, tilePos, tempNodeName, mainClass):
self.clearSelection(mainClass)
if (tempNodeName[0:17] != 'render/solid roof') or (
tempNodeName[0:20] != 'render/solid corner2'):
x = tilePos[0]
y = tilePos[1]
mainClass.GUI.showWall(mainClass.mapLoaderClass.tileArray[y][x],
mainClass)
if (mainClass.mapLoaderClass.tileArray[y][x].selectable == True
): # If it is selectable, then select it
mainClass.mapLoaderClass.tileArray[self.tileSelected[1]][
self.tileSelected[0]].model.setColor(1, 1, 1, 1)
mainClass.mapLoaderClass.tileArray[y][x].model.setColor(
0.5, 1, 0.5, 1)
self.tileSelected = (x, y)
def mouseClick1(self, mainClass):
if (len(self.entries) > 0):
print str(self.entries[0].getIntoNodePath())
tempNodeName = str(self.entries[0].getIntoNodePath(
)) # Gets the node path of whatever is clicked on
print tempNodeName, tempNodeName[len(tempNodeName) -
3:len(tempNodeName)]
if (tempNodeName[0:12] == "render/solid") or (
tempNodeName[0:12] == "render/tile ") or (
tempNodeName[0:12] == "render/water") or (
tempNodeName[0:11]
== "render/lava"): # If a tile or a solid
x = int(self.entries[0].getIntoNode().getName()
[len(self.entries[0].getIntoNode().getName()) -
6:len(self.entries[0].getIntoNode().getName()) - 4])
y = int(self.entries[0].getIntoNode().getName()
[len(self.entries[0].getIntoNode().getName()) - 2:])
self.selectWall((x, y), tempNodeName, mainClass)
elif (tempNodeName[0:11] == "render/unit"): # If a unit
self.selectUnit(int(tempNodeName[12:15]), mainClass)
# elif (tempNodeName[0:15] == 'render/building'):
# self.selectBuilding(int(tempNodeName[16:19]), mainClass)
def mouseClick3(self, mainClass): # Deselects a wall
if (self.tileSelected != (0, 0)):
self.clearSelection(mainClass)
# mainClass.mapLoaderClass.tileArray[self.tileSelected[1]][self.tileSelected[0]].model.setColor(1,1,1,1)
#
# self.tileSelected = (0,0)
elif (self.unitSelected != None):
if (len(self.entries) > 0):
# mainClass.unitHandler.gameUnits[self.unitSelected].select.hide()
tempNodeName = str(self.entries[0].getIntoNodePath())
if (tempNodeName[0:12] == "render/tile ") or (
tempNodeName[0:12]
== "render/water") or (tempNodeName[0:11]
== "render/lava"): # If a tile
mainClass.unitHandler.moveTo(
mainClass,
(self.entries[0].getSurfacePoint(render).getX(),
self.entries[0].getSurfacePoint(render).getY()),
self.unitSelected,
userJob=True)
mainClass.unitHandler.gameUnits[
self.unitSelected].AIBehaviors.resumeAi("pathfollow")
self.clearSelection(mainClass)
#mainClass.mapLoaderClass.tileArray[self.tileSelected[1]][self.tileSelected[0]].model.setColor(1,1,1,1)
# self.tileSelected = (0,0)
else:
mainClass.unitHandler.gameUnits[
self.unitSelected].AIBehaviors.removeAi("pathfollow")
self.unitSelected = None
def clearSelection(self, mainClass):
# mainClass.GUI.hideAll()
if (self.tileSelected != (0, 0)):
mainClass.mapLoaderClass.tileArray[self.tileSelected[1]][
self.tileSelected[0]].model.setColor(1, 1, 1, 1)
self.tileSelected = (0, 0)
if (self.unitSelected != None):
mainClass.unitHandler.gameUnits[self.unitSelected].select.hide()
if (self.tempJob != None):
mainClass.unitHandler.gameUnits[
self.unitSelected].job = self.tempJob
if (mainClass.unitHandler.gameUnits[self.unitSelected].AIBehaviors.
behaviorStatus('pathfollow') == 'paused'):
mainClass.unitHandler.gameUnits[
self.unitSelected].AIBehaviors.resumeAi("pathfollow")
self.unitSelected = None
if (self.buildingSelected != None):
mainClass.buildingHandler.buildings[
self.buildingSelected].modelNode.setColor(1, 1, 1, 1)
self.buildingSelected = None
def mineWall(self, mainClass):
if (self.tileSelected != (0, 0)):
pass
# mainClass.mineWall(mainClass.mapLoaderClass.tileArray[self.tileSelected[1]][self.tileSelected[0]])
# self.b1.hide()
# self.tileSelected = (0,0)
def getMousePos(self):
#if (len(self.entries) >= 1):
return Vec3(self.entries[0].getSurfacePoint(render).getX(),
self.entries[0].getSurfacePoint(render).getY(),
self.entries[0].getSurfacePoint(render).getZ())
class MouseEvents(DirectObject.DirectObject):
def __init__(self):
# from gameEngine import moveUnitsNext, moveUnitsPrev
# self.accept('arrow_down', moveUnitsNext )
# self.accept('arrow_up', moveUnitsPrev )
self.accept('arrow_up-repeat', self.moveCameraUp)
self.accept('arrow_up', self.moveCameraUp)
self.accept('arrow_down-repeat', self.moveCameraDown)
self.accept('arrow_down', self.moveCameraDown)
self.accept('arrow_left-repeat', self.moveCameraLeft)
self.accept('arrow_left', self.moveCameraLeft)
self.accept('arrow_right-repeat', self.moveCameraRight)
self.accept('arrow_right', self.moveCameraRight)
# Initialize the traverser.
self.myTraverser = CollisionTraverser()
# Initialize the handler.
self.myHandler = CollisionHandlerQueue()
self.accept("escape", sys.exit) #Exit the program when escape is pressed
base.disableMouse()
self.pickerNode = CollisionNode('mouseRay')
self.pickerNP = camera.attachNewNode(self.pickerNode)
self.pickerNode.setFromCollideMask(BitMask32.bit(1))
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
self.myTraverser.addCollider(self.pickerNP, self.myHandler)
''' the player has to double click a star or planet in order to activate them '''
self.accept("mouse1", self.handleLeftMouseClick)
self.accept("mouse3", self.handleRightMouseClick)
self.accept("mouse1-up", self.handleMouseDrag)
self.mouseFirstPos = None
cm = CardMaker('quad')
# cm.setFrameFullscreenQuad()
self.drag_rect_path = base.render2d.attachNewNode(cm.generate())
self.drag_rect_path.setTransparency(TransparencyAttrib.MAlpha)
self.drag_rect_path.setColor(Vec4(1,1,1,0.3))
self.drag_rect_path.hide()
# self.drag_rect_path = LineNodePath(base.render2d, thickness = 8.0)
def selectionRectangle(self, task):
if base.mouseWatcherNode.hasMouse():# and self.mouseFirstPos != None:
mpos = base.mouseWatcherNode.getMouse()
self.drag_rect_path.show()
self.drag_rect_path.setSx(mpos.getX()-self.mouseFirstPos.getX()+0.0001)
self.drag_rect_path.setSz(mpos.getY()-self.mouseFirstPos.getY()+0.0001)
self.drag_rect_path.setPos(self.mouseFirstPos.getX(), 0, self.mouseFirstPos.getY())
# self.drag_rect_path.drawLines([((self.mouseFirstPos.getX(),self.mouseFirstPos.getY()),(mpos.getX(), mpos.getY()))])
# self.drag_rect_path.create()
# base.win.makeDisplayRegion(self.mouseFirstPos.getX(), self.mouseFirstPos.getY(), mpos.getX(), mpos.getY())
return task.cont
def handleMouseDrag(self):
if base.mouseWatcherNode.hasMouse():
if self.mouseFirstPos != None:
mpos = base.mouseWatcherNode.getMouse()
lvec = Vec2(self.mouseFirstPos) - Vec2(mpos)
if lvec.length() > 0.01:
scaled_pos = Point2(self.mouseFirstPos)
scaled_pos.setX(scaled_pos.getX()*base.getAspectRatio())
scaled_mpos = Point2(mpos)
scaled_mpos.setX(scaled_mpos.getX()*base.getAspectRatio())
for unit in self.player.selected_units:
unit.deselect()
del self.player.selected_units[:]
for unit in self.player.units:
if unit.is3dpointIn2dRegion(scaled_pos, scaled_mpos):
unit.select()
self.mouseFirstPos = None
self.drag_rect_path.hide()
taskMgr.remove(self.rect_task)
def setPlayer(self, player):
self.player = player
def setCamera(self, camera):
self.camera = camera
def moveCameraUp(self):
self.camera.camera_direction = "moveUp"
def moveCameraDown(self):
self.camera.camera_direction = "moveDown"
def moveCameraLeft(self):
self.camera.camera_direction = "moveLeft"
def moveCameraRight(self):
self.camera.camera_direction = "moveRight"
def handleLeftMouseClick(self):
if base.mouseWatcherNode.hasMouse():
#get the mouse position
mpos = base.mouseWatcherNode.getMouse()
self.savemousePos()
# This makes the ray's origin the camera and makes the ray point
# to the screen coordinates of the mouse.
self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
self.myTraverser.traverse(render)
# Assume for simplicity's sake that myHandler is a CollisionHandlerQueue.
if self.myHandler.getNumEntries() > 0:
# This is so we get the closest object.
self.myHandler.sortEntries()
pickedObj = self.myHandler.getEntry(0).getIntoNodePath()
if pickedObj.hasTag('star'):
self.selected(pickedObj, 'star', 'pyStar', 'leftClick')
elif pickedObj.hasTag('planet'):
self.selected(pickedObj, 'planet', 'pyPlanet', 'leftClick')
elif pickedObj.hasTag('unit'):
self.selected(pickedObj, 'unit', 'pyUnit', 'leftClick')
elif pickedObj.hasTag('testUnit'):
self.selected(pickedObj, 'testUnit', 'pyTestUnit', 'leftClick')
self.rect_task = taskMgr.add(self.selectionRectangle, 'drag')
def savemousePos(self):
self.mouseFirstPos = Point2(base.mouseWatcherNode.getMouse())
# self.mouseFirstPos.setX(self.mouseFirstPos.getX()*1.33)
def handleRightMouseClick(self):
if base.mouseWatcherNode.hasMouse():
#get the mouse position
mpos = base.mouseWatcherNode.getMouse()
# This makes the ray's origin the camera and makes the ray point
# to the screen coordinates of the mouse.
self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
self.myTraverser.traverse(render)
# Assume for simplicity's sake that myHandler is a CollisionHandlerQueue.
if self.myHandler.getNumEntries() > 0:
# This is so we get the closest object.
self.myHandler.sortEntries()
pickedObj = self.myHandler.getEntry(0).getIntoNodePath()
#if pickedObj.hasTag('star'):
# self.selected(pickedObj, 'star', 'pyStar')
if pickedObj.hasTag('planet'):
self.selected(pickedObj, 'planet', 'pyPlanet', 'rightClick')
#elif pickedObj.hasTag('unit'):
# self.selected(pickedObj, 'unit', 'pyUnit')
def selected(self, pickedObj, tag, python_tag, click):
# print 'Player has selected '+ tag + ' ' + pickedObj.getTag(tag)
model_path = pickedObj.getParent()
#model_path.notify("starSelected")
model = model_path.getPythonTag(python_tag)
if(click == 'rightClick'):
model.selectRight(self.player)
elif(click == 'leftClick' and tag == 'unit'):
if(self.player == model.player):
for unit in self.player.selected_units:
unit.deselect()
del self.player.selected_units[:]
model.select()
else:
model.select(self.player)
class Level2World(object):
def __init__(self, render, loader, theBase, world, hopper):
self.render = render
self.loader = loader
base = theBase
self.world = world
self.hopper = hopper
base.disableMouse()
#----- Play Music -----
self.backgroundMusic = base.loader.loadSfx("sounds/deathDanceMusic.mp3")
self.backgroundMusic.play()
self.failSound = base.loader.loadSfx("sounds/fail.wav")
#------ State Variables -----
self.isLit = False
#----- Setup Visible World -----
self.platforms = []
self.spinningPlatforms = []
self.spinners = []
self.berries = []
self.coins = []
self.enemies = []
self.setupPlatforms()
self.setupCoins()
self.setupBerries()
self.setupEnemies()
self.endToken = Coin(self.render, self.world, self.hopper, 0, 0.6, 0.6, Vec3(0, 0, 1))
self.endToken.coinNP.reparentTo(self.platforms[-1].platformBulletNode)
self.wizardLair = WizardLair(self.render, self.world, self.loader, self.hopper)
self.wizardLair.wizardGate.reparentTo(self.platforms[1].platformBulletNode)
self.wizardLair.castle.reparentTo(self.platforms[6].platformBulletNode)
self.wizardLair.lair.reparentTo(self.platforms[11].platformBulletNode)
self.sky = loader.loadModel("models/art/cat-skies/alice-skies--celestial/celestial.egg")
self.sky.setPos(0, 0, 0)
self.sky.setP(90)
self.sky.setScale(1)
self.sky.reparentTo(self.render)
#----- Setup Light -----
self.directionalLight2 = DirectionalLight( "directionalLight" )
self.directionalLight2.setColor( Vec4( 1, 1, 1, 1 ) )
self.directionalLight2.setDirection(Vec3(0, 0, -1))
self.directionalLightNP = self.render.attachNewNode(self.directionalLight2)
#----- Collision Handling -----
base.cTrav = CollisionTraverser()
self.collisionHandler = CollisionHandlerEvent()
self.pickerNode = CollisionNode('mouseRayCollisionNode')
self.pickerNP = base.camera.attachNewNode(self.pickerNode)
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
base.cTrav.addCollider(self.pickerNP, self.collisionHandler)
self.collisionHandler.addInPattern("mouseRayIntoEnemy")
self.collisionHandler.addOutPattern("mouseRayOutEnemy")
self.pickingEnabledObject = None
#----- Tasks -----
def update(self, task):
self.hopper.processInput()
for enemy in self.enemies:
if enemy.getHealth() != 0: enemy.pace()
dt = globalClock.getDt()
self.world.doPhysics(dt, 10, 1/180.0)
return task.cont
def simulateWater(self, task):
if self.hopper.hopperNP.getZ() < 0:
self.hopper.freeze = True
return task.done
else:
return task.cont
def rayUpdate(self, task):
if base.mouseWatcherNode.hasMouse():
mPos = base.mouseWatcherNode.getMouse()
self.pickerRay.setFromLens(base.camNode, mPos.getX(), mPos.getY())
return task.cont
#----- Setup Enemy Functions -----
def setupEnemies(self):
enemy1 = Enemy(self.render, self.world, base, Point3(0, 0, 1), self.hopper, 1)
enemy1.enemyNP.reparentTo(self.platforms[3].platformBulletNode)
enemy2 = Enemy(self.render, self.world, base, Point3(0, 0, 1), self.hopper, 2)
enemy2.enemyNP.reparentTo(self.platforms[4].platformBulletNode)
self.enemies.append(enemy1)
self.enemies.append(enemy2)
#----- Lair Enemies -----
enemy = Enemy(self.render, self.world, base, Point3(3, 16, 1), self.hopper, 1, strength = 2, size = 1.3)
enemy.enemyNP.reparentTo(self.platforms[11].platformBulletNode)
self.enemies.append(enemy)
enemy = Enemy(self.render, self.world, base, Point3(3, -16, 1), self.hopper, 1, strength = 2, size = 1.3)
enemy.enemyNP.reparentTo(self.platforms[11].platformBulletNode)
self.enemies.append(enemy)
enemy = Enemy(self.render, self.world, base, Point3(13, 3, 1), self.hopper, 1, strength = 2, size = 1.3)
enemy.enemyNP.reparentTo(self.platforms[11].platformBulletNode)
self.enemies.append(enemy)
enemy = Enemy(self.render, self.world, base, Point3(-13, 3, 1), self.hopper, 1, strength = 2, size = 1.3)
enemy.enemyNP.reparentTo(self.platforms[11].platformBulletNode)
self.enemies.append(enemy)
def resetEnemies(self):
for enemy in self.enemies:
enemy.enemyNP.remove_node()
self.enemies = []
self.setupEnemies()
def collideEventIn(self, entry):
print "Selected enemy!"
np_from = entry.getFromNodePath()
np_into = entry.getIntoNodePath()
np_into.getParent().setColor(.6, 0.5, 1.0, 1)
self.pickingEnabledObject = np_into
def collideEventOut(self, entry):
print "Deselected enemy!"
self.pickingEnabledObject = None
np_into = entry.getIntoNodePath()
np_into.getParent().setColor(1.0, 1.0, 1.0, 1)
def mousePick(self, status):
if self.pickingEnabledObject:
if status == 'down':
idNum = self.pickingEnabledObject.getTag("id")
self.enemies[int(idNum)-1].lowerHealth()
if status == 'up':
pass
#----- Setup Item Functions -----
def setupPlatforms(self):
path = "images/wizardFloor.jpg"
platform = Platform(self.render, self.world, 0, Vec3(10, 7, 0.5), Point3(-2, 3, -1), tex = path)
self.platforms.append(platform)
platform = Platform(self.render, self.world, 0, Vec3(10, 7, 0.5), Point3(-13, 3, -1), tex = path)
self.platforms.append(platform)
platform = Platform(self.render, self.world, 0, Vec3(10, 7, 0.5), Point3(-24, 3, 0), roll = 20, tex = path)
self.platforms.append(platform)
platform = Platform(self.render, self.world, 0, Vec3(10, 7, 0.5), Point3(-38, 3, 3), tex = path)
self.platforms.append(platform)
platform = Platform(self.render, self.world, 0, Vec3(10, 7, 0.5), Point3(-50, 3, 4), tex = path)
self.platforms.append(platform)
platform = Platform(self.render, self.world, 0, Vec3(10, 7, 0.5), Point3(-62, 3, 5), tex = path)
self.platforms.append(platform)
platform = Platform(self.render, self.world, 0, Vec3(30, 30, 0.5), Point3(-72, 3, 6), tex = path)
self.platforms.append(platform)
x = -68; y = 3; z = 5
heading = 0
for i in range(4):
platform = Platform(self.render, self.world, heading, Vec3(7, 6, 0.5), Point3(x, y, z), tex = path)
self.platforms.append(platform)
self.spinningPlatforms.append(platform)
x -= 8; z += 1.8
platform = Platform(self.render, self.world, 0, Vec3(30, 30, 0.5), Point3(x - 40, -15, z), tex = path)
self.platforms.append(platform)
x -= 40; y = 3
heading = 45
for i in range(4):
platform = Platform(self.render, self.world, heading, Vec3(9, 7, 0.5), Point3(x, y, z), tex = path)
self.platforms.append(platform)
if i == 0 or i == 2:
spinner = Spinner(self.render, self.world, 90, 25, Vec3(2.2, 0.3, 1), Point3(x+9, y+7, z+2))
self.spinners.append(spinner)
x -= 10; y -= 10; z += 1.8
def setupCoins(self):
#----- Castle Coins -----
x = 3
for i in range(9):
coin = Coin(self.render, self.world, self.hopper, 10, 0.35, 0.35, Point3(x, -8, 2))
coin.coinNP.reparentTo(self.platforms[6].platformBulletNode)
self.coins.append(coin)
x -= 2
#----- Lair Coins -----
x = 3
for i in range(8):
coin = Coin(self.render, self.world, self.hopper, 10, 0.35, 0.35, Point3(x, -12, 2))
coin.coinNP.reparentTo(self.platforms[11].platformBulletNode)
self.coins.append(coin)
x -= 2
index = 2
for i in range(4):
coin = Coin(self.render, self.world, self.hopper, 10, 0.35, 0.35, Point3(0, 0, 2))
coin.coinNP.reparentTo(self.platforms[index].platformBulletNode)
self.coins.append(coin)
index += 4
def resetCoins(self):
print "Inside coins; NOT removing a coin but initializing list to 0"
self.coins = []
self.setupCoins()
def setupBerries(self):
index = 3
mult = 1
for i in range(4):
berry1 = Berry(self.render, self.world, self.hopper, 10*mult, 0.35, 0.35, Point3(0, 0, 2))
berry1.berryNP.reparentTo(self.platforms[index].platformBulletNode)
self.berries.append(berry1)
index += 3
mult *= -1
if mult > 0:
mult *= 2
else:
mult /= 2
def resetBerries(self):
self.berries = []
self.setupBerries()
#----- Light Functions -----
def addLight(self):
self.dlight = DirectionalLight('dlight')
self.dlight.setColor(VBase4(0.9, 0.9, 0.8, 1))
self.dlnp = self.render.attachNewNode(self.dlight)
self.dlnp.setHpr(90, -30, 0)
self.render.setLight(self.dlnp)
self.slight = Spotlight('slight')
slens = PerspectiveLens()
self.slight.setLens(slens)
self.slight.setColor(Vec4(1, 1, 1, 1))
self.slnp = self.render.attachNewNode(self.slight)
self.slnp.reparentTo(self.hopper.hopperNP)
self.slnp.setPos(0, 40, 50)
self.slnp.lookAt(self.hopper.hopperNP)
self.render.setLight(self.slnp)
self.alight = AmbientLight('alight')
self.alight.setColor(VBase4(0.2, 0.4, 1, 1))
self.alnp = self.render.attachNewNode(self.alight)
self.render.setLight(self.alnp)
self.render.setShaderAuto()
self.slight.setShadowCaster(True)
for platform in self.platforms:
platform.removeNormal()
def destroyLight(self):
self.render.clearLight(self.dlnp)
self.render.clearLight(self.alnp)
self.render.clearLight(self.slnp)
for platform in self.platforms:
platform.addNormal()
def destroyWorld(self):
for platform in self.platforms:
self.world.removeRigidBody(platform.platformBulletNode.node())
platform.platformBulletNode.remove_node()
for spinner in self.spinners:
self.world.removeRigidBody(spinner.spinnerBulletNode.node())
spinner.spinnerBulletNode.remove_node()
for coin in self.coins:
self.world.removeGhost(coin.ghostNode)
coin.removeCoin()
for enemy in self.enemies:
enemy.enemyNP.remove_node()
class World(DirectObject.DirectObject):
def __init__(self):
self.creeps = None
self.open = False
self.sec = 0
self.min = 0
self.pindex = 1 # This is the Pause Index
self.index = -1 # This is the hero Index
self.rindex = False # This is the Repick Index
self.hpicked = [] # This List Stores All The Heroes Picked and Removes Them
for i in range(0, 110):
self.hpicked.append(-1) # Gotta change and check this
self.hindex = 0 # When a hero is picked this index saves it and stores it in the list
self.RND = render.attachNewNode("rend")
self.LightHandler = None
self.Players()
self.LoadTerrain() # Load the Map
self.SetupCamera()
self.SetupLight()
self.SetupEvents()
self.SetupTimer()
self.chooseHero()
self.SetupMap()
self.SetupCreeps()
self.SetupCollision()
self.displayed = False
self.keyMap = {"cam-left": 0, "cam-right": 0, "cam-up": 0, "cam-down": 0, "zoom-in": 0, "zoom-out": 0}
self.chatindex = 0
self.chat = [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]
self.text = ["text1", "text2", "text3", "text4", "text5" "text6" "text7" "text8" "text9", "text10", "text11"]
self.task = None
def Players(self):
self.hero1 = None
self.hero2 = None
self.hero3 = None
self.hero4 = None
self.hero5 = None
self.hero6 = None
self.hero7 = None
self.hero8 = None
self.hero9 = None
self.hero10 = None
self.player1 = None
self.player2 = None
self.player3 = None
self.player4 = None
self.player5 = None
self.player6 = None
self.player7 = None
self.player8 = None
self.player9 = None
self.player10 = None
def LoadTerrain(self):
self.terrain = loader.loadModel("models/environment")
self.terrain.setTag("Map", "1")
self.terrain.reparentTo(self.RND)
self.itmpan1 = OnscreenImage(image=MYDIRIMG + "/3.png", scale=(0.3, 0, 0.09), pos=(0.61, 0, -0.915))
self.itmpan2 = OnscreenImage(image=MYDIRIMG + "/3.png", scale=(0.3, 0, 0.09), pos=(0.61, 0, -0.740))
self.t2 = OnscreenImage(image=MYDIRIMG + "/t2.png", scale=(0.25, 0, 0.06), pos=(1.160, 0, -0.71))
self.t1 = OnscreenImage(image=MYDIRIMG + "/t1.png", scale=(0.25, 0, 0.06), pos=(1.160, 0, -0.83))
self.end = OnscreenImage(image=MYDIRIMG + "/end.png", scale=(0.1, 0, 0.2), pos=(1.510, 0, -0.80))
self.back = OnscreenImage(image=MYDIRIMG + "/back.png", scale=(0.57, 0, 0.2), pos=(-0.26, 0, -0.80))
def SetupCollision(self):
base.cTrav = CollisionTraverser()
self.collHandler = CollisionHandlerQueue()
self.pickerNode = CollisionNode("mouseRay")
self.pickerNP = camera.attachNewNode(self.pickerNode)
self.pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
base.cTrav.addCollider(self.pickerNP, self.collHandler)
def ObjectClick(self):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
base.cTrav.traverse(render) # Assume for simplicity's sake that myHandler is a CollisionHandlerQueue.
if self.collHandler.getNumEntries() > 0: # This is so we get the closest object.
self.collHandler.sortEntries()
self.pickedObj = self.collHandler.getEntry(0).getIntoNodePath()
self.pickedObj1 = self.pickedObj.findNetTag("Unit")
self.pickedObj2 = self.pickedObj.findNetTag("MyHero")
self.pickedObj3 = self.pickedObj.findNetTag("Map")
self.pickedObj4 = self.pickedObj.findNetTag("MyHero")
if self.pickedObj1 == self.creeps.getModel():
if self.displayed is False:
self.displayed = True
self.creeps.display()
else:
if self.displayed is True:
self.displayed = False
self.creeps.displaynot()
if self.hero != None:
if self.pickedObj2 == self.hero1.getModel():
if self.displayed is False:
self.displayed = True
self.hero1.display()
else:
if self.displayed is True:
self.displayed = False
self.hero1.displaynot()
def SetupCamera(self):
base.camera.setPos(0, 0, 180)
base.camera.setP(-30)
base.camera.lookAt(0, 0, 0)
def SetupTimer(self):
self.btn = aspect2d.attachNewNode("btn")
self.btn.setTransparency(1)
self.timesec = OnscreenText(text="", pos=(1.3, -0.71), fg=(1, 1, 1, 1), mayChange=1, scale=0.05)
self.timemin = OnscreenText(text="", pos=(1.1, -0.71), fg=(1, 1, 1, 1), mayChange=1, scale=0.05)
self.pausebtn = DirectButton(
text="Pause (%d)" % (self.pindex),
parent=self.btn,
text_fg=(0, 0.2, 0, 1),
text_pos=(0.05, -0.15),
text_scale=(0.48, 0.53),
image=(MYDIRIMG + "btnof.png", MYDIRIMG + "btnon.png", MYDIRIMG + "btnon.png", None),
frameColor=(0, 0, 0, 0),
pos=(-1.0, 0, -0.81),
image_scale=(1.0, 0, 0.7),
scale=(0.15, 0, 0.10),
command=self.Pause,
)
self.infobtn = DirectButton(
text="Info",
parent=self.btn,
text_fg=(0, 0.2, 0, 1),
text_pos=(0.05, -0.15),
text_scale=0.6,
image=(MYDIRIMG + "btnof.png", MYDIRIMG + "btnon.png", MYDIRIMG + "btnon.png", None),
frameColor=(0, 0, 0, 0),
pos=(-1.0, 0, -0.68),
image_scale=(1.0, 0, 0.7),
scale=(0.15, 0, 0.10),
command=self.Pause,
)
taskMgr.doMethodLater(1, self.Timer, "tickTask")
def SetupMap(self):
self.minimap = minimap(None)
def SetupLight(self):
self.LightHandler = Lights(None)
def SetupEvents(self):
self.DEntry = DirectEntry(
text="",
pos=(-0.6, 0.0, -0.7),
image=MYDIRIMG + "/tooltips9.png",
frameColor=(0, 0, 0, 1),
width=27,
image_pos=(13.5, 0, 0.2),
image_scale=(15, 0, 0.6),
scale=0.05,
initialText="",
numLines=1,
focus=1,
command=self.Parser,
)
self.DEntry.setTransparency(1)
self.DEntry.detachNode()
taskMgr.add(self.MoveCamera, "CameraControl")
self.accept("enter", self.MsgBox)
self.accept("wheel_up", self.setKey, ["zoom-in", 1])
self.accept("wheel_down", self.setKey, ["zoom-out", 1])
# self.accept("wheel_up-up",self.setKey, ["zoom-in",0])
# self.accept("wheel_down-up",self.setKey, ["zoom-out",0])
self.accept("a", self.setKey, ["cam-left", 1])
self.accept("d", self.setKey, ["cam-right", 1])
self.accept("w", self.setKey, ["cam-up", 1])
self.accept("s", self.setKey, ["cam-down", 1])
self.accept("+", self.setKey, ["zoom-in", 1])
self.accept("-", self.setKey, ["zoom-out", 1])
self.accept("a-up", self.setKey, ["cam-left", 0])
self.accept("d-up", self.setKey, ["cam-right", 0])
self.accept("w-up", self.setKey, ["cam-up", 0])
self.accept("s-up", self.setKey, ["cam-down", 0])
self.accept("+-up", self.setKey, ["zoom-in", 0])
self.accept("--up", self.setKey, ["zoom-out", 0])
self.accept("mouse1", self.ObjectClick)
def UnSetupEvents(self):
self.ignore("a")
self.ignore("s")
self.ignore("w")
self.ignore("s")
self.ignore("+")
self.ignore("-")
self.ignore("enter")
self.ignore("wheel_up")
self.ignore("wheel_down")
taskMgr.remove("CameraControl")
def setKey(self, key, value):
self.keyMap[key] = value
def MoveCamera(self, task):
mpos = base.mouseWatcherNode.getMouse()
elapsed = globalClock.getDt()
self.dt = elapsed
self.mx = mpos.getX()
self.my = mpos.getY()
if self.keyMap["cam-left"] != 0:
base.camera.setX(base.camera, -(self.dt * 20))
if self.keyMap["cam-right"] != 0:
base.camera.setX(base.camera, +(self.dt * 20))
if self.keyMap["zoom-in"] != 0:
base.camera.setY(base.camera, -(self.dt * 20))
if self.keyMap["zoom-out"] != 0:
base.camera.setY(base.camera, +(self.dt * 20))
if self.keyMap["cam-down"] != 0:
base.camera.setZ(base.camera, -(self.dt * 20))
if self.keyMap["cam-up"] != 0:
base.camera.setZ(base.camera, +(self.dt * 20))
if self.mx > 0.95:
if base.camera.getX() < MAPLIMIT:
base.camera.setX(base.camera, +(self.dt * SCROLLSPEED))
if self.mx < -0.95:
if base.camera.getX() > -MAPLIMIT:
base.camera.setX(base.camera, -(self.dt * SCROLLSPEED))
if self.my > 0.95:
if base.camera.getY() < MAPLIMIT:
base.camera.setZ(base.camera, +(self.dt * SCROLLSPEED))
if self.my < -0.95:
if base.camera.getY() > -MAPLIMIT:
base.camera.setZ(base.camera, -(self.dt * SCROLLSPEED))
return task.cont
def chooseHero(self):
if self.hero1 == None:
self.BTNnode = aspect2d.attachNewNode("buttons")
for i in range(0, 3):
for j in range(0, 4):
self.index += 1
if icons[self.index] == None:
continue
if self.hpicked[self.index] == self.index:
continue
self.worldHeroButton(-1.8 + j * 0.1, -i * 0.1, self.index)
def worldHeroButton(self, x, y, arg):
DirectButton(
text="",
parent=self.BTNnode,
text_font=font,
image=MYDIRICONS + icons[arg] + ".tga",
frameColor=(0, 0, 0, 0),
pad=(-0.1, -0.1),
image_scale=(IconSx + 0.2, 0, IconSy + 0.2),
pos=(posx - 0.5 + x, 0, posy + y),
scale=(0.20, 0, 0.20),
command=self.SetupHero,
extraArgs=[arg],
)
def SetupCreeps(self):
self.creeps = Unit1()
def SetupHero(self, no):
self.hpicked.insert(self.hindex, no)
self.hindex += 1
self.BTNnode.detachNode()
self.hero1 = Hero(no)
self.hero1.getModel().setTag("Hero1", "1")
def Timer(self, task):
self.task = task
self.sec += 1
if self.hero1 != None:
self.hero1.sendTime(self.min, self.sec)
if self.sec >= 60:
self.sec = 0
self.min += 1
self.timemin.setText(str(self.min))
self.timesec.setText(str(self.sec))
return task.again
def MsgBox(self):
if self.open == False:
self.DEntry.reparentTo(aspect2d)
self.open = True
else:
self.DEntry.detachNode()
self.open = False
def Parser(self, text):
Text = text
# Within 120 seconds on the game
if self.hero1 == None:
self.BTNnode.detachNode()
if Text == "-random":
self.hero1 = Hero(random.randint(0, 96))
elif Text == "-random int":
self.hero1 = Hero(random.randint(66, 96))
elif Text == "-random str":
self.hero1 = Hero(random.randint(0, 36))
elif Text == "-random agi":
self.hero1 == Hero(random.randint(36, 66))
if Text == "-repick":
if self.rindex == False:
if self.hero1 != None:
self.hero1.destroy()
self.hero1 = None
self.index = -1
self.chooseHero()
self.rindex = True
else:
Error("Cannot Repick")
elif Text == "-":
pass
else:
pass
# self.Chat(Text,self.task)
# taskMgr.add(self.Chat,"nn",extraArgs=[Text])
# this sends text to allies
def ChatTimer(self, task, chat, i):
chat.destroy()
self.chat.insert(i, 0)
self.chatindex -= 1
return task.done
def Chat(self, text, task):
for i in range(1, 15):
if self.chat[i] == 0:
self.text[i] = OnscreenText(text=text, pos=(-1.3, -0.4), fg=(0, 0, 0, 1), scale=0.07)
self.chat.insert(self.chatindex, 1)
taskMgr.doMethodLater(5, self.ChatTimer, "chat", [task, self.text[i], i])
self.chatindex += 1
break
else:
self.text[i].setY(-(0.1 * i) + 0.4)
return task.done
def Pause(self):
if self.pindex != 0:
self.pindex -= 1
time.sleep(2)
self.pausebtn["text"] = "Pause (%d)" % (self.pindex)
else:
Error("Pause Limits Used")
def destroy(self):
if self.hero1 != None:
self.hero1.destroy()
self.minimap.destroy()
self.btn.detachNode()
self.BTNnode.detachNode()
taskMgr.remove("timer")
self.terrain.detachNode()
del self.LightHandler
del self.creeps
self.UnSetupEvents()
def MousePos(self, task): # This Took me 1.5 Months to Learn
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)
):
pass
return task.again
class MouseControls(DirectObject.DirectObject):
def __init__(self):
self.keys = {}
for char in string.ascii_lowercase:
self.keys[char] = BUTTON_UP
def makeKeyPair(ch):
def keyUp():
self.keys[ch] = BUTTON_DOWN
#print "%s UP" % (ch)
def keyDown():
self.keys[ch] = BUTTON_UP
#print "%s DOWN" % (ch)
return [keyUp, keyDown]
keyPair = makeKeyPair(char)
self.accept(char,keyPair[0])
self.accept(char+'-up',keyPair[1])
self.accept('mouse1',self.leftClick)
self.accept('mouse1-up',self.leftClickUp)
self.accept('mouse2',self.mClick)
self.accept('mouse2-up',self.mClickUp)
self.accept('mouse3',self.rightClick)
self.accept('mouse3-up',self.rightClickUp)
self.mouse1Down = False
self.mouse2Down = False
self.mouse3Down = False
self.trackMouseTimeOld = 0
self.trackMouseX = 0
self.trackMouseY = 0
self.trackMouse_Mouse1DownOld = False
self.trackMouse_Mouse2DownOld = False
self.trackMouse_Mouse3DownOld = False
taskMgr.add(self.trackMouseTask, 'trackMouseTask')
#
base.cTrav = CollisionTraverser()
self.pickerQ = CollisionHandlerQueue()
self.pickerCollN = CollisionNode('mouseRay')
self.pickerCamN = base.camera.attachNewNode(self.pickerCollN)
self.pickerCollN.setFromCollideMask(BitMask32.bit(1))
self.pickerRay = CollisionRay()
self.pickerCollN.addSolid(self.pickerRay)
base.cTrav.addCollider(self.pickerCamN, self.pickerQ)
self.objectUnderCursor = None
#taskMgr.add(self.mousePickerTask, 'Mouse picker process')
def leftClick(self):
self.mouse1Down = True
#Collision traversal
pickerNode = CollisionNode('mouseRay')
pickerNP = base.camera.attachNewNode(pickerNode)
pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
pickerRay = CollisionRay()
pickerNode.addSolid(pickerRay)
myTraverser = CollisionTraverser()
myHandler = CollisionHandlerQueue()
myTraverser.addCollider(pickerNP, myHandler)
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
myTraverser.traverse(render)
# Assume for simplicity's sake that myHandler is a CollisionHandlerQueue.
if myHandler.getNumEntries() > 0:
# This is so we get the closest object
myHandler.sortEntries()
pickedObj = myHandler.getEntry(0).getIntoNodePath()
objTag = pickedObj.findNetTag('mouseCollisionTag').getTag('mouseCollisionTag')
if objTag and len(objTag)>0:
messenger.send('object_click',[objTag])
pickerNP.remove()
def leftClickUp(self):
self.mouse1Down = False
def mClick(self):
self.mouse2Down = True
def mClickUp(self):
self.mouse2Down = False
def rightClick(self):
self.mouse3Down = True
def rightClickUp(self):
self.mouse3Down = False
def trackMouseTask(self, task):
timeElapsed = task.time - self.trackMouseTimeOld
if timeElapsed < 0.05:
return Task.cont
self.trackMouseTimeOld = task.time
if base.mouseWatcherNode.hasMouse():
mX = base.mouseWatcherNode.getMouseX()
mY = base.mouseWatcherNode.getMouseY()
diffX = mX-self.trackMouseX
diffY = mY-self.trackMouseY
if (abs(diffX) > DRAG_THRESH) or (abs(diffY) > DRAG_THRESH):
messenger.send('mouseDelta',[diffX,diffY])
self.trackMouseX = mX
self.trackMouseY = mY
if self.trackMouse_Mouse1DownOld and self.mouse1Down:
messenger.send('mouse1Delta',[diffX,diffY])
if self.trackMouse_Mouse2DownOld and self.mouse2Down:
messenger.send('mouse2Delta',[diffX,diffY])
if self.trackMouse_Mouse3DownOld and self.mouse3Down:
messenger.send('mouse3Delta',[diffX,diffY])
self.trackMouse_Mouse1DownOld = self.mouse1Down
self.trackMouse_Mouse2DownOld = self.mouse2Down
self.trackMouse_Mouse3DownOld = self.mouse3Down
return Task.cont
def mousePickerTask(self, task):
print 'lalala: ',self.objectUnderCursor
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
#self.picker.traverse(base.render)
if self.pickerQ.getNumEntries() > 0:
self.pickerQ.sortEntries()
firstNode = self.pickerQ.getEntry(0).getIntoNode()
if firstNode != self.objectUnderCursor:
if self.objectUnderCursor:
messenger.send('interactive-scene-event',[self.objectUnderCursor.getName(),'rollout'])
print 'Rollout', self.objectUnderCursor.getName()
self.objectUnderCursor = firstNode
messenger.send('interactive-scene-event',[self.objectUnderCursor.getName(),'rollin'])
print 'Rollin', self.objectUnderCursor.getName()
else:
if self.objectUnderCursor:
messenger.send('interactive-scene-event',[self.objectUnderCursor.getName(),'rollout'])
print 'Rollout', self.objectUnderCursor.getName()
self.objectUnderCursor = None
return task.cont
class Hero(DirectObject):
def __init__(self,no):
self.HeroStats(no)
self.display()
# self.displaynot()
self.SetupEvents()
self.Collision()
self.Loader()
self.SkillStatus()
self.sec=0
self.min=0
self.heroPace=None
self.timesec = OnscreenText(text = '', pos = (1.2,-0.725),fg=(1,1,1,1),mayChange=1,scale=0.05)
self.timemin = OnscreenText(text = '', pos = (1,-0.725),fg=(1,1,1,1),mayChange=1,scale=0.05)
self.deathtxt=OnscreenText(text="",pos=(0.5,0.9),scale=0.5)
taskMgr.add(self.update,"update")
taskMgr.doMethodLater(1,self.Second,"second")
taskMgr.add(self.MousePos,"mouse")
def HeroStats(self,no):
self.char={}
self.char=hero[no]
self.name=self.char['name']
self.model=Actor(MYDIRMODEL+self.char['model']+'.egg')
self.type=None
self.heroicon=self.char['icon'][0]
self.skillicons=(self.char['icon'][1],self.char['icon'][2],self.char['icon'][3],self.char['icon'][4])
self.StartPos=Point3(25,25,0)
self.gold=4000
self.goldrate = 1
self.items=[-1,-1,-1,-1,-1,-1] #each stores the no of the item
self.itemindex=0
self.itemname="self.itemb"
self.range=self.char['range']
self.strdt=self.char['strdt']
self.agidt=self.char['agidt']
self.intdt=self.char['intdt']
self.type=self.char['type']
self.Delta1=0
self.Delta2=0
self.Delta3=0
self.Delta4=0
self.Delta5=0
self.lvl=0
self.xp=0
self.Input=None
self.str=self.char['str']+(self.strdt*self.lvl)
self.agi=self.char['agi'] + (self.agidt*self.lvl)
self.int=self.char['int'] +(self.intdt*self.lvl)
self.basehp=590+self.str*19
self.basemp=220+(self.int*13)
self.maxhp=590 +(self.str*19)
self.curhp=self.maxhp
self.maxmp=220 +(self.int*13)
self.curmp=self.maxmp
self.armor=self.char['armor'] +(self.agi/7)
self.atkspeed=1.5/self.agi
if self.type=='str':
self.TYPESTR()
if self.type=='agi':
self.TYPEAGI()
if self.type=='int':
self.TYPEINT()
self.healrate=0.003 *self.str
self.mprate=0.02 *self.int
self.res=0.25
self.speed=self.char['speed']
self.skill=0
self.isDead=False
self.lon=pi*(self.getX()+10)*(self.getY()+10)
def Loader(self):
self.model=Actor("models/ralph", {"run": "models/ralph-run"})
# self.model=Actor(MYDIRMODEL+self.model+'.egg')
self.model.setScale(3)
# self.model.setHpr(90,270,0)
self.model.setTransparency(0.5)
# self.model.setScale(0.1)
self.model.setPos(self.StartPos)
self.model.reparentTo(render)
# self.model.setColor(0, 0, 0, 0)
self.model.loop("run")
# self.Input=Input(self.model)
Flame(self,self.model)
#-------------------------------------------------------------Display Function---------------------------------------------------#
def TYPESTR(self):
self.mindamage=self.char['min']+self.str+self.Delta1
self.maxdamage=self.char['max']+self.str+self.Delta1
self.damage=range(int(self.mindamage),int(self.maxdamage))
def TYPEAGI(self):
self.mindamage=self.char['min']+self.agi+self.Delta1
self.maxdamage=self.char['max']+self.agi+self.Delta1
self.damage=range(int(self.mindamage),int(self.maxdamage))
def TYPEINT(self):
self.mindamage=self.char['min']+self.int+self.Delta1
self.maxdamage=self.char['max']+self.int+self.Delta1
self.damage=range(int(self.mindamage),int(self.maxdamage))
def TYPE(self):
pass
def display(self):
x,y,z=self.model.getX(),self.model.getY(),self.model.getZ()
base.camera.setPos(x,y,z+180)
base.camera.setP(-30)
base.camera.lookAt(self.model)
self.panel=aspect2d.attachNewNode("panel")
self.panel.setTransparency(1)
self.SKNode=aspect2d.attachNewNode("skl")
self.SKNode.setTransparency(0)
self.HP=DirectLabel(text='',parent = self.panel,text_fg=(0,0.9,0,1),frameColor=(0,0,0,0),pos=(-0.41,0,-0.850),scale=0.04)
self.MP=DirectLabel(text='',parent = self.panel,text_fg=(0,0,0.8,1),frameColor=(0,0,0,0),pos=(-0.41,0,-0.912),scale=0.04)
self.LVL=DirectLabel(text ="Level %d"%(self.lvl+1),parent = self.panel,text_fg=(0,0,0,1),frameColor=(0,0,0,0),pos =(-0.5,0,-0.79),scale=Sc)
Text1(self,"Damage",-0.26,-0.02,-1)
Text1(self,"Armor",-0.27,0.03,-1)
Text1(self,"Str",-0.25,0.085,-1)
Text1(self,"Agi",-0.25,0.13,-1)
Text1(self,"Int",-0.25,0.17,-1)
self.DAM=Text2(self,"%d-%d",(self.mindamage-self.Delta1,self.maxdamage-self.Delta1),-0.40,-0.02,-1)
self.ARM=Text2(self,"%d",(self.armor-self.Delta2),-0.40,0.03,-1)
self.STR=Text2(self,"%d",(self.str-self.Delta3),-0.40,0.085,-1)
self.AGI=Text2(self,"%d",(self.agi-self.Delta4),-0.40,0.13,-1)
self.INT=Text2(self,"%d",(self.int-self.Delta5),-0.40,0.17,-1)
if self.Delta1!=0:
self.damdelta=Text3(self,"%d",self.Delta1,-0.4,-0.02,-1)
if self.Delta2!=0:
self.armdelta=Text3(self,"%d",self.Delta2,-0.4,0.03,-1)
if self.Delta3!=0:
self.strdelta=Text3(self,"%d",self.Delta3,-0.36,0.085,-1)
if self.Delta4!=0:
self.agidelta=Text3(self,"%d",self.Delta4,-0.44,0.13,-1)
if self.Delta5!=0:
self.intdelta=Text3(self,"%d",self.Delta5,-0.44,0.17,-1)
self.hpbar = DirectWaitBar(barColor=(0,0.176470,0,1),parent = self.panel,scale=(0.3,0,0.23), frameColor=(0,0,0,1),pos = (0,0,-0.84))
self.mpbar=DirectWaitBar(barColor=(0,0,0.6,1),parent = self.panel,scale=(0.3,0,0.23), frameColor=(0,0,0,1),pos = (0,0,-0.90))
self.lvlbar=DirectWaitBar(barColor=(0,0,0.2,1),parent = self.panel,image='glue/lvlbar.png',image_scale=(1.1,0,0.2),scale=0.35, pos = (0,0,-0.8))
self.lvlbar.setTransparency(1)
self.lvlbar.detachNode()
self.skbtn1=DirectButton(image=self.skillicons[0]+'.png',parent=self.SKNode,pos=(posx-1.3,0,posy-1.2),pad=(-0.1,-0.1),scale=biconscale,command=self.SkillNo,extraArgs=[0])
self.skbtn2=DirectButton(image=self.skillicons[1]+'.png',parent=self.SKNode,pos=(posx-1.3+0.14,0,posy-1.2),pad=(-0.1,-0.1),scale=biconscale,command=self.SkillNo,extraArgs=[1])
self.skbtn3=DirectButton(image=self.skillicons[2]+'.png',parent=self.SKNode,pos=(posx-1.3+0.28,0,posy-1.2),pad=(-0.1,-0.1),scale=biconscale,command=self.SkillNo,extraArgs=[2])
self.skbtn4=DirectButton(image=self.skillicons[3]+'.png',parent=self.SKNode,pos=(posx-1.3+0.42,0,posy-1.2),pad=(-0.1,-0.1),scale=biconscale,command=self.SkillNo,extraArgs=[3])
self.b2 = DirectButton(text ="dam",parent = self.panel,pos=(-0.5,0,0),enableEdit=1,scale=(0.25,0,0.1),command=self.hurt,extraArgs=[200])
self.b3 = DirectButton(text ="",image='tome.tga',pos=(0.5,0,0),frameColor=(0,0,0,0),pad=(-0.1,-0.1),enableEdit=1,scale=(0.07,0,0.07),command=self.itemBuy,extraArgs=[0,300])
self.GOLD=OnscreenText(text='',fg=(1,1,1,1),pos=(1.225,-0.84),scale=0.05)
# self.escapeEvent = OnscreenText(text=HELPTEXT, font = font,style=1, fg=(1,1,1,1), pos=(-0.82, -0.725),align=TextNode.ALeft, scale = .045)
def displaynot(self):
self.panel.detachNode()
self.SKNode.detachNode()
#------------------------------------------------------------Set Functions--------------------------------------------------------#
def setDamage(self,amt):
if delta >1:
self.damage+=delta
else:
self.damage=self.damage+self.damage*delta
def Delta(self,amt1,amt2,amt3,amt4,amt5):
if amt1!=0: #After changes occur for that period the taks sets the values to zero
self.Delta1+=amt1
if amt2!=0:
self.Delta2+=amt2
if amt3!=0:
self.Delta3+=amt3
if amt4!=0:
self.Delta4+=amt3
if amt5!=0:
self.Delta5+=amt3
def hurt(self,amt):
if self.curhp>0:
if self.curhp<=self.maxhp:
self.curhp-=amt*1
def hurtMag(self,delta):
if self.curhp>0:
if self.curhp<=self.maxhp:
self.curhp-=delta*self.res
def heal(self,delta):
if self.curhp!=self.maxhp:
if self.curhp < self.maxhp:
self.curhp+=delta
def replenish(self,delta):
if self.curmp!=self.maxmp:
if self.curmp < self.maxmp:
if self.curmp>0:
self.curmp+=delta
def manaspend(self,amt):
if self.curmp>amt:
self.curmp-=amt
def setSpeed(self,delta):
if delta > 1:
self.speed+=delta
else:
self.speed=self.speed+self.speed*delta
def setArmor(self,delta):
self.armor+=delta
def setPos(self,x,y,z):
self.model.setPos(x,y,z)
def setHPColor(self):
if self.curhp<0.25*self.maxhp:
self.hpbar['barColor']=(1,0,0,1)
elif self.curhp<0.5*self.maxhp:
self.hpbar['barColor']=(1,0.5,0,1)
elif self.curhp<0.75*self.maxhp:
self.hpbar['barColor']=(1,1,0,1)
else:
self.hpbar['barColor']=(0,0.176470,0,1)
#-------------------------------------------------------------Setup Keys And EVENTS--------------------------------------------------#
def SetupEvents(self):
self.dt=0
self.keyMap = {"left":0, "right":0, "forward":0}
self.isMoving = False
self.Change=False
self.Animate=False
self.pos3d=None
self.target=Point3()
self.dist=0
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
self.Text = OnscreenText(text="Set PanRate",pos=(-1.25,-0.15),scale=0.1)
self.slider = DirectSlider(range=(20,100), value=50, pageSize=2, pos=(-1.25,0,-0.2),scale= (0.2,0.2,0.2), command=self.setScrollSpeed)
self.dumm=loader.loadModel("models/panda.egg")
self.dumm.reparentTo(render)
self.dumm.setTag("Unit",'1')
self.dumm.setPos(0,0,0)
self.mini=0
self.x1,self.y1=self.model.getX(),self.model.getY()
self.x2,self.y2=self.dumm.getX(),self.dumm.getY()
self.fired=False
self.atk=Attack(self.model,self.dumm,1.4)
self.accept("arrow_left", self.setKey1, ["left",1,True])
self.accept("arrow_right", self.setKey1, ["right",1,True])
self.accept("arrow_up", self.setKey1, ["forward",1,True])
self.accept("arrow_left-up", self.setKey1, ["left",0,False])
self.accept("arrow_right-up", self.setKey1, ["right",0,False])
self.accept("arrow_up-up", self.setKey1, ["forward",0,False])
self.accept("mouse1",self.ObjectClick)
self.accept("mouse3",self.MoveHero)
def MoveHero(self):
self.startR=self.model.getHpr()
self.target=self.mpos3d
x2,y2,z2=self.target.getX(),self.target.getY(),self.target.getZ()
h1,p1,r1=self.model.getH(),self.model.getP(),self.model.getR()
self.dist=sqrt(pow(self.x1-x2,2)+pow(self.y1-y2,2))
self.sptime=self.dist/(self.speed)
self.hall=270-degrees(y2/x2)
# self.model.setPos(self.model,self.spd,0,self.spd)
self.Inter=LerpPosHprInterval(self.model,self.sptime,pos=self.target ,startPos=self.model.getPos(),startHpr=self.startR,hpr=self.startR)#(h1,p1,self.hall))
#Inter2=Func(self.model.lookAt(self.target),Wait(0.3))
self.heroPace = Sequence(self.Inter,name="heroPace")
self.heroPace.start()
def Collision(self):
self.mpos3d=0
self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, 0))
base.cTrav = CollisionTraverser()
self.collHandler = CollisionHandlerQueue()
self.pickerNode = CollisionNode('mouseRay')
self.pickerNP = camera.attachNewNode(self.pickerNode)
self.pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
base.cTrav.addCollider(self.pickerNP, self.collHandler)
def ObjectClick(self):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
base.cTrav.traverse(render) # Assume for simplicity's sake that myHandler is a CollisionHandlerQueue.
if self.collHandler.getNumEntries() > 0: # This is so we get the closest object.
self.collHandler.sortEntries()
self.pickedObj = self.collHandler.getEntry(0).getIntoNodePath()
self.pickedObj = self.pickedObj.findNetTag('Unit')
if not self.pickedObj.isEmpty():
self.Attack(self.pickedObj.getPos())
#Handles the object
def setKey1(self, key, value,value2):
self.keyMap[key] = value
self.Change=value2
def checkKeys(self):
if (self.keyMap["left"]!=0):
self.model.setH(self.model.getH() + self.dt*300)
if (self.keyMap["right"]!=0):
self.model.setH(self.model.getH() - self.dt*300)
if (self.keyMap["forward"]!=0):
self.model.setX(self.model, +(self.dt*25*SPEED))
def checkAnim(self):
if self.Change: #(self.keyMap["forward"]!=0) or (self.keyMap["left"]!=0) or (self.keyMap["right"]!=0):
if self.isMoving is False:
self.model.loop("run")
self.isMoving = True
else:
if self.isMoving:
self.model.stop()
self.model.pose("walk",5)
self.isMoving = False
if self.Animate:
pass
def Attack(self,pos):
self.atk.setWeil(self.model)
self.atk.setTarg(self.dumm)
self.atk.setDist(self.mini)
if self.mini<=60:
self.Animate=self.atk.ATT()
else:
messenger.send('mouse3')
if self.mini<=60:
self.atk.ATT()
def setScrollSpeed(self):
SCROLLSPEED=self.slider['value']
def UnSetupEvents(self):
self.ignore("arrow_left")
self.ignore("arrow_right")
self.ignore("arrow_up")
self.ignore("arrow_left-up")
self.ignore("arrow_right-up")
self.ignore("arrow_up-up")
self.ignore("enter")
self.ignore("mouse1")
self.ignore("mouse3")
taskMgr.remove("update")
taskMgr.remove("second")
taskMgr.remove("mouse")
#--------------------------------------------------------------Return Functions------------------------------------------------------#
def getDamage(self):
return self.damage
def getPos(self):
return self.model.getPos()
def getX(self):
return self.model.getX()
def getY(self):
return self.model.getY()
def getZ(self):
return self.model.getZ()
def getlvl(self):
return self.lvl
def getModel(self):
return self.model
def gainxp(self,unit):
self.xp+=unit
def gainGold(self,gain):
self.gold+=gain
def sendTime(self,min,sec):
self.min=min
self.sec=sec
#----------------------------------------------------------------ITEM FUNCTIONS--------------------------------------------------------#
def itemBuy(self,arg,cost):
if self.gold>=0:
if self.itemindex<=5:
del self.items[self.itemindex]
self.items.insert(self.itemindex,arg)
self.gainGold(-cost)
if self.items[self.itemindex]!=-1:
if self.itemindex==0:
self.itm0= aspect2d.attachNewNode("item0")
DirectButton(text ="",parent=self.itm0,image='tome.tga',pos=(0+0.12*self.itemindex,0,-0.90),pad=(-0.1,-0.1),scale=(0.05,0,0.05),extraArgs=[arg,cost],command=self.itemSold)#,commandButtons=DGG.RMB)
if self.itemindex==1:
self.itm1= aspect2d.attachNewNode("item1")
DirectButton(text ="",parent=self.itm1,image='tome.tga',pos=(0+0.12*self.itemindex,0,-0.90),pad=(-0.1,-0.1),scale=(0.05,0,0.05),extraArgs=[arg,cost],command=self.itemSold)#,commandButtons=DGG.RMB)
if self.itemindex==2:
self.itm2= aspect2d.attachNewNode("item2")
DirectButton(text ="",parent=self.itm2,image='tome.tga',pos=(0+0.12*self.itemindex,0,-0.90),pad=(-0.1,-0.1),scale=(0.05,0,0.05),extraArgs=[arg,cost],command=self.itemSold)#,commandButtons=DGG.RMB)
if self.itemindex==3:
self.itm3= aspect2d.attachNewNode("item3")
DirectButton(text ="",parent=self.itm3,image='tome.tga',pos=(0+0.12*self.itemindex,0,-0.90),pad=(-0.1,-0.1),scale=(0.05,0,0.05),extraArgs=[arg,cost],command=self.itemSold)#,commandButtons=DGG.RMB)
if self.itemindex==4:
self.itm4= aspect2d.attachNewNode("item4")
DirectButton(text ="",parent=self.itm4,image='tome.tga',pos=(0+0.12*self.itemindex,0,-0.90),pad=(-0.1,-0.1),scale=(0.05,0,0.05),extraArgs=[arg,cost],command=self.itemSold)#,commandButtons=DGG.RMB)
if self.itemindex==5:
self.itm5= aspect2d.attachNewNode("item5")
DirectButton(text ="",parent=self.itm5,image='tome.tga',pos=(0+0.12*self.itemindex,0,-0.90),pad=(-0.1,-0.1),scale=(0.05,0,0.05),extraArgs=[arg,cost],command=self.itemSold)#,commandButtons=DGG.RMB)
self.itemindex+=1
else:
Error("No Empty Slots")
else:
Error("No Gold")
def itemSold(self,itemtosell,cost):
self.ind=self.items.index(itemtosell)
del self.items[self.ind]
self.items.insert(self.ind,-1)
self.gainGold(cost/2)
if self.ind==0:
self.itm0.detachNode()
if self.ind==1:
self.itm1.detachNode()
if self.ind==2:
self.itm2.detachNode()
if self.ind==3:
self.itm3.detachNode()
if self.ind==4:
self.itm4.detachNode()
if self.ind==5:
self.itm5.detachNode()
self.itemindex-=1
def lvlup(self):
self.lvl+=1
self.str=self.char['str'] +(self.strdt*self.lvl)
self.str=self.char['str'] +(self.agidt*self.lvl)
self.int=self.char['int'] +(self.intdt*self.lvl)
self.hpgain=(self.strdt+self.Delta1)*19
self.mpgain=(self.intdt+self.Delta3)*13
self.maxhp=590+self.str*19
self.maxmp=290+self.int*13 #some error here
self.heal(self.hpgain)
self.replenish(self.mpgain)
self.xp =0
#---------------------------------------------------------SKILL FUNCTIONS-------------------------------------#
def SkillStatus(self):
self.sp1=0
self.sp2=0
self.sp3=0
self.sp4=0
self.sp1dam=0
self.sp2dam=0
self.sp3dam=0
self.sp4dam=0
if self.sp1==1:
self.range=400
self.sp1dam=130
self.raduis=100
self.sp2dam=30
self.sp3dam=90
self.pulses=6
def SkillNo(self,arg):
if arg==0:
if self.curmp>=100:
self.accept("mouse1",Blink,extraArgs=[self])
self.skbtn1['image']='cancel.png'
# self.skbtn1['command']=self.setOpen()
else:
Error("NO MANA")
elif arg==1:
StatUp(self)
elif arg==2:
StatDn(self)
else:
Ulti(self)
def setOpen(self):
self.open=False
self.ignore("mouse1")
self.skbtn1['image']=self.skillicons[0]+'.png'
self.accept("mouse1",self.ObjectClick)
#----------------------------------------TASK FUNCTIONS------------------------------------------------------#
def Delay(self,task):
self.Delta(-2,-2,-2)
return task.done
def Second(self,task):
self.gainGold(self.goldrate)
self.heal(self.healrate)
self.replenish(self.mprate)
return task.again
def update(self,task):
self.timemin.setText(str(self.min))
self.timesec.setText(str(self.sec))
self.str=self.char['str'] +(self.strdt*self.lvl)+self.Delta3
self.agi=self.char['agi'] + (self.agidt*self.lvl)+self.Delta4
self.int=self.char['int']+(self.intdt*self.lvl)+self.Delta5
self.hpgain=(self.strdt+self.Delta1)*19
self.mpgain=(self.intdt+self.Delta3)*13
self.maxhp=590+self.str*19
self.maxmp=290+self.int*13 #some error here
# self.heal(self.hpgain)
# self.replenish(self.mpgain)
self.armor=self.char['armor'] +(self.agi/7)+self.Delta2
self.atkspeed=1.5/self.agi
if self.type=='str':
self.TYPESTR()
if self.type=='agi':
self.TYPEAGI()
if self.type=='int':
self.TYPEINT()
self.healrate=0.03 *self.str
self.mprate=0.02 *self.int
self.GOLD.setText(str(self.gold))
self.hpbar['range']=int(self.maxhp)
self.hpbar['value']=int(self.curhp)
self.mpbar['range']=int(self.maxmp)
self.mpbar['value']=int(self.curmp)
self.lvlbar['range']=int(10*self.lvl)
self.lvlbar['value']=int(self.xp)
self.HP['text']="HP"+str(int(self.curhp))+"/"+str(int(self.maxhp))
self.MP['text']="MP"+str(int(self.curmp))+"/"+str(int(self.maxmp))
self.DAM['text']=str(int(self.mindamage))+'-'+str(int(self.maxdamage))
self.ARM['text']=str(int(self.armor))
self.STR['text']=str(int(self.str))
self.AGI['text']=str(int(self.agi))
self.INT['text']=str(int(self.int))
self.LVL['text']="LEVEL "+str(int(self.lvl))
if self.xp>=20*20:
self.lvlup()
if self.curhp<=0:
taskMgr.add(self.Death,"death")
self.x1,self.y1=self.model.getX(),self.model.getY()
self.x2,self.y2=self.dumm.getX(),self.dumm.getY()
self.mini=sqrt(pow(self.x1-self.x2,2)+pow(self.y1-self.y2,2))
Debug2(self,str(self.mini))
elapsed = globalClock.getDt()
self.dt=elapsed
self.setHPColor()
self.checkAnim()
self.checkKeys()
# base.camera.lookAt(self.model)
# self.floater.setPos(self.model.getPos())
# base.camera.lookAt(self.floater)
return task.cont
def Death(self,task):
self.isDead=True
Debug2(self,str(task.time))
if self.isDead==True:
self.model.reparentTo(hidden)
self.panel.detachNode()
self.deathtime=(self.lvl+1)*3
self.isDead=False
if int(task.time)==self.deathtime:
self.model.setPos(self.StartPos)
self.model.reparentTo(render)
self.curhp=self.maxhp
self.model.loop("walk")
self.display()
taskMgr.remove("death")
# self.deathtxt.destroy()
return task.cont
def MousePos(self, task): #This Took me 1.5 Months to Learn
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.mpos3d = Point3()
nearPoint = Point3()
farPoint = Point3()
base.camLens.extrude(mpos, nearPoint, farPoint)
if self.plane.intersectsLine(self.mpos3d, render.getRelativePoint(camera, nearPoint),render.getRelativePoint(camera, farPoint)):
pass
return task.again
def destroy(self):
self.panel.detachNode()
self.t1.destroy()
self.t2.destroy()
self.model.remove()
self.timesec.destroy()
self.timemin.destroy()
self.UnsetupEvents()
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")
class MouseControls(DirectObject.DirectObject):
def __init__(self):
self.keys = {}
for char in string.ascii_lowercase:
self.keys[char] = BUTTON_UP
def makeKeyPair(ch):
def keyUp():
self.keys[ch] = BUTTON_DOWN
#print "%s UP" % (ch)
def keyDown():
self.keys[ch] = BUTTON_UP
#print "%s DOWN" % (ch)
return [keyUp, keyDown]
keyPair = makeKeyPair(char)
self.accept(char, keyPair[0])
self.accept(char + '-up', keyPair[1])
self.accept('mouse1', self.leftClick)
self.accept('mouse1-up', self.leftClickUp)
self.accept('mouse2', self.mClick)
self.accept('mouse2-up', self.mClickUp)
self.accept('mouse3', self.rightClick)
self.accept('mouse3-up', self.rightClickUp)
self.mouse1Down = False
self.mouse2Down = False
self.mouse3Down = False
self.trackMouseTimeOld = 0
self.trackMouseX = 0
self.trackMouseY = 0
self.trackMouse_Mouse1DownOld = False
self.trackMouse_Mouse2DownOld = False
self.trackMouse_Mouse3DownOld = False
taskMgr.add(self.trackMouseTask, 'trackMouseTask')
#
base.cTrav = CollisionTraverser()
self.pickerQ = CollisionHandlerQueue()
self.pickerCollN = CollisionNode('mouseRay')
self.pickerCamN = base.camera.attachNewNode(self.pickerCollN)
self.pickerCollN.setFromCollideMask(BitMask32.bit(1))
self.pickerRay = CollisionRay()
self.pickerCollN.addSolid(self.pickerRay)
base.cTrav.addCollider(self.pickerCamN, self.pickerQ)
self.objectUnderCursor = None
#taskMgr.add(self.mousePickerTask, 'Mouse picker process')
def leftClick(self):
self.mouse1Down = True
#Collision traversal
pickerNode = CollisionNode('mouseRay')
pickerNP = base.camera.attachNewNode(pickerNode)
pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
pickerRay = CollisionRay()
pickerNode.addSolid(pickerRay)
myTraverser = CollisionTraverser()
myHandler = CollisionHandlerQueue()
myTraverser.addCollider(pickerNP, myHandler)
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
myTraverser.traverse(render)
# Assume for simplicity's sake that myHandler is a CollisionHandlerQueue.
if myHandler.getNumEntries() > 0:
# This is so we get the closest object
myHandler.sortEntries()
pickedObj = myHandler.getEntry(0).getIntoNodePath()
objTag = pickedObj.findNetTag('mouseCollisionTag').getTag(
'mouseCollisionTag')
if objTag and len(objTag) > 0:
messenger.send('object_click', [objTag])
pickerNP.remove()
def leftClickUp(self):
self.mouse1Down = False
def mClick(self):
self.mouse2Down = True
def mClickUp(self):
self.mouse2Down = False
def rightClick(self):
self.mouse3Down = True
def rightClickUp(self):
self.mouse3Down = False
def trackMouseTask(self, task):
timeElapsed = task.time - self.trackMouseTimeOld
if timeElapsed < 0.05:
return Task.cont
self.trackMouseTimeOld = task.time
if base.mouseWatcherNode.hasMouse():
mX = base.mouseWatcherNode.getMouseX()
mY = base.mouseWatcherNode.getMouseY()
diffX = mX - self.trackMouseX
diffY = mY - self.trackMouseY
if (abs(diffX) > DRAG_THRESH) or (abs(diffY) > DRAG_THRESH):
messenger.send('mouseDelta', [diffX, diffY])
self.trackMouseX = mX
self.trackMouseY = mY
if self.trackMouse_Mouse1DownOld and self.mouse1Down:
messenger.send('mouse1Delta', [diffX, diffY])
if self.trackMouse_Mouse2DownOld and self.mouse2Down:
messenger.send('mouse2Delta', [diffX, diffY])
if self.trackMouse_Mouse3DownOld and self.mouse3Down:
messenger.send('mouse3Delta', [diffX, diffY])
self.trackMouse_Mouse1DownOld = self.mouse1Down
self.trackMouse_Mouse2DownOld = self.mouse2Down
self.trackMouse_Mouse3DownOld = self.mouse3Down
return Task.cont
def mousePickerTask(self, task):
print 'lalala: ', self.objectUnderCursor
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
#self.picker.traverse(base.render)
if self.pickerQ.getNumEntries() > 0:
self.pickerQ.sortEntries()
firstNode = self.pickerQ.getEntry(0).getIntoNode()
if firstNode != self.objectUnderCursor:
if self.objectUnderCursor:
messenger.send(
'interactive-scene-event',
[self.objectUnderCursor.getName(), 'rollout'])
print 'Rollout', self.objectUnderCursor.getName()
self.objectUnderCursor = firstNode
messenger.send(
'interactive-scene-event',
[self.objectUnderCursor.getName(), 'rollin'])
print 'Rollin', self.objectUnderCursor.getName()
else:
if self.objectUnderCursor:
messenger.send(
'interactive-scene-event',
[self.objectUnderCursor.getName(), 'rollout'])
print 'Rollout', self.objectUnderCursor.getName()
self.objectUnderCursor = None
return task.cont
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
class NodeRaycaster:
def __init__(self, renderer):
self.log = logging.getLogger('pano.raycaster')
self.renderer = renderer
#Stores the collisions of the camera ray with the cubemap
self.collisionsQueue = None
#Variables for setting up collision detection in Panda
self.pickerNP = None
self.pickerNode = None
self.pickerRay = None
self.traverser = None
def initialize(self):
"""
To setup collision detection we need:
a. A CollisionNode having a ray as its solid and placed at the position
of the camera while also having the same orientation as the camera.
b. A new nodepath placed in the scenegraph as an immediate child of the
camera. It will be used to insert the collision node in the scenegraph.
c. A CollisionRay for firing rays based on mouse clicks.
d. A collisions traverser.
e. A collisions queue where all found collisions will be stored for later
processing.
"""
self.traverser = CollisionTraverser('Hotspots collision traverser')
self.collisionsQueue = CollisionHandlerQueue()
self.pickerNode = CollisionNode('mouseRay')
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
self.pickerNP = self.renderer.getCamera().attachNewNode(
self.pickerNode)
self.traverser.addCollider(self.pickerNP, self.collisionsQueue)
def dispose(self):
if self.pickerNP is not None:
self.traverser.removeCollider(self.pickerNP)
self.pickerNode.clearSolids()
self.pickerNP.removeNode()
def raycastWindow(self, x, y, returnAll=False):
'''
Casts a camera ray, whose origin is implicitly defined by the given window coordinates, against
the rendered scene returns information regarding the hit point, if any.
@param x: The x window coordinate of the ray's origin in render2d space.
@param y: The y window coordinate of the ray's origin in render2d space
@param returnAll: If set to False then only the closest collided geometry is returned, otherwise
all nodepaths whose collision nodes were intersected by the camera ray will be returned.
@return:
If returnAll was False, then a list containing a tuple of the form (topmost intersected NodePath, contact point Point3f).
if returnAll was set to True, a list of tuples in the same form as above, one tuple for each intersection.
None if no collision occurred.
'''
#This makes the ray's origin the camera and makes the ray point
#to the screen coordinates of the mouse
self.pickerRay.setFromLens(self.renderer.getCamera().node(), x, y)
#Check for collision only with the node
self.traverser.traverse(self.renderer.getSceneRoot())
if self.collisionsQueue.getNumEntries() > 0:
if not returnAll:
self.collisionsQueue.sortEntries()
cEntry = self.collisionsQueue.getEntry(0)
if cEntry.hasInto():
return [(cEntry.getIntoNodePath(),
cEntry.getSurfacePoint())]
else:
return None
else:
nodepaths = []
for i in xrange(self.collisionsQueue.getNumEntries()):
cEntry = self.collisionsQueue.getEntry(i)
if cEntry.hasInto():
# self.log.debug('adding collision into-nodepath: %s' % str(cEntry.getIntoNodePath()))
intoNP = cEntry.getIntoNodePath()
nodepaths.append(
(intoNP, cEntry.getSurfacePoint(intoNP)))
return nodepaths
class CameraHandler(DirectObject.DirectObject):
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')
# sets the camMoveTask to be run every frame
##########
def rayupdate(self, task):
if base.mouseWatcherNode.hasMouse():
self.entry=0
self.collisionHandler2.sortEntries()
if self.collisionHandler2.getNumEntries()>0:
self.entry=self.collisionHandler2.getEntry(0)
mpos=base.mouseWatcherNode.getMouse()
# this function will set our ray to shoot from the actual camera lenses off the 3d scene, passing by the mouse pointer position,
# making magically hit what is pointed by it in the 3d space
self.pickerRay.setFromLens(base.camNode, mpos.getX(),mpos.getY())
return task.cont
def mineWall(self, parserClass, modelLoaderClass, mapLoaderClass, mainClass):
if (self.tileSelected != (0,0)):
mainClass.mineWall(mapLoaderClass.tileArray[self.tileSelected[1]][self.tileSelected[0]], parserClass, modelLoaderClass, mapLoaderClass)
def mouseClick(self, mapLoaderClass):
if (self.entry!=0):
x = int(self.entry.getIntoNode().getName()[len(self.entry.getIntoNode().getName())-6:len(self.entry.getIntoNode().getName())-4])
y = int(self.entry.getIntoNode().getName()[len(self.entry.getIntoNode().getName())-2:])
if (mapLoaderClass.tileArray[y][x].selectable == True):
mapLoaderClass.tileArray[self.tileSelected[1]][self.tileSelected[0]].model.setColor(1,1,1,1)
mapLoaderClass.tileArray[y][x].model.setColor(0.5,1,0.5,1)
self.tileSelected = (x, y)
else:
mapLoaderClass.tileArray[self.tileSelected[1]][self.tileSelected[0]].model.setColor(1,1,1,1)
self.tileSelected = (0,0)
# print self.tileSelected
def turnCameraAroundPoint(self, deltaX, deltaY):
# This function performs two important tasks. First, it is used for the camera orbital movement that occurs when the
# right mouse button is held down. It is also called with 0s for the rotation inputs to reposition the camera during the
# panning and zooming movements.
# The delta inputs represent the change in rotation of the camera, which is also used to determine how far the camera
# actually moves along the orbit.
newCamHpr = Vec3()
newCamPos = Vec3()
# Creates temporary containers for the new rotation and position values of the camera.
camHpr=base.camera.getHpr()
# Creates a container for the current HPR of the camera and stores those values.
newCamHpr.setX(camHpr.getX()+deltaX)
newCamHpr.setY(self.clamp(camHpr.getY()-deltaY, -85, -10))
newCamHpr.setZ(camHpr.getZ())
# Adjusts the newCamHpr values according to the inputs given to the function. The Y value is clamped to prevent
# the camera from orbiting beneath the ground plane and to prevent it from reaching the apex of the orbit, which
# can cause a disturbing fast-rotation glitch.
base.camera.setHpr(newCamHpr)
# Sets the camera's rotation to the new values.
angleradiansX = newCamHpr.getX() * (math.pi / 180.0)
angleradiansY = newCamHpr.getY() * (math.pi / 180.0)
# Generates values to be used in the math that will calculate the new position of the camera.
newCamPos.setX(self.camDist*math.sin(angleradiansX)*math.cos(angleradiansY)+self.target.getX())
newCamPos.setY(-self.camDist*math.cos(angleradiansX)*math.cos(angleradiansY)+self.target.getY())
newCamPos.setZ(-self.camDist*math.sin(angleradiansY)+self.target.getZ())
base.camera.setPos(newCamPos.getX(),newCamPos.getY(),newCamPos.getZ())
# print (newCamPos.getX(),newCamPos.getY(),newCamPos.getZ())
# Performs the actual math to calculate the camera's new position and sets the camera to that position.
#Unfortunately, this math is over my head, so I can't fully explain it.
base.camera.lookAt(self.target.getX(),self.target.getY(),self.target.getZ() )
# Points the camera at the target location.
def setTarget(self, x, y, z):
#This function is used to give the camera a new target position.
x = self.clamp(x, self.panLimitsX.getX(), self.panLimitsX.getY())
self.target.setX(x)
y = self.clamp(y, self.panLimitsY.getX(), self.panLimitsY.getY())
self.target.setY(y)
self.target.setZ(z)
# Stores the new target position values in the target variable. The x and y values are clamped to the pan limits.
def setPanLimits(self, xMin, xMax, yMin, yMax):
# This function is used to set the limitations of the panning movement.
self.panLimitsX = (xMin, xMax)
self.panLimitsY = (yMin, yMax)
# Sets the inputs into the limit variables.
def clamp(self, val, minVal, maxVal):
# This function constrains a value such that it is always within or equal to the minimum and maximum bounds.
val = min( max(val, minVal), maxVal)
# This line first finds the larger of the val or the minVal, and then compares that to the maxVal, taking the smaller. This ensures
# that the result you get will be the maxVal if val is higher than it, the minVal if val is lower than it, or the val itself if it's
# between the two.
return val
# returns the clamped value
def startOrbit(self):
# This function puts the camera into orbiting mode.
self.orbiting=True
# Sets the orbiting variable to true to designate orbiting mode as on.
def stopOrbit(self):
# This function takes the camera out of orbiting mode.
self.orbiting=False
# Sets the orbiting variable to false to designate orbiting mode as off.
def adjustCamDist(self, distFactor):
# This function increases or decreases the distance between the camera and the target position to simulate zooming in and out.
# The distFactor input controls the amount of camera movement.
# For example, inputing 0.9 will set the camera to 90% of it's previous distance.
self.camDist=self.camDist*distFactor
if (self.camDist >= self.zoomMax):
self.camDist = self.zoomMax
elif (self.camDist <= self.zoomMin):
self.camDist = self.zoomMin
# Sets the new distance into self.camDist.
self.turnCameraAroundPoint(0,0)
# Calls turnCameraAroundPoint with 0s for the rotation to reset the camera to the new position.
def camMoveTask(self, task):
# This task is the camera handler's work house. It's set to be called every frame and will control both orbiting and panning the camera.
if base.mouseWatcherNode.hasMouse():
# We're going to use the mouse, so we have to make sure it's in the game window. If it's not and we try to use it, we'll get
# a crash error.
mpos = base.mouseWatcherNode.getMouse()
# Gets the mouse position
if self.orbiting:
# Checks to see if the camera is in orbiting mode. Orbiting mode overrides panning, because it would be problematic if, while
# orbiting the camera the mouse came close to the screen edge and started panning the camera at the same time.
self.turnCameraAroundPoint((self.mx-mpos.getX())*100,(self.my-mpos.getY())*100)
# calculates new values for camera rotation based on the change in mouse position. mx and my are used here as the old
# mouse position.
else:
# If the camera isn't in orbiting mode, we check to see if the mouse is close enough to the edge of the screen to start panning
moveY=False
moveX=False
# these two booleans are used to denote if the camera needs to pan. X and Y refer to the mouse position that causes the
# panning. X is the left or right edge of the screen, Y is the top or bottom.
if self.my > (1 - self.panZoneSize):
angleradiansX1 = base.camera.getH() * (math.pi / 180.0)
panRate1 = (1 - self.my - self.panZoneSize) * (self.camDist / self.panRateDivisor) * 2
moveY = True
if self.my < (-1 + self.panZoneSize):
angleradiansX1 = base.camera.getH() * (math.pi / 180.0)+math.pi
panRate1 = (1 + self.my - self.panZoneSize)*(self.camDist / self.panRateDivisor)
moveY = True
if self.mx > (1 - self.panZoneSize):
angleradiansX2 = base.camera.getH() * (math.pi / 180.0)+math.pi*0.5
panRate2 = (1 - self.mx - self.panZoneSize) * (self.camDist / self.panRateDivisor) * 2
moveX = True
if self.mx < (-1 + self.panZoneSize):
angleradiansX2 = base.camera.getH() * (math.pi / 180.0)-math.pi*0.5
panRate2 = (1 + self.mx - self.panZoneSize) * (self.camDist / self.panRateDivisor)
moveX = True
# These four blocks check to see if the mouse cursor is close enough to the edge of the screen to start panning and then
# perform part of the math necessary to find the new camera position. Once again, the math is a bit above my head, so
# I can't properly explain it. These blocks also set the move booleans to true so that the next lines will move the camera.
if moveY:
tempX = self.target.getX()+math.sin(angleradiansX1)*panRate1
tempX = self.clamp(tempX, self.panLimitsX.getX(), self.panLimitsX.getY())
self.target.setX(tempX)
tempY = self.target.getY()-math.cos(angleradiansX1)*panRate1
tempY = self.clamp(tempY, self.panLimitsY.getX(), self.panLimitsY.getY())
self.target.setY(tempY)
self.turnCameraAroundPoint(0,0)
if moveX:
tempX = self.target.getX()-math.sin(angleradiansX2)*panRate2
tempX = self.clamp(tempX, self.panLimitsX.getX(), self.panLimitsX.getY())
self.target.setX(tempX)
tempY = self.target.getY()+math.cos(angleradiansX2)*panRate2
tempY = self.clamp(tempY, self.panLimitsY.getX(), self.panLimitsY.getY())
self.target.setY(tempY)
self.turnCameraAroundPoint(0,0)
# These two blocks finalize the math necessary to find the new camera position and apply the transformation to the
# camera's TARGET. Then turnCameraAroundPoint is called with 0s for rotation, and it resets the camera position based
# on the position of the target. The x and y values are clamped to the pan limits before they are applied.
# print(self.target)
self.mx=mpos.getX()
self.my=mpos.getY()
# The old mouse positions are updated to the current mouse position as the final step.
return task.cont
class MousePicker(p3d.SingleTask):
"""
Class to represent a ray fired from the input camera lens using the mouse.
"""
def __init__(self, *args, **kwargs):
p3d.SingleTask.__init__(self, *args, **kwargs)
self.fromCollideMask = kwargs.pop('fromCollideMask', None)
self.node = None
self.collEntry = None
# Create collision nodes
self.collTrav = CollisionTraverser()
#self.collTrav.showCollisions( render )
self.collHandler = CollisionHandlerQueue()
self.pickerRay = CollisionRay()
# Create collision ray
pickerNode = CollisionNode(self.name)
pickerNode.addSolid(self.pickerRay)
pickerNode.setIntoCollideMask(BitMask32.allOff())
pickerNp = self.camera.attachNewNode(pickerNode)
self.collTrav.addCollider(pickerNp, self.collHandler)
# Create collision mask for the ray if one is specified
if self.fromCollideMask is not None:
pickerNode.setFromCollideMask(self.fromCollideMask)
# Bind mouse button events
eventNames = ['mouse1', 'control-mouse1', 'mouse1-up']
for eventName in eventNames:
self.accept(eventName, self.FireEvent, [eventName])
def OnUpdate(self, task, x=None, y=None):
# Update the ray's position
if self.mouseWatcherNode.hasMouse():
mp = self.mouseWatcherNode.getMouse()
x, y = mp.getX(), mp.getY()
if x is None or y is None:
return
self.pickerRay.setFromLens(self.camera.node(), x, y)
# Traverse the hierarchy and find collisions
self.collTrav.traverse(self.rootNp)
if self.collHandler.getNumEntries():
# If we have hit something, sort the hits so that the closest is first
self.collHandler.sortEntries()
collEntry = self.collHandler.getEntry(0)
node = collEntry.getIntoNode()
# If this node is different to the last node, send a mouse leave
# event to the last node, and a mouse enter to the new node
if node != self.node:
if self.node is not None:
messenger.send('%s-mouse-leave' % self.node.getName(),
[self.collEntry])
messenger.send('%s-mouse-enter' % node.getName(), [collEntry])
# Send a message containing the node name and the event over name,
# including the collision entry as arguments
messenger.send('%s-mouse-over' % node.getName(), [collEntry])
# Keep these values
self.collEntry = collEntry
self.node = node
elif self.node is not None:
# No collisions, clear the node and send a mouse leave to the last
# node that stored
messenger.send('%s-mouse-leave' % self.node.getName(),
[self.collEntry])
self.node = None
def FireEvent(self, event):
"""
Send a message containing the node name and the event name, including
the collision entry as arguments.
"""
if self.node is not None:
messenger.send('%s-%s' % (self.node.getName(), event),
[self.collEntry])
def GetFirstNodePath(self):
"""
Return the first node in the collision queue if there is one, None
otherwise.
"""
if self.collHandler.getNumEntries():
collEntry = self.collHandler.getEntry(0)
return collEntry.getIntoNodePath()
return None
class MousePicker( p3d.Object ):
"""
Class to represent a ray fired from the input camera lens using the mouse.
"""
def __init__( self, name, camera=None, rootNp=None, fromCollideMask=None, pickTag=None, gizmos=None ):
p3d.Object.__init__( self, name, camera, rootNp )
self.fromCollideMask = fromCollideMask
self.pickTag = pickTag
self.selection = set([])
self.node = None
self.np = None
self.collEntry = None
self.gizmos = gizmos
assert self.gizmos is not None
# Create a marquee
self.marquee = marquee.Marquee( '%sMarquee' % self.name )
# Create collision ray
self.pickerRay = CollisionRay()
# Create collision node
pickerNode = CollisionNode( self.name )
pickerNode.addSolid( self.pickerRay )
pickerNode.setFromCollideMask( self.fromCollideMask )
self.pickerNp = camera.attachNewNode( pickerNode )
#pickerNp.setCollideMask(AXIS_COLLISION_MASK)
self.collHandler = CollisionHandlerQueue()
self.collTrav = CollisionTraverser()
self.collTrav.showCollisions( render )
self.collTrav.addCollider( self.pickerNp, self.collHandler )
# Bind mouse button events
eventNames = ['mouse1', 'control-mouse1', 'mouse1-up']
for eventName in eventNames:
self.accept( eventName, self.FireEvent, [eventName] )
#==
self.selectionCol = None
def FireEvent( self, event ):
# Send a message containing the node name and the event name, including
# the collision entry as arguments
print "FireEvent", event, self.node
if self.node is not None:
print self.np, self.np.getName()
messenger.send( '%s-%s' % ( self.node.getName(), event ), [self.collEntry] )
elif event in ('mouse1', 'control-mouse1'):
self.StartSelection()
elif event == 'mouse1-up':
if self.marquee.started:
self.StopSelection()
def UpdateTask( self, task ):
#self.collTrav.traverse( self.rootNp ) # Traverse the hierarchy and find collisions
self.collTrav.traverse(render) # Traverse the hierarchy and find collisions
if self.collHandler.getNumEntries(): # If we have hit something,
self.collHandler.sortEntries() # sort the hits so that the closest is first
collEntry = self.collHandler.getEntry( 0 )
else:
collEntry = None
self.set_node( collEntry)
# updating the pickerRay
if base.mouseWatcherNode.hasMouse():
mp = base.mouseWatcherNode.getMouse()
self.pickerRay.setFromLens( self.camera.node(), mp.getX(), mp.getY() )
return task.cont
def set_node(self, collEntry):
#==
if collEntry : new_node = collEntry.getIntoNode()
else : new_node = None
#==
if new_node == self.node :
# ultra triky bit, even if the node is th same
# the collision is not and it is used for the picking later on
if collEntry : self.collEntry = collEntry
return
#==
if self.node is not None:
messenger.send( '%s-mouse-leave' % self.node.getName())
self.np.setColorScale( Vec4(1) )
self.node = None
#==
if new_node is not None:
self.collEntry = collEntry
self.node = new_node
#==
self.np = self.collEntry.getIntoNodePath().getParent()
self.np.setColorScale( Vec4(1, 0, 0, 1) )
print self.np , self.np.getName()
messenger.send( '%s-mouse-enter' %self.node.getName(), [collEntry] )
messenger.send( '%s-mouse-over' %self.node.getName(), [collEntry] )
def StartSelection( self, clearSelection=True ):
print "StartSelection"
# Reset selected node colours
if self.selectionCol:
self.selectionCol.replace_nodes([])
#for i in self.selection:
#i.setColorScale( Vec4(1) )
self.marquee.Start()
#==
if clearSelection:
self.selection = set([])
def StopSelection( self ):
print "StopSelection"
# Stop the marquee
self.marquee.Stop()
nodes = set([])
for node in self.rootNp.findAllMatches( '**' ):
if self.marquee.IsPoint3Inside( self.camera, self.rootNp, node.getPos() ):
#if self.pickTag is None or node.getTag( self.pickTag ):
if node.getPythonTag('mesh_view'):
nodes.add( node )
# Add any node which was under the mouse to the selection
if self.collHandler.getNumEntries():
collEntry = self.collHandler.getEntry( 0 )
node = collEntry.getIntoNodePath().getParent()
if node.getPythonTag('mesh_view'):
nodes.add( node )
#nodes.add( node )
self.selection = nodes
#==
if self.selectionCol:
self.selectionCol.replace_nodes(nodes)
#for i in self.selection:
#i.setColorScale( Vec4(1, 0, 0, 1) )
#==
self.gizmos.AttachNodePaths( self.selection )
if self.gizmos.active is not None:
# Refresh the active gizmo so it appears in the right place
self.gizmos.active.Refresh()
