def apply_spurt(self, actor_node, force=None): print 'spurt' print('force', force) #print actor_node # really want this to remember its previous state with that # particular ball, and reduce the force from then by some amount. if force is None: # force = LinearVectorForce(0.0, 0.0, self.force_mag) force = LinearVectorForce(0.0, 0.0, self.force_mag) self.spurt.addForce(force) print('new', force) #self.force_mag -= 15 else: force.getAmplitude() # apply the spurt actor_node.getPhysical(0).addLinearForce(force) print('added force', self.spurt.getForce(0).getVector(actor_node.getPhysicsObject())[2]) #print force, actor_node #for child in self.base.render.getChildren(): # print child # set a task that will clear this force a short moment later self.base.taskMgr.doMethodLater(0.01, self.remove_force, 'removeForceTask', extraArgs=[actor_node, force], appendTask=True) print 'set do method later'
def ship(self): an = ActorNode() an.getPhysicsObject().setMass(100) self.fighter = self.render.attachNewNode(an) self.physicsMgr.attachPhysicalNode(an) self.anpo = an.getPhysicsObject() fn = ForceNode("force-node-fighter") self.fighter.attachNewNode(fn) self.pft = LinearVectorForce(Vec3(0, +1, 0) * 500) # forward thrust self.prt = LinearVectorForce(Vec3(0, -1, 0) * 500) # reverse thrust self.pft.setMassDependent(1) self.prt.setMassDependent(1) self.pft.setActive(False) self.prt.setActive(False) fn.addForce(self.pft) fn.addForce(self.prt) an.getPhysical(0).addLinearForce(self.pft) an.getPhysical(0).addLinearForce(self.prt) self.camera.reparentTo(self.fighter) from_obj = self.fighter.attachNewNode(CollisionNode('fighter')) from_obj.node().setFromCollideMask(BitMask32(0x1)) from_obj.setCollideMask(BitMask32(0x1)) from_obj.node().addSolid(CollisionSphere(0, 0, 0, 1)) # from_obj.show() self.pusher.addCollider(from_obj, self.fighter) self.cTrav.addCollider(from_obj, self.pusher)
def apply_spurt(self, actor_node, force=None): print 'spurt' print('force', force) #print actor_node # really want this to remember its previous state with that # particular ball, and reduce the force from then by some amount. if force is None: # force = LinearVectorForce(0.0, 0.0, self.force_mag) force = LinearVectorForce(0.0, 0.0, self.force_mag) self.spurt.addForce(force) print('new', force) #self.force_mag -= 15 else: force.getAmplitude() # apply the spurt actor_node.getPhysical(0).addLinearForce(force) print( 'added force', self.spurt.getForce(0).getVector(actor_node.getPhysicsObject())[2]) #print force, actor_node #for child in self.base.render.getChildren(): # print child # set a task that will clear this force a short moment later self.base.taskMgr.doMethodLater(0.01, self.remove_force, 'removeForceTask', extraArgs=[actor_node, force], appendTask=True) print 'set do method later'
def shoot(self, pos, shootVec=None): if shootVec != None: v = shootVec v *= 214.0 else: # Get from/to points from mouse click pMouse = base.mouseWatcherNode.getMouse() pFrom = Point3() pTo = Point3() base.camLens.extrude(pMouse, pFrom, pTo) pFrom = render.getRelativePoint(base.cam, pFrom) pTo = render.getRelativePoint(base.cam, pTo) # Calculate initial velocity v = pTo - pFrom v.normalize() v *= 214.0 self.bulletNP.setPos(pos) self.bulletNP.reparentTo(render) self.bulletFN = ForceNode("Bullet-force-%d" % id(self)) self.bulletFNP = self.bulletNP.attachNewNode(self.bulletFN) # speed of a paintball when he leafes the muzzle: 214 fps self.lvf = LinearVectorForce(v) self.lvf.setMassDependent(1) self.bulletFN.addForce(self.lvf) self.bulletAN.getPhysical(0).addLinearForce(self.lvf) self.accept("bulletCollision-%d-hit" % id(self), self.bulletHit) taskMgr.doMethodLater( 2, self.doRemove, 'doRemove-%d' % id(self), appendTask=True)
def __init__(self, name): self.name = name self.cell_x = 0 self.cell_y = 0 self.vel = LPoint3(0, 0, 0) self.c_node = base.render.attachNewNode( self.name+"_camera_node") self.panda_actor = Actor("models/panda-model", {"walk": "models/panda-walk4"}) self.panda_actor.setScale(0.05, 0.05, 0.05) self.p_node = NodePath(self.name+"_phys_node") self.p_node.reparentTo(render) self.an = ActorNode("panda-phys") self.anp = self.p_node.attachNewNode(self.an) base.enableParticles() base.physicsMgr.attachPhysicalNode(self.an) self.panda_actor.reparentTo(self.anp) gravityFN=ForceNode('world-forces') gravityFNP=render.attachNewNode(gravityFN) #gravityForce=LinearVectorForce(0,0,-9.81) #gravity acceleration self.gravityForce=LinearVectorForce(0,0,-9.81) gravityFN.addForce(self.gravityForce) base.physicsMgr.addLinearForce(self.gravityForce) self.c_node.reparentTo(self.panda_actor) self.c_node.setCompass() #self.panda_actor.reparentTo(base.render) base.camera.reparentTo(self.c_node) self.box = loader.loadModel("box.egg") self.box.setScale(100, 100, 100) self.box.setPos(-180, 0, 0) self.boxc = self.box.find("**/Cube") self.boxc.node().setIntoCollideMask(BitMask32.bit(0)) self.boxc.node().setFromCollideMask(BitMask32.allOff()) self.ban = ActorNode("box-phys") base.physicsMgr.attachPhysicalNode(self.ban) self.bp_node = NodePath(self.name+"_phys_node2") self.bp_node.reparentTo(render) self.banp = self.bp_node.attachNewNode(self.ban) self.box.reparentTo(self.banp) self.boxc.show()
def addLinearForce(self, x, y, z, physicalNode=None): """Adds a linear vector force to the simulation with the given components. If a 'physicalNode' is given, the force will be aplied to it. Otherwise the force will be global. """ force = LinearVectorForce(x, y, z) self.forces.node().addForce(force) physicalNode = physicalNode or base.physicsMgr physicalNode.addLinearForce(force) return force
def __init__(self): NodePath.__init__(self, "particleFloorTest") # Sort Order of Particles self.setDepthWrite(0) # Load Particle Effects self.f = ParticleEffect.ParticleEffect() self.f.reparentTo(self) self.p0 = Particles.Particles('particles-1') # Particles parameters self.p0.setFactory("PointParticleFactory") self.p0.setRenderer("PointParticleRenderer") self.p0.setEmitter("SphereVolumeEmitter") self.p0.setPoolSize(64) self.p0.setBirthRate(0.020) self.p0.setLitterSize(7) self.p0.setLitterSpread(2) self.p0.setSystemLifespan(0.0000) #self.p0.setLocalVelocityFlag(1) self.p0.setFloorZ(-1.0) self.p0.setSystemGrowsOlderFlag(0) # Factory parameters self.p0.factory.setLifespanBase(10.000) self.p0.factory.setLifespanSpread(0.50) self.p0.factory.setMassBase(1.80) self.p0.factory.setMassSpread(1.00) self.p0.factory.setTerminalVelocityBase(400.0000) self.p0.factory.setTerminalVelocitySpread(0.0000) self.f.addParticles(self.p0) if 1: f0 = ForceGroup.ForceGroup('frict') # Force parameters force0 = LinearVectorForce(Vec3(0., 0., -1.)) force0.setActive(1) f0.addForce(force0) self.f.addForceGroup(f0)
def setup(self, task): lens = OrthographicLens() lens.setFilmSize(25, 20) # Or whatever is appropriate for your scene base.camNode.setLens(lens) node = self.scene.find("root/camera1") node.removeNode() self.camera.setPos(0, 30, 0) self.camera.lookAt(self.scene) self.mario = self.scene.find("root/mario") self.mario.reparentTo(self.scene) self.scene.find("root/bottomstair").reparentTo(self.scene) self.scene.find("root/floor0").reparentTo(self.scene) self.scene.find("root/floor1").reparentTo(self.scene) self.scene.find("root/middlestair").reparentTo(self.scene) self.scene.find("root/topstair").reparentTo(self.scene) self.scene.find("root/floor2").reparentTo(self.scene) self.scene.find("root/pCube4").reparentTo(self.scene) self.scene.find("root/floors").reparentTo(self.scene) self.scene.find("root/barrel").reparentTo(self.scene) self.scene.find("root/walls").reparentTo(self.scene) self.scene.find("root/rightWall").reparentTo(self.scene) self.scene.find("root/MainGroup").reparentTo(self.scene) self.scene.find("root/hammer1").reparentTo(self.scene) self.barrel = self.scene.find("barrel") self.barrel.setPos(self.scene, 0, 0, 0) self.setupCollision() base.enableParticles() gravityFN = ForceNode('world-forces') gravityFNP = render.attachNewNode(gravityFN) gravityForce = LinearVectorForce(0, 0, -9.81) #gravity acceleration gravityFN.addForce(gravityForce) base.physicsMgr.addLinearForce(gravityForce) return Task.done
def createBarrel(self): barrelNode = NodePath("PhysicalBarrel") barrelNode.reparentTo(self.scene) barrelNode.setPos(self.scene, 0,0,0) physicsBarrel = ActorNode("physics_barrel") physicsBarrel.getPhysicsObject().setMass(0.01) #in what units? (69 kindda 3 lbs) barrel = barrelNode.attachNewNode(physicsBarrel) base.physicsMgr.attachPhysicalNode(physicsBarrel) barrel.setPos(barrelNode, 0,0,0) visual_barrel = self.scene.attachNewNode("BarrelCopy") originalBarrel = self.scene.find("barrel") originalBarrel.instanceTo(visual_barrel) visual_barrel.reparentTo(barrel) visual_barrel.setPos(self.scene, -6.5,0,-24.5 ) dataNode = barrelNode.attachNewNode(AuxData("Sequence",None)) seq = self.createBarrelGraphicSequence(visual_barrel, physicsBarrel, dataNode) dataNode.node().getPythonTag("subclass").sequence = seq #sphere = CollisionSphere(6.6,0,4.78, 0.5) sphere = CollisionSphere(6.6,0,24.7, 0.5) cnodePath = visual_barrel.attachNewNode(CollisionNode('barrelCollider')) cnodePath.node().addSolid(sphere) cnodePath.node().setFromCollideMask(0xD) # crash with default and mario body and walls cnodePath.node().setIntoCollideMask(0xD) # crash with default and mario body and walls self.showCollision(cnodePath) #cnodePath.show() self.physicsCollisionPusher.addCollider(cnodePath,barrel) base.cTrav.addCollider(cnodePath, self.physicsCollisionPusher) barrelForceNode = ForceNode('barrelForce') barrel.attachNewNode(barrelForceNode) barrelForce = LinearVectorForce(-7,0,0, 1, False) # barrelForce.setMassDependent(0) barrelForceNode.addForce(barrelForce) physicsBarrel.getPhysical(0).addLinearForce(barrelForce) # starting barrel point :D barrelNode.setPos(self.scene,6.5,0,4.5)
def __init__(self, base, name, speed, scale, color, mask, relA, xyz, relB, lookat, life): an = ActorNode() self.anp = base.render.attachNewNode(an) base.physicsMgr.attachPhysicalNode(an) self.anpo = an.getPhysicsObject() fn = ForceNode("force-missile") self.anp.attachNewNode(fn) bft = LinearVectorForce(Vec3(0, 1, 0) * speed) fn.addForce(bft) an.getPhysical(0).addLinearForce(bft) missile = base.loader.loadModel("./mdl/missile.egg") missile.setColor(color) missile.setScale(scale) missile.reparentTo(self.anp) missile.setTag(name, '1') missile_from_obj = missile.attachNewNode(CollisionNode(name)) missile_from_obj.node().addSolid(CollisionSphere(0, 0, 0, 1)) missile_from_obj.node().setFromCollideMask(mask) missile_from_obj.setCollideMask(mask) base.pusher.addCollider(missile_from_obj, self.anp) base.cTrav.addCollider(missile_from_obj, base.pusher) self.anp.setPos(relA, xyz) self.anp.lookAt(relB, lookat) # light the missile mlight = DirectionalLight('mlight') mlight.setColor(VBase4(1., 1., 1., 1)) mlnp = base.render.attachNewNode(mlight) mlnp.setHpr(self.anp.getHpr()) self.anp.setLightOff() self.anp.setLight(mlnp) # remove the missile base.taskMgr.doMethodLater(life, self.remove_missile, 'task-remove-missile', extraArgs=[self.anp], appendTask=True)
def createBarrel(self): barrelNode = NodePath("PhysicalBarrel") barrelNode.reparentTo(self.scene) physicsBarrel = ActorNode("physics_barrel") physicsBarrel.getPhysicsObject().setMass( 0.01) #in what units? (69 kindda 3 lbs) barrel = barrelNode.attachNewNode(physicsBarrel) base.physicsMgr.attachPhysicalNode(physicsBarrel) barrel.setPos(0, 0, 2) visual_barrel = self.scene.attachNewNode("BarrelCopy") originalBarrel = self.scene.find("barrel") originalBarrel.instanceTo(visual_barrel) visual_barrel.reparentTo(barrel) sphere = CollisionSphere(6.6, 0, 4.78, 0.5) cnodePath = visual_barrel.attachNewNode( CollisionNode('barrelCollider')) cnodePath.node().addSolid(sphere) cnodePath.node().setFromCollideMask( 0xD) # crash with default and mario body and walls cnodePath.node().setIntoCollideMask( 0xD) # crash with default and mario body and walls cnodePath.show() self.physicsCollisionPusher.addCollider(cnodePath, barrel) base.cTrav.addCollider(cnodePath, self.physicsCollisionPusher) barrelForceNode = ForceNode('barrelForce') barrel.attachNewNode(barrelForceNode) barrelForce = LinearVectorForce(-7, 0, 0, 1, False) # barrelForce.setMassDependent(0) barrelForceNode.addForce(barrelForce) physicsBarrel.getPhysical(0).addLinearForce(barrelForce)
def setup(self,task): lens = OrthographicLens() lens.setFilmSize(21.8,18) # Or whatever is appropriate for your scene #lens.setFilmSize(142,136) # Or whatever is appropriate for your scene base.camNode.setLens(lens) node = self.scene.find("root/camera1") node.removeNode() self.camera.setPos( 0,30,0 ) self.camera.lookAt(self.scene) self.mario = self.render.attachNewNode("MarioContainer") self.mario.setPos(self.scene, 0,0,0) self.marioGraphic = self.mario.attachNewNode("MarioGraphic") self.marioGraphic.setPos(self.mario, 0,0,0) self.scene.find("root/mario").reparentTo(self.marioGraphic) myTexture = loader.loadTexture("models/dk-arcade.png") self.marioRealGraphic = self.marioGraphic.find("mario") self.marioRealGraphic.setPos(self.marioGraphic, -6.7, 1, 4.5 ) self.marioRealGraphic.setTexture(myTexture) self.marioRealGraphic.setTwoSided(True) self.marioRealGraphic.setTransparency(1) self.scene.find("root/hammerup").reparentTo(self.marioRealGraphic) self.scene.find("root/hammerdowm").reparentTo(self.marioRealGraphic) self.marioRealGraphic.find("hammerup").hide() self.marioRealGraphic.find("hammerdowm").hide() self.scene.find("root/bottomstair").reparentTo(self.scene) self.scene.find("root/floor0").reparentTo(self.scene) self.scene.find("root/floor1").reparentTo(self.scene) self.scene.find("root/middlestair").reparentTo(self.scene) self.scene.find("root/topstair").reparentTo(self.scene) self.scene.find("root/floor2").reparentTo(self.scene) self.scene.find("root/pCube4").reparentTo(self.scene) self.scene.find("root/floors").reparentTo(self.scene) self.scene.find("root/barrel").reparentTo(self.scene) self.scene.find("root/walls").reparentTo(self.scene) self.scene.find("root/rightWall").reparentTo(self.scene) self.scene.find("root/MainGroup").reparentTo(self.scene) self.scene.find("root/hammer1").reparentTo(self.scene) self.barrel = self.scene.find("barrel") self.barrel.setPos(self.scene, 0,0,20) myTexture = loader.loadTexture("models/block.png") self.scene.find("floor0").setTexture(myTexture) self.scene.find("floor1").setTexture(myTexture) self.scene.find("floor2").setTexture(myTexture) self.scene.find("floors").setTexture(myTexture) self.scene.find("pCube4").setTexture(myTexture) self.scene.find("floor0").setTransparency(1) self.scene.find("floor1").setTransparency(1) self.scene.find("floor2").setTransparency(1) self.scene.find("floors").setTransparency(1) self.scene.find("pCube4").setTransparency(1) myTexture = loader.loadTexture("models/stairs.png") self.scene.find("bottomstair").setTexture(myTexture) self.scene.find("middlestair").setTexture(myTexture) self.scene.find("topstair").setTexture(myTexture) self.scene.find("bottomstair").setTransparency(1) self.scene.find("middlestair").setTransparency(1) self.scene.find("topstair").setTransparency(1) base.setBackgroundColor(0,0,0) self.setupCollision() base.enableParticles() gravityFN=ForceNode('world-forces') gravityFNP=render.attachNewNode(gravityFN) gravityForce=LinearVectorForce(0,0,-9.81) #gravity acceleration gravityFN.addForce(gravityForce) base.physicsMgr.addLinearForce(gravityForce) # create dk graphic barrel sequence return Task.done
#** This is the first time we see this collider: it is used mainly to define a flat infinite plane surface - # it is very reliable and stable and gives high fame rate performances so use it as much as you can. # Note that we specify 2 corners of the plane of just 1 unit per side but this collider will collide # with everithing as it was an infinite plane anyhow. Note that there is no need to set anything further for it. cp = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0))) planeNP = base.render.attachNewNode(CollisionNode('planecnode')) planeNP.node().addSolid(cp) planeNP.show() #** This is how to define the gravity force to make our stuff fall down: first off we define a ForceNode and attach to the render, so that everything below will be affected by this force globalforcesFN = ForceNode('world-forces') globalforcesFNP = base.render.attachNewNode(globalforcesFN) # then we set a linear force that will act in Z axis-drag-down-force of 9.81 units per second. globalforcesGravity = LinearVectorForce(0, 0, -5.81) globalforcesFN.addForce(globalforcesGravity) # and then we assign this force to the physics manager. By the way, we never defined that manager, but it was made automatically when we called base.enableParticles() base.physicsMgr.addLinearForce(globalforcesGravity) #** Inside this function we'll load a model and assign a collide ball to it, suitable to collide with everything interacting in the physics environment. # I put it in a function because I'll going to call it several times. It will return at last the topmost nodepath of its structure so that we may drive each ball around. def phyball_dispenser(modelname, scale=1.): # first off we gotta define the topmost node that should be a PandaNode wrapped into a nodepath - this is mandatory cos if we try to directly use the Actornode defined below, we'll face inexpected behavior manipulating the object. ballNP = NodePath(PandaNode("phisicsball")) # we then need an ActorNode - this is required when playing with physics cos it got an interface suitable for this # task while the usual nodepath ain't. Then we'll stick it to the main nodepath we'll put into the scene render node, wrapped into a nodepath of course. ballAN = ActorNode("ballactnode") ballANP = ballNP.attachNewNode(ballAN) ballmodel = loader.loadModel(modelname)
class Engine(ShowBase): def __init__(self, mouse): ShowBase.__init__(self) self.mouse = mouse self.joy_x = None self.joy_y = None props = WindowProperties() props.setMouseMode(WindowProperties.MRelative) # keep mouse in screen self.disableMouse() self.win.requestProperties(props) self.setBackgroundColor(0, 0, 0) # Make missiles glow self.filters = CommonFilters(self.win, self.cam) self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size="large") self.screen_width = self.win.getXSize() self.screen_height = self.win.getYSize() self.center_x = self.screen_width/2 self.center_y = self.screen_height/2 # self.win.movePointer(0, self.center_x, self.center_y) self.enableParticles() self.cTrav = CollisionTraverser() # self.cTrav.setRespectPrevTransform(True) self.pusher = PhysicsCollisionHandler() self.pusher.addInPattern('%fn-into-%in') self.target = None self.maxvel = 50 self.roll_time = 0 self.fuel = 1000 self.ship() self.sounds() self.hud() self.part = Spacedust(self) self.events() self.camLens.setFov(70) self.camLens.setNear(1) self.camLens.setFar(500) self.get_key = { "ACCEL": False, "DECEL": False, "FORWARD_THRUST": False, "REVERSE_THRUST": False, "ROLL_LEFT": False, "ROLL_RIGHT": False, "ROLL_LEFT_BEG": False, "ROLL_RIGHT_BEG": False, "FIRE": False, "FIRING": False, "LOCK": False, "LOCKING": False, } self.AIworld = AIWorld(self.render) self.taskMgr.add(self.update, "task-update") self.taskMgr.doMethodLater(1, self.fuel_usage, "task-fuel-usage") self.taskMgr.add(self.AI_update, "AI-update") self.gen_enemy() def gen_enemy(self): x = randint(-1000, 1000) y = randint(-1000, 1000) z = randint(-1000, 1000) Enemy(self, 0, x, y, z) def AI_update(self, task): self.AIworld.update() return task.cont def hud(self): self.font = self.loader.loadFont("./fnt/subatomic.tsoonami.ttf") self.aim = OnscreenImage(image="./png/ring.png", pos=Vec3(0), scale=0.02) self.aim.setTransparency(TransparencyAttrib.MAlpha) self.locker = OnscreenImage(image="./png/ring.png", pos=Vec3(0), scale=0.12) self.locker.setTransparency(TransparencyAttrib.MAlpha) self.locker.hide() self.txtFuel = OnscreenText(parent=self.render2d, align=TextNode.ALeft, pos=(-0.95, 0.8), text='FUEL', fg=(1, 1, 1, 0.5), scale=0.05, font=self.font, mayChange=True) self.txtSpeed = OnscreenText(parent=self.render2d, align=TextNode.ALeft, pos=(-0.95, 0.7), text='SPEED', fg=(1, 1, 1, 0.5), scale=0.05, font=self.font, mayChange=True) self.txtDist = OnscreenText(parent=self.render2d, align=TextNode.ALeft, pos=(-0.95, 0.6), text='DIST', fg=(1, 1, 1, 0.5), scale=0.05, font=self.font, mayChange=True) self.txtCoord = OnscreenText(parent=self.render2d, align=TextNode.ALeft, pos=(-0.95, 0.5), text='COORD', fg=(1, 1, 1, 0.5), scale=0.05, font=self.font, mayChange=True) self.taskMgr.doMethodLater(1, self.instruments, "task-instruments") def instruments(self, task): self.txtSpeed.setText("SPEED: %s" % str(int(self.mvel))) self.txtFuel.setText("FUEL: %s" % str(self.fuel)) if self.target is not None: self.txtDist.setText("DISTANCE: %s" % str(round(self.dist, 1))) else: self.txtDist.setText("DISTANCE: ---") self.txtCoord.setText("COORD: %s %s %s" % (str(round(self.fighter.getX(), 1)), str(round(self.fighter.getY(), 1)), str(round(self.fighter.getZ(), 1)))) return task.again def set_key(self, key, value): self.get_key[key] = value def toggle_key(self, key): self.set_key(key, not self.get_key[key]) def init_roll(self, a, task): if task.time <= 2: if self.roll_time <= task.time: self.roll_time = task.time else: self.roll_time += task.time if self.roll_time > 2: self.roll_time = 2 self.fighter.setR(self.fighter.getR() + a * self.roll_time) else: self.fighter.setR(self.fighter.getR() + a * 2) return task.cont def end_roll(self, a, b, task): if task.time < b: self.roll_time -= task.time if self.roll_time < 0: self.roll_time = 0 self.fighter.setR(self.fighter.getR() + a * (b - task.time)) return task.cont else: return task.done def roll(self, a): if a > 0: self.set_key("ROLL_RIGHT_BEG", True) else: self.set_key("ROLL_LEFT_BEG", True) self.taskMgr.add(self.init_roll, "task-init-roll", extraArgs=[a], appendTask=True) def unroll(self, a): if a > 0: self.set_key("ROLL_RIGHT_BEG", False) else: self.set_key("ROLL_LEFT_BEG", False) self.taskMgr.remove("task-init-roll") self.taskMgr.add(self.end_roll, "task-end-roll", extraArgs=[a, self.roll_time], appendTask=True) def to_roll(self): if self.get_key["ROLL_LEFT"]: if not self.get_key["ROLL_LEFT_BEG"]: if self.fuel > 5: self.roll(-1) self.snd_roller.play() else: if self.get_key["ROLL_LEFT_BEG"]: self.unroll(-1) self.snd_roller.stop() if self.get_key["ROLL_RIGHT"]: if not self.get_key["ROLL_RIGHT_BEG"]: if self.fuel > 5: self.roll(+1) self.snd_roller.play() else: if self.get_key["ROLL_RIGHT_BEG"]: self.unroll(+1) self.snd_roller.stop() def fuel_usage(self, task): if self.get_key["FORWARD_THRUST"] or self.get_key["REVERSE_THRUST"]: self.fuel -= 9 if self.get_key["ROLL_LEFT_BEG"] or self.get_key["ROLL_RIGHT_BEG"]: self.fuel -= 4 self.fuel -= 1 if self.fuel < 0: self.fuel = 0 return task.again def chk_speed(self, mvel): if mvel < 0.01: # stop fighter dead if self.prt.getActive(): self.set_key("DECEL", False) mvel = 0 if mvel > self.maxvel: # stop fighter accelerating if self.pft.getActive(): self.set_key("ACCEL", False) mvel = self.maxvel self.part.p.renderer.setLineScaleFactor(mvel*2) self.part.pn.setPos(self.fighter, 0, 10, 0) return mvel def thrust_shake(self, task): x = uniform(-1000, 1000) y = uniform(-1000, 1000) self.repos(x, y, 0.001) return task.cont def thrust_end(self, task): if task.time < 5: f = (5. - task.time) / 5. s = 1000.*f x = uniform(-s, s) y = uniform(-s, s) self.repos(x, y, 0.001) self.snd_thrust.setVolume(f) return task.cont self.snd_thrust.stop() return task.done def thrust(self, a): if a > 0: self.set_key("FORWARD_THRUST", True) else: self.set_key("REVERSE_THRUST", True) self.taskMgr.remove("task-thrust-end") self.snd_thrust.setVolume(1) self.snd_thrust.play() self.taskMgr.add(self.thrust_shake, "task-thrust-shake") def unthrust(self, a): if a > 0: self.set_key("FORWARD_THRUST", False) else: self.set_key("REVERSE_THRUST", False) self.taskMgr.remove("task-thrust-shake") self.taskMgr.add(self.thrust_end, "task-thrust-end") def to_thrust(self): if self.get_key["ACCEL"]: if self.mvel < self.maxvel - 1: if not self.get_key["FORWARD_THRUST"]: if self.fuel > 10: self.pft.setActive(True) self.thrust(+1) else: if self.get_key["FORWARD_THRUST"]: self.pft.setActive(False) self.unthrust(+1) if self.get_key["DECEL"]: if self.mvel > 0: if not self.get_key["REVERSE_THRUST"]: if self.fuel > 10: self.prt.setActive(True) self.thrust(-1) else: if self.get_key["REVERSE_THRUST"]: self.prt.setActive(False) self.unthrust(-1) def events(self): self.accept("escape", self.quit) self.accept('mouse1', self.set_key, ["FIRE", True]) self.accept('mouse1-up', self.set_key, ["FIRE", False]) self.accept('mouse3', self.set_key, ["LOCK", True]) self.accept('mouse3-up', self.set_key, ["LOCK", False]) self.accept("w", self.set_key, ["ACCEL", True]) self.accept("w-up", self.set_key, ["ACCEL", False]) self.accept("s", self.set_key, ["DECEL", True]) self.accept("s-up", self.set_key, ["DECEL", False]) self.accept("a", self.set_key, ["ROLL_LEFT", True]) self.accept("a-up", self.set_key, ["ROLL_LEFT", False]) self.accept("d", self.set_key, ["ROLL_RIGHT", True]) self.accept("d-up", self.set_key, ["ROLL_RIGHT", False]) def update(self, task): self.pos() self.speed() if self.fuel > 0: self.to_roll() self.to_thrust() self.to_fire() self.to_lock() self.rehud() return task.cont def rehud(self): if self.target is not None: c = self.target.np.getPos(self.fighter) self.dist = c.length() c.normalize() self.d2 = c - Vec3(0, 1, 0)*c.dot(Vec3(0, 1, 0)) self.target.radar.setPos(self.d2.getX(), 1, self.d2.getZ()) def sounds(self): self.audio3d = Audio3DManager.Audio3DManager(self.sfxManagerList[0], self.camera) self.audio3d.setListenerVelocityAuto() self.snd_space = self.loader.loadSfx("./snd/space.flac") self.snd_space.setLoop(True) self.snd_thrust = self.loader.loadSfx("./snd/thrust.flac") self.snd_thrust.setLoop(True) self.snd_roller = self.loader.loadSfx("./snd/roller.flac") self.snd_roller.setLoop(True) self.snd_launch = self.loader.loadSfx("./snd/launch.flac") self.snd_lock = self.loader.loadSfx("./snd/lock.flac") self.snd_space.play() def quit(self): self.taskMgr.running = False def repos(self, x, y, d): player_q = self.fighter.getQuat() up = player_q.getUp() right = player_q.getRight() up.normalize() right.normalize() up_q = copy(player_q) right_q = copy(player_q) up_q.setFromAxisAngle(-(x * d), up) right_q.setFromAxisAngle(y * d, right) self.fighter.setQuat(player_q.multiply(up_q.multiply(right_q))) def move_end(self, x, y, task): if task.time <= 1: d = 0.002*(1 - task.time) self.repos(x, y, d) return task.cont return task.done def pos(self): if self.mouse: md = self.win.getPointer(0) x = md.getX() y = md.getY() else: x = self.joy_x y = self.joy_y if self.win.movePointer(0, self.center_x, self.center_y): x -= self.center_x y -= self.center_y if x != 0 or y != 0: self.taskMgr.add(self.move_end, 'task-move-end', extraArgs=[x, y], appendTask=True) def speed(self): fwd = self.fighter.getQuat().getForward() fwd.normalize() self.mvel = self.anpo.getVelocity().length() # speed control self.mvel = self.chk_speed(self.mvel) self.anpo.setVelocity(fwd * self.mvel) def ship(self): an = ActorNode() an.getPhysicsObject().setMass(100) self.fighter = self.render.attachNewNode(an) self.physicsMgr.attachPhysicalNode(an) self.anpo = an.getPhysicsObject() fn = ForceNode("force-node-fighter") self.fighter.attachNewNode(fn) self.pft = LinearVectorForce(Vec3(0, +1, 0) * 500) # forward thrust self.prt = LinearVectorForce(Vec3(0, -1, 0) * 500) # reverse thrust self.pft.setMassDependent(1) self.prt.setMassDependent(1) self.pft.setActive(False) self.prt.setActive(False) fn.addForce(self.pft) fn.addForce(self.prt) an.getPhysical(0).addLinearForce(self.pft) an.getPhysical(0).addLinearForce(self.prt) self.camera.reparentTo(self.fighter) from_obj = self.fighter.attachNewNode(CollisionNode('fighter')) from_obj.node().setFromCollideMask(BitMask32(0x1)) from_obj.setCollideMask(BitMask32(0x1)) from_obj.node().addSolid(CollisionSphere(0, 0, 0, 1)) # from_obj.show() self.pusher.addCollider(from_obj, self.fighter) self.cTrav.addCollider(from_obj, self.pusher) def launch_bullet(self): speed = 500. scale = Vec3(0.05) color = Vec4(0, 1, 0, 1) mask = BitMask32(0x2) lookat = Vec3(0, 100, 0) Missile(self, "bullet", speed, scale, color, mask, self.fighter, Vec3(-0.5, 0, 0), self.fighter, lookat, 0.5) Missile(self, "bullet", speed, scale, color, mask, self.fighter, Vec3(+0.5, 0, 0), self.fighter, lookat, 0.5) self.snd_launch.play() def to_fire(self): if self.get_key["FIRE"]: if not self.get_key["FIRING"]: self.set_key("FIRING", True) self.taskMgr.doMethodLater(0.16, self.fire_bullet, "task-fire-bullet") else: if self.get_key["FIRING"]: self.set_key("FIRING", False) self.taskMgr.remove("task-fire-bullet") def fire_bullet(self, task): if self.fuel >= 5: self.fuel -= 5 self.launch_bullet() return task.again def launch_missile(self): speed = 100 scale = Vec3(0.2) color = Vec4(1, 0, 0, 1) mask = BitMask32(0x2) lookat = Vec3(0, 0, 0) self.missile = Missile(self, "missile", speed, scale, color, mask, self.fighter, Vec3(0, 0, -2), self.target.np, lookat, 3) self.snd_launch.play() self.taskMgr.add(self.guide_missile, "task-guide-missile") def guide_missile(self, task): try: quat = Quat() lookAt(quat, self.target.np.getPos() - self.missile.anp.getPos(), Vec3.up()) self.missile.anp.setQuat(quat) fwd = quat.getForward() fwd.normalize() mvel = self.missile.anpo.getVelocity().length() self.missile.anpo.setVelocity(fwd*mvel) except: return task.done return task.cont def can_lock(self): if self.dist >= 30 and self.dist <= 300 and abs(self.d2.getX()) <= 0.1 and abs(self.d2.getZ()) <= 0.1: return True else: return False def remove_lock(self): if self.get_key["LOCKING"]: self.set_key("LOCKING", False) self.locker.hide() self.snd_lock.stop() self.taskMgr.remove("task-fire-missile") def to_lock(self): if self.get_key["LOCK"]: if self.can_lock(): if self.fuel >= 100: if not self.get_key["LOCKING"]: self.set_key("LOCKING", True) self.locker.setScale(0.12) self.locker.setColor(1, 0, 0, 0.5) self.locker.show() self.snd_lock.play() self.taskMgr.add(self.fire_missile, "task-fire-missile") else: self.remove_lock() else: self.remove_lock() else: self.remove_lock() def fire_missile(self, task): if self.fuel >= 100: if task.time < 3.6: e = (3.6 - task.time)/3.6 f = 0.02 + e*0.1 self.locker.setScale(f) self.locker.setColor(e, 1-e, 0, 0.5) return task.cont else: self.fuel -= 100 self.launch_missile() return task.done
def __init__(self): self.base = ShowBase() self.thrust = 0.5 self.wind = 0.2 self.UP = Vec3(0, 0, 1) # might as well just make this a variable # set up camera self.base.disableMouse() self.base.camera.setPos(20, -20, 5) self.base.camera.lookAt(0, 0, 5) # Set up the collision traverser. If we bind it to base.cTrav, then Panda will handle # management of this traverser (for example, by calling traverse() automatically for us once per frame) self.base.cTrav = CollisionTraverser() # Now let's set up some collision bits for our masks self.ground_bit = 1 self.ball_bit = 2 self.base.setBackgroundColor(0.64, 0, 0) # First, we build a card to represent the ground cm = CardMaker('ground-card') cm.setFrame(-60, 60, -60, 60) card = self.base.render.attachNewNode(cm.generate()) card.lookAt(0, 0, -1) # align upright #tex = loader.loadTexture('maps/envir-ground.jpg') tex = loader.loadTexture('models/textures/rock12.bmp') card.setTexture(tex) # Then we build a collisionNode which has a plane solid which will be the ground's collision # representation groundColNode = card.attachNewNode(CollisionNode('ground-cnode')) groundColPlane = CollisionPlane(Plane(Vec3(0, -1, 0), Point3(0, 0, 0))) groundColNode.node().addSolid(groundColPlane) # Now, set the ground to the ground mask groundColNode.setCollideMask(BitMask32().bit(self.ground_bit)) # Why aren't we adding a collider? There is no need to tell the collision traverser about this # collisionNode, as it will automatically be an Into object during traversal. # enable forces self.base.enableParticles() node = NodePath("PhysicsNode") node.reparentTo(self.base.render) # may want to have force dependent on mass eventually, # but at the moment assume all balls same weight self.force_mag = 200 # gravity gravity_fn = ForceNode('world-forces') gravity_fnp = self.base.render.attachNewNode(gravity_fn) gravity_force = LinearVectorForce(0.0, 0.0, -9.81) gravity_fn.addForce(gravity_force) self.base.physicsMgr.addLinearForce(gravity_force) # wind wind_fn = ForceNode('world-forces') wind_fnp = self.base.render.attachNewNode(wind_fn) wind_force = LinearVectorForce(1.0, 0.5, 0.0) wind_fn.addForce(wind_force) self.base.physicsMgr.addLinearForce(wind_force) # spurt out of fountain, bounce self.spurt = ForceNode("spurt") spurt_np = self.base.render.attachNewNode(self.spurt) # create a list for our ball actors, not sure if I need this, but seems likely self.ball_actors = [] # make a teapot teapot = loader.loadModel('teapot.egg') tex = loader.loadTexture('maps/color-grid.rgb') #teapot.setTexGen(TextureStage.getDefault(), TexGenAttrib.MWorldPosition) teapot.setTexture(tex) teapot.reparentTo(self.base.render) teapot.setPos(-5, 10, 10) # create the first ball: #ball = self.create_a_ball() #self.enliven_ball(ball) smiley = loader.loadModel('smiley.egg') lerper = NodePath('lerper') smiley.setTexProjector(TextureStage.getDefault(), NodePath(), lerper) smiley.reparentTo(self.base.render) smiley.setPos(5, 10, 10) i = lerper.posInterval(5, VBase3(0, 1, 0)) i.loop() # Tell the messenger system we're listening for smiley-into-ground messages and invoke our callback self.base.accept('ball_cnode-into-ground-cnode', self.ground_callback) ball_fountain = taskMgr.doMethodLater(.5, self.spurt_balls, 'tickTask')
def quad_move(self, task): position_proportionality_constant = 0.0007 angle_proportionality_constant = 0.2 angle_max = 10 angle_directions = {i: k, j: -j} keys_vs_moves = {'w': i, 's': -i, 'a': j, 'd': -j, 'e': k, 'q': -k} move_total = LPoint3f(0, 0, 0) angle_total = LPoint3f(0, 0, 0) for key, move in keys_vs_moves.items(): pressed_key = self.mouseWatcherNode.is_button_down(KeyboardButton.asciiKey(key)) if pressed_key: move_total += move if key not in ['e', 'q', 'm']: angle_total += LPoint3f(*tuple(sign(move) * np.array( angle_directions[LPoint3f(*tuple(int(abs(c)) for c in move))]) * angle_proportionality_constant)) else: prop_sign = 1 if key == 'e' else -1 for prop in self.prop_models: prop.setHpr(prop.get_hpr() + LPoint3f(10 * prop_sign, 0, 0)) self.movements += key with open(ROOT_DIR + self.simulation_folder + 'movements.txt', 'w') as file: file.write(self.movements) # self.movie(namePrefix=self.simulation_folder, duration=1.0, fps=30, # format='png', sd=4, source=None) if any([abs(coordinate) > 0 for coordinate in angle_total]): # tilt_force_node = ForceNode('tilt-force') # tilt_force = AngularVectorForce(*angle_total) # tilt_force_node.addForce(tilt_force) # # self.actor_node.getPhysical(0).addAngularForce(tilt_force) desired_quad_hpr = list(self.quad_model.getHpr() + angle_total) for index, coordinate in enumerate(desired_quad_hpr): if coordinate: desired_quad_hpr[index] = sign(coordinate) * min(abs(coordinate), 90 + angle_max if index == 0 else angle_max) desired_quad_hpr = LPoint3f(*desired_quad_hpr) self.quad_model.setHpr(desired_quad_hpr) if any([abs(coordinate) > 0 for coordinate in move_total]): movement_force_node = ForceNode('movement-force') movement_force = LinearVectorForce(*(- move_total * position_proportionality_constant)) # movement_force.setMassDependent(1) movement_force_node.addForce(movement_force) self.actor_node.getPhysical(0).addLinearForce(movement_force) # time.sleep(0.1) # thruster.setP(-45) # bend the thruster nozzle out at 45 degrees # desired_quad_pos = self.quad_model.getPos() + move_total * position_proportionality_constant # self.quad_model.setPos(desired_quad_pos) return task.cont
class Bullet(DirectObject): def __init__(self, playerID, color=LPoint3f(0,0,0)): self.color = color self.playerID = playerID self.bulletNP = NodePath("Bullet-%d" % id(self)) self.bulletAN = ActorNode("bullet-physics-%d" % id(self)) # set the mass of the ball to 3.3g = average weight of a paintball self.bulletAN.getPhysicsObject().setMass(0.033) self.bulletANP = self.bulletNP.attachNewNode(self.bulletAN) base.physicsMgr.attachPhysicalNode(self.bulletAN) self.bullet = loader.loadModel("Bullet") self.bullet.setScale(2) self.bullet.setColorScale( self.color.getX(), self.color.getY(), self.color.getZ(), 1.0) self.bullet.reparentTo(self.bulletANP) # setup the collision detection # 17.3 mm (0.0173) = size of a .68cal paintball self.bulletColName = "bulletCollision-%02d" % id(self) self.bulletSphere = CollisionSphere(0, 0, 0, 0.0173*2) self.bulletCollision = self.bulletANP.attachNewNode(CollisionNode(self.bulletColName)) self.bulletCollision.node().addSolid(self.bulletSphere) #self.bulletCollision.show() base.physicpusher.addCollider(self.bulletCollision, self.bulletANP) base.cTrav.addCollider(self.bulletCollision, base.physicpusher) def shoot(self, pos, shootVec=None): if shootVec != None: v = shootVec v *= 214.0 else: # Get from/to points from mouse click pMouse = base.mouseWatcherNode.getMouse() pFrom = Point3() pTo = Point3() base.camLens.extrude(pMouse, pFrom, pTo) pFrom = render.getRelativePoint(base.cam, pFrom) pTo = render.getRelativePoint(base.cam, pTo) # Calculate initial velocity v = pTo - pFrom v.normalize() v *= 214.0 self.bulletNP.setPos(pos) self.bulletNP.reparentTo(render) self.bulletFN = ForceNode("Bullet-force-%d" % id(self)) self.bulletFNP = self.bulletNP.attachNewNode(self.bulletFN) # speed of a paintball when he leafes the muzzle: 214 fps self.lvf = LinearVectorForce(v) self.lvf.setMassDependent(1) self.bulletFN.addForce(self.lvf) self.bulletAN.getPhysical(0).addLinearForce(self.lvf) self.accept("bulletCollision-%d-hit" % id(self), self.bulletHit) taskMgr.doMethodLater( 2, self.doRemove, 'doRemove-%d' % id(self), appendTask=True) def doRemove(self, task): if self is None: return task.done self.ignoreAll() self.bulletNP.removeNode() self.bulletAN.getPhysical(0).removeLinearForce(self.lvf) return task.done def bulletHit(self, entry): hitName = entry.getIntoNode().getName() if str(self.playerID) not in hitName and \ self.bulletColName not in hitName: base.messenger.send("Bulet-hit-%s" % hitName, [entry, self.color]) self.bulletNP.removeNode() self.bulletAN.getPhysical(0).removeLinearForce(self.lvf)
if __name__ == "__main__": from direct.directbase.TestStart import * from panda3d.physics import LinearVectorForce from panda3d.core import Vec3 import ParticleEffect from direct.tkpanels import ParticlePanel import Particles import ForceGroup # Showbase base.enableParticles() # ForceGroup fg = ForceGroup.ForceGroup() gravity = LinearVectorForce(Vec3(0.0, 0.0, -10.0)) fg.addForce(gravity) # Particles p = Particles.Particles() # Particle effect pe = ParticleEffect.ParticleEffect('particle-fx') pe.reparentTo(render) #pe.setPos(0.0, 5.0, 4.0) pe.addForceGroup(fg) pe.addParticles(p) # Particle Panel pp = ParticlePanel.ParticlePanel(pe)
def shred(self): self.reset() self.setPos(0.000, 3.000, 2.300) self.setHpr(0.000, 0.000, 0.000) self.setScale(1.000, 1.000, 1.000) p0 = Particles.Particles('particles-1') p0.setFactory("PointParticleFactory") p0.setRenderer("SpriteParticleRenderer") p0.setEmitter("SphereVolumeEmitter") p0.setPoolSize(60) p0.setBirthRate(0.0600) p0.setLitterSize(3) p0.setLitterSpread(1) p0.setSystemLifespan(0.0000) p0.setLocalVelocityFlag(1) p0.setSystemGrowsOlderFlag(0) p0.factory.setLifespanBase(1.9000) p0.factory.setLifespanSpread(0.4000) p0.factory.setMassBase(1.0000) p0.factory.setMassSpread(0.2000) p0.factory.setTerminalVelocityBase(400.0000) p0.factory.setTerminalVelocitySpread(0.0000) p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHANONE) p0.renderer.setUserAlpha(1.00) p0.renderer.setIgnoreScale(1) p0.renderer.setTextureFromNode("phase_3.5/models/props/suit-particles", "**/roll-o-dex") p0.renderer.setColor(Vec4(1.00, 1.00, 1.00, 1.00)) p0.renderer.setXScaleFlag(0) p0.renderer.setYScaleFlag(0) p0.renderer.setAnimAngleFlag(0) p0.renderer.setInitialXScale(0.0160) p0.renderer.setFinalXScale(0.0240) p0.renderer.setInitialYScale(0.3200) p0.renderer.setFinalYScale(0.0800) p0.renderer.setNonanimatedTheta(5.0000) p0.renderer.setAlphaBlendMethod(BaseParticleRenderer.PPBLENDLINEAR) p0.renderer.setAlphaDisable(0) p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE) p0.emitter.setAmplitude(5.0000) p0.emitter.setAmplitudeSpread(1.0000) p0.emitter.setOffsetForce(Vec3(0.0000, 3.0000, 0.0000)) p0.emitter.setExplicitLaunchVector(Vec3(1.0000, 0.0000, 0.0000)) p0.emitter.setRadiateOrigin(Point3(0.0000, -7.0000, 0.0000)) p0.emitter.setRadius(0.6000) self.addParticles(p0) f0 = ForceGroup.ForceGroup('forces') force0 = LinearVectorForce(Vec3(0.0000, 0.0000, 5.0000), 1.0000, 0) force0.setActive(1) f0.addForce(force0) force1 = LinearSinkForce(Point3(0.0000, 0.0000, -8.0000), LinearDistanceForce.FTONEOVERRSQUARED, 14.5479, 155.9407, 1) force1.setActive(1) f0.addForce(force1) force2 = LinearNoiseForce(1.7000, 0) force2.setActive(1) f0.addForce(force2) force3 = LinearJitterForce(12.5698, 0) force3.setActive(1) f0.addForce(force3) self.addForceGroup(f0)