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