class CogdoFlyingCollisions(GravityWalker):
wantFloorSphere = 0
def __init__(self):
GravityWalker.__init__(self, gravity=0.0)
def initializeCollisions(self,
collisionTraverser,
avatarNodePath,
avatarRadius=1.4,
floorOffset=1.0,
reach=1.0):
self.cHeadSphereNodePath = None
self.cFloorEventSphereNodePath = None
self.setupHeadSphere(avatarNodePath)
self.setupFloorEventSphere(avatarNodePath,
ToontownGlobals.FloorEventBitmask,
avatarRadius)
GravityWalker.initializeCollisions(self, collisionTraverser,
avatarNodePath, avatarRadius,
floorOffset, reach)
return
def setupWallSphere(self, bitmask, avatarRadius):
self.avatarRadius = avatarRadius
cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75,
self.avatarRadius)
cSphereNode = CollisionNode('Flyer.cWallSphereNode')
cSphereNode.addSolid(cSphere)
cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode)
cSphereNode.setFromCollideMask(bitmask)
cSphereNode.setIntoCollideMask(BitMask32.allOff())
if config.GetBool('want-fluid-pusher', 0):
self.pusher = CollisionHandlerFluidPusher()
else:
self.pusher = CollisionHandlerPusher()
self.pusher.addCollider(cSphereNodePath, self.avatarNodePath)
self.cWallSphereNodePath = cSphereNodePath
def setupEventSphere(self, bitmask, avatarRadius):
self.avatarRadius = avatarRadius
cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75,
self.avatarRadius * 1.04)
cSphere.setTangible(0)
cSphereNode = CollisionNode('Flyer.cEventSphereNode')
cSphereNode.addSolid(cSphere)
cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode)
cSphereNode.setFromCollideMask(bitmask)
cSphereNode.setIntoCollideMask(BitMask32.allOff())
self.event = CollisionHandlerEvent()
self.event.addInPattern('enter%in')
self.event.addOutPattern('exit%in')
self.cEventSphereNodePath = cSphereNodePath
def setupRay(self, bitmask, floorOffset, reach):
cRay = CollisionRay(0.0, 0.0, 3.0, 0.0, 0.0, -1.0)
cRayNode = CollisionNode('Flyer.cRayNode')
cRayNode.addSolid(cRay)
self.cRayNodePath = self.avatarNodePath.attachNewNode(cRayNode)
cRayNode.setFromCollideMask(bitmask)
cRayNode.setIntoCollideMask(BitMask32.allOff())
self.lifter = CollisionHandlerGravity()
self.lifter.setLegacyMode(self._legacyLifter)
self.lifter.setGravity(self.getGravity(0))
self.lifter.addInPattern('%fn-enter-%in')
self.lifter.addAgainPattern('%fn-again-%in')
self.lifter.addOutPattern('%fn-exit-%in')
self.lifter.setOffset(floorOffset)
self.lifter.setReach(reach)
self.lifter.addCollider(self.cRayNodePath, self.avatarNodePath)
def setupHeadSphere(self, avatarNodePath):
collSphere = CollisionSphere(0, 0, 0, 1)
collSphere.setTangible(1)
collNode = CollisionNode('Flyer.cHeadCollSphere')
collNode.setFromCollideMask(ToontownGlobals.CeilingBitmask)
collNode.setIntoCollideMask(BitMask32.allOff())
collNode.addSolid(collSphere)
self.cHeadSphereNodePath = avatarNodePath.attachNewNode(collNode)
self.cHeadSphereNodePath.setZ(base.localAvatar.getHeight() + 1.0)
self.headCollisionEvent = CollisionHandlerEvent()
self.headCollisionEvent.addInPattern('%fn-enter-%in')
self.headCollisionEvent.addOutPattern('%fn-exit-%in')
base.cTrav.addCollider(self.cHeadSphereNodePath,
self.headCollisionEvent)
def setupFloorEventSphere(self, avatarNodePath, bitmask, avatarRadius):
cSphere = CollisionSphere(0.0, 0.0, 0.0, 0.75)
cSphereNode = CollisionNode('Flyer.cFloorEventSphere')
cSphereNode.addSolid(cSphere)
cSphereNodePath = avatarNodePath.attachNewNode(cSphereNode)
cSphereNode.setFromCollideMask(bitmask)
cSphereNode.setIntoCollideMask(BitMask32.allOff())
self.floorCollisionEvent = CollisionHandlerEvent()
self.floorCollisionEvent.addInPattern('%fn-enter-%in')
self.floorCollisionEvent.addAgainPattern('%fn-again-%in')
self.floorCollisionEvent.addOutPattern('%fn-exit-%in')
base.cTrav.addCollider(cSphereNodePath, self.floorCollisionEvent)
self.cFloorEventSphereNodePath = cSphereNodePath
def deleteCollisions(self):
GravityWalker.deleteCollisions(self)
if self.cHeadSphereNodePath != None:
base.cTrav.removeCollider(self.cHeadSphereNodePath)
self.cHeadSphereNodePath.detachNode()
self.cHeadSphereNodePath = None
self.headCollisionsEvent = None
if self.cFloorEventSphereNodePath != None:
base.cTrav.removeCollider(self.cFloorEventSphereNodePath)
self.cFloorEventSphereNodePath.detachNode()
self.cFloorEventSphereNodePath = None
self.floorCollisionEvent = None
self.cRayNodePath.detachNode()
del self.cRayNodePath
self.cEventSphereNodePath.detachNode()
del self.cEventSphereNodePath
return
def setCollisionsActive(self, active=1):
if self.collisionsActive != active:
if self.cHeadSphereNodePath != None:
base.cTrav.removeCollider(self.cHeadSphereNodePath)
if active:
base.cTrav.addCollider(self.cHeadSphereNodePath,
self.headCollisionEvent)
if self.cFloorEventSphereNodePath != None:
base.cTrav.removeCollider(self.cFloorEventSphereNodePath)
if active:
base.cTrav.addCollider(self.cFloorEventSphereNodePath,
self.floorCollisionEvent)
GravityWalker.setCollisionsActive(self, active)
return
def enableAvatarControls(self):
pass
def disableAvatarControls(self):
pass
def handleAvatarControls(self, task):
pass
class CogdoFlyingCollisions(GravityWalker):
wantFloorSphere = 0
def __init__(self):
GravityWalker.__init__(self, gravity=0.0)
def initializeCollisions(self, collisionTraverser, avatarNodePath, avatarRadius = 1.4, floorOffset = 1.0, reach = 1.0):
self.cHeadSphereNodePath = None
self.cFloorEventSphereNodePath = None
self.setupHeadSphere(avatarNodePath)
self.setupFloorEventSphere(avatarNodePath, ToontownGlobals.FloorEventBitmask, avatarRadius)
GravityWalker.initializeCollisions(self, collisionTraverser, avatarNodePath, avatarRadius, floorOffset, reach)
def setupWallSphere(self, bitmask, avatarRadius):
self.avatarRadius = avatarRadius
cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75, self.avatarRadius)
cSphereNode = CollisionNode('Flyer.cWallSphereNode')
cSphereNode.addSolid(cSphere)
cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode)
cSphereNode.setFromCollideMask(bitmask)
cSphereNode.setIntoCollideMask(BitMask32.allOff())
if config.GetBool('want-fluid-pusher', 0):
self.pusher = CollisionHandlerFluidPusher()
else:
self.pusher = CollisionHandlerPusher()
self.pusher.addCollider(cSphereNodePath, self.avatarNodePath)
self.cWallSphereNodePath = cSphereNodePath
def setupEventSphere(self, bitmask, avatarRadius):
self.avatarRadius = avatarRadius
cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75, self.avatarRadius * 1.04)
cSphere.setTangible(0)
cSphereNode = CollisionNode('Flyer.cEventSphereNode')
cSphereNode.addSolid(cSphere)
cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode)
cSphereNode.setFromCollideMask(bitmask)
cSphereNode.setIntoCollideMask(BitMask32.allOff())
self.event = CollisionHandlerEvent()
self.event.addInPattern('enter%in')
self.event.addOutPattern('exit%in')
self.cEventSphereNodePath = cSphereNodePath
def setupRay(self, bitmask, floorOffset, reach):
cRay = CollisionRay(0.0, 0.0, 3.0, 0.0, 0.0, -1.0)
cRayNode = CollisionNode('Flyer.cRayNode')
cRayNode.addSolid(cRay)
self.cRayNodePath = self.avatarNodePath.attachNewNode(cRayNode)
cRayNode.setFromCollideMask(bitmask)
cRayNode.setIntoCollideMask(BitMask32.allOff())
self.lifter = CollisionHandlerGravity()
self.lifter.setLegacyMode(self._legacyLifter)
self.lifter.setGravity(self.getGravity(0))
self.lifter.addInPattern('%fn-enter-%in')
self.lifter.addAgainPattern('%fn-again-%in')
self.lifter.addOutPattern('%fn-exit-%in')
self.lifter.setOffset(floorOffset)
self.lifter.setReach(reach)
self.lifter.addCollider(self.cRayNodePath, self.avatarNodePath)
def setupHeadSphere(self, avatarNodePath):
collSphere = CollisionSphere(0, 0, 0, 1)
collSphere.setTangible(1)
collNode = CollisionNode('Flyer.cHeadCollSphere')
collNode.setFromCollideMask(ToontownGlobals.CeilingBitmask)
collNode.setIntoCollideMask(BitMask32.allOff())
collNode.addSolid(collSphere)
self.cHeadSphereNodePath = avatarNodePath.attachNewNode(collNode)
self.cHeadSphereNodePath.setZ(base.localAvatar.getHeight() + 1.0)
self.headCollisionEvent = CollisionHandlerEvent()
self.headCollisionEvent.addInPattern('%fn-enter-%in')
self.headCollisionEvent.addOutPattern('%fn-exit-%in')
base.cTrav.addCollider(self.cHeadSphereNodePath, self.headCollisionEvent)
def setupFloorEventSphere(self, avatarNodePath, bitmask, avatarRadius):
cSphere = CollisionSphere(0.0, 0.0, 0.0, 0.75)
cSphereNode = CollisionNode('Flyer.cFloorEventSphere')
cSphereNode.addSolid(cSphere)
cSphereNodePath = avatarNodePath.attachNewNode(cSphereNode)
cSphereNode.setFromCollideMask(bitmask)
cSphereNode.setIntoCollideMask(BitMask32.allOff())
self.floorCollisionEvent = CollisionHandlerEvent()
self.floorCollisionEvent.addInPattern('%fn-enter-%in')
self.floorCollisionEvent.addAgainPattern('%fn-again-%in')
self.floorCollisionEvent.addOutPattern('%fn-exit-%in')
base.cTrav.addCollider(cSphereNodePath, self.floorCollisionEvent)
self.cFloorEventSphereNodePath = cSphereNodePath
def deleteCollisions(self):
GravityWalker.deleteCollisions(self)
if self.cHeadSphereNodePath != None:
base.cTrav.removeCollider(self.cHeadSphereNodePath)
self.cHeadSphereNodePath.detachNode()
self.cHeadSphereNodePath = None
self.headCollisionsEvent = None
if self.cFloorEventSphereNodePath != None:
base.cTrav.removeCollider(self.cFloorEventSphereNodePath)
self.cFloorEventSphereNodePath.detachNode()
self.cFloorEventSphereNodePath = None
self.floorCollisionEvent = None
self.cRayNodePath.detachNode()
del self.cRayNodePath
self.cEventSphereNodePath.detachNode()
del self.cEventSphereNodePath
def setCollisionsActive(self, active = 1):
if self.collisionsActive != active:
if self.cHeadSphereNodePath != None:
base.cTrav.removeCollider(self.cHeadSphereNodePath)
if active:
base.cTrav.addCollider(self.cHeadSphereNodePath, self.headCollisionEvent)
if self.cFloorEventSphereNodePath != None:
base.cTrav.removeCollider(self.cFloorEventSphereNodePath)
if active:
base.cTrav.addCollider(self.cFloorEventSphereNodePath, self.floorCollisionEvent)
GravityWalker.setCollisionsActive(self, active)
def enableAvatarControls(self):
pass
def disableAvatarControls(self):
pass
def handleAvatarControls(self, task):
pass
def rayupdate(task):
if base.mouseWatcherNode.hasMouse():
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
pickerRay.setFromLens(base.camNode, mpos.getX(),mpos.getY())
return task.cont
#** Now the tricky part: we have here a particular kind of pattern that react firing a task event when a collider, tagged as 'rays', whatever the value is stored into, hit an object tagged as 'balls', no matter what value is stored into its tag. The resulting event strings sent to the panda3D event manager will be the result of the FROM collider (ray) and the tag value owned by the INTO object being hit (a ball), provided that was settled with a tag key 'balls'.
# That said, these two lines will catch all the events for either smiles and frowneys because we both tagged 'em as 'balls', for all IN events...
collisionHandler.addInPattern("%(rays)ft-into-%(balls)it")
# ...and here for the OUT events
collisionHandler.addOutPattern("%(rays)ft-out-%(balls)it")
#** To complicate things a little, this time we'll going to use the addAgainPattern method, that will raise an event while the mouse ponter is keeping over a ball of any group. Note that the 'ray_again_all' chunk will be used by the CollisionHandlerEvent to fire the event. See the related accept below.
collisionHandler.addAgainPattern(
"ray_again_all%(""rays"")fh%(""balls"")ih"
)
""" Note that we could have been done the same using this form as well:
collisionHandler.addAgainPattern("%(rays)ft-again-%(balls)it")
but then we should have used 2 accepts like this:
DO.accept('ray1-again-smileys', collideAgainBalls)
DO.accept('ray1-again-frowney', collideAgainBalls)
instead of just one as we did below, and this don't hurt very much in this snippet cos' we got just 2 groups, but could be complicated if we need to use a lot more groups.
Another big thing to note is that we could have been done all of this using the masking technique (see step4.py).
"""
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
#now put squareGeom in a GeomNode. You can now position your geometry in the scene graph.
squareGN=GeomNode("square")
squareGN.addGeom(squareGeom)
terrainNode = NodePath("terrNode")
terrainNode.reparentTo(render)
terrainNode.attachNewNode(squareGN)
terrainNode.setX(-width/2)
texGrass = loader.loadTexture("textures/envir-ground.jpg")
terrainNode.setTexture(texGrass)
cHandler.addInPattern("%(rays)ft-into-%(building)it")
cHandler.addOutPattern("%(rays)ft-out-%(building)it")
cHandler.addAgainPattern("ray_again_all%(""rays"")fh%(""building"")ih")
DO=DirectObject()
DO.accept('ray1-into-buildPlayer1', collideInBuilding)
DO.accept('ray1-out-buildPlayer1', collideOutBuilding)
DO.accept('ray_again_all', collideAgainstBuilds)
pickingEnabledOject=None
DO.accept('mouse1', mouseClick, ["down"])
DO.accept('mouse1-up', mouseClick, ["up"])
DO.accept("w",moveCam, ["up"])
DO.accept("s",moveCam, ["down"])
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")
from pandaImports import DirectObject
from tower import *
"""This file handles all the collision events
of our game
"""
# base.cTrav maintains a list of colliders of all solid objects in the world to check collisions (runs every frame)
base.cTrav = CollisionTraverser()
# collisionHandler specifies what to do when a collision event is detected
collisionHandler = CollisionHandlerEvent()
# "In" event: when there is a collision in the current frame, but it didn't in the previous frame
collisionHandler.addInPattern("%fn-into-%in")
# "Again" event: when there is a collision in the current frame, the same that happened in the previous frame
collisionHandler.addAgainPattern("%fn-again-%in")
# "Out" event: when there isn't a collision in the current frame, but there was in the previous frame
collisionHandler.addOutPattern("%fn-out-%in")
# self.collision3DPoint is the point where the collision occurs
collision3DPoint = [0, 0, 0]
# self.addCollider(mousePicking.pickerNP)
# self.addCollider(player.getTower(-1).troop.troopModel.troopColliderNP)
DO = DirectObject()
def addCollisionEventAgain(fromName, intoName, function, extraArgs=[]):
# Let's manage now the collision events:
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
from pandac.PandaModules import CollisionHandlerEvent, CollisionNode, CollisionTraverser, CollisionRay
from pandaImports import DirectObject
from tower import *
'''This file handles all the collision events
of our game
'''
#base.cTrav maintains a list of colliders of all solid objects in the world to check collisions (runs every frame)
base.cTrav = CollisionTraverser()
#collisionHandler specifies what to do when a collision event is detected
collisionHandler = CollisionHandlerEvent()
#"In" event: when there is a collision in the current frame, but it didn't in the previous frame
collisionHandler.addInPattern('%fn-into-%in')
#"Again" event: when there is a collision in the current frame, the same that happened in the previous frame
collisionHandler.addAgainPattern('%fn-again-%in')
#"Out" event: when there isn't a collision in the current frame, but there was in the previous frame
collisionHandler.addOutPattern('%fn-out-%in')
#self.collision3DPoint is the point where the collision occurs
collision3DPoint = [0, 0, 0]
#self.addCollider(mousePicking.pickerNP)
#self.addCollider(player.getTower(-1).troop.troopModel.troopColliderNP)
DO = DirectObject()
def addCollisionEventAgain(fromName, intoName, function, extraArgs=[]):
#Let's manage now the collision events:
DO.accept(fromName + "-again-" + intoName, function, extraArgs)
from tower import *
'''This file handles all the collision events
of our game
'''
#base.cTrav maintains a list of colliders of all solid objects in the world to check collisions (runs every frame)
base.cTrav=CollisionTraverser()
#collisionHandler specifies what to do when a collision event is detected
collisionHandler = CollisionHandlerEvent()
#"In" event: when there is a collision in the current frame, but it didn't in the previous frame
collisionHandler.addInPattern('%fn-into-%in')
#"Again" event: when there is a collision in the current frame, the same that happened in the previous frame
collisionHandler.addAgainPattern('%fn-again-%in')
#"Out" event: when there isn't a collision in the current frame, but there was in the previous frame
collisionHandler.addOutPattern('%fn-out-%in')
#self.collision3DPoint is the point where the collision occurs
collision3DPoint = [0,0,0]
#self.addCollider(mousePicking.pickerNP)
#self.addCollider(player.getTower(-1).troop.troopModel.troopColliderNP)
DO = DirectObject()
def addCollisionEventAgain(fromName, intoName, function, extraArgs = []):
#Let's manage now the collision events:
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")
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
pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
return task.cont
#** Now the tricky part: we have here a particular kind of pattern that react firing a task event when a collider, tagged as 'rays', whatever the value is stored into, hit an object tagged as 'balls', no matter what value is stored into its tag. The resulting event strings sent to the panda3D event manager will be the result of the FROM collider (ray) and the tag value owned by the INTO object being hit (a ball), provided that was settled with a tag key 'balls'.
# That said, these two lines will catch all the events for either smiles and frowneys because we both tagged 'em as 'balls', for all IN events...
collisionHandler.addInPattern("%(rays)ft-into-%(balls)it")
# ...and here for the OUT events
collisionHandler.addOutPattern("%(rays)ft-out-%(balls)it")
#** To complicate things a little, this time we'll going to use the addAgainPattern method, that will raise an event while the mouse ponter is keeping over a ball of any group. Note that the 'ray_again_all' chunk will be used by the CollisionHandlerEvent to fire the event. See the related accept below.
collisionHandler.addAgainPattern("ray_again_all%("
"rays"
")fh%("
"balls"
")ih")
""" Note that we could have been done the same using this form as well:
collisionHandler.addAgainPattern("%(rays)ft-again-%(balls)it")
but then we should have used 2 accepts like this:
DO.accept('ray1-again-smileys', collideAgainBalls)
DO.accept('ray1-again-frowney', collideAgainBalls)
instead of just one as we did below, and this don't hurt very much in this snippet cos' we got just 2 groups, but could be complicated if we need to use a lot more groups.
Another big thing to note is that we could have been done all of this using the masking technique (see step4.py).
"""
