def getClickBox(self):
return [Vec3(-1), Vec3(1)]
def updatePostAttackPosLerp(self):
suitPos = self.suit.getPos(render)
finalPos = suitPos + Vec3(0, -Globals.LegalEagle.PostAttackLength, 0)
self.postAttackPosLerp.setStartPos(suitPos)
self.postAttackPosLerp.setEndPos(finalPos)
DEFAULT_HORIZON_SCALE = 0.05 MISSILE_SCALE = .29 GRENADE_SCALE = .35 # collision bitmask constants NO_COLLISION_BITS = BitMask32.all_off() MAP_COLLIDE_BIT = BitMask32.bit(0) SOLID_COLLIDE_BIT = BitMask32.bit(1) GHOST_COLLIDE_BIT = BitMask32.bit(2) # physics contstants EXPLOSIONS_DONT_PUSH = ["expl", "ground"] DEFAULT_GRAVITY = Vec3(0, -9.81, 0) DEFAULT_FRICTION = 1 AIR_FRICTION = 0.02 # weapons stuff PLASMA_SCALE = .3 MIN_PLASMA_CHARGE = .4 WALKER_RECHARGE_FACTOR = .23 WALKER_ENERGY_TO_GUN_CHARGE = (.10, .36) WALKER_MIN_CHARGE_ENERGY = .2 PLASMA_LIFESPAN = 900 PLASMA_SOUND_FALLOFF = 20 MISSILE_LIFESPAN = 600 # missile/grenade engine color lists in rgb decimal format
def __init__(self):
ShowBase.__init__(self)
self.world = loader.loadModel("environment")
self.world.reparentTo(render)
self.world.setScale(0.5)
self.world.setPos(-8, 80, 0)
self.panda = Actor("panda", {"walk": "panda-walk"})
self.panda.reparentTo(render)
self.panda.setHpr(270, 0, 0)
self.panda.loop("walk")
self.walkIval1 = self.panda.posInterval(2, Vec3(-8, -8, 0), startPos = Vec3(8, -8, 0))
self.walkIval2 = self.panda.posInterval(2, Vec3(-8, 8, 0), startPos = Vec3(-8, -8, 0))
self.walkIval3 = self.panda.posInterval(2, Vec3(8, 8, 0), startPos = Vec3(-8, 8, 0))
self.walkIval4 = self.panda.posInterval(2, Vec3(8, -8, 0), startPos = Vec3(8, 8, 0))
self.turnIval1 = self.panda.hprInterval(0.5, Vec3(180, 0, 0), startHpr = Vec3(270, 0, 0))
self.turnIval2 = self.panda.hprInterval(0.5, Vec3(90, 0, 0), startHpr = Vec3(180, 0, 0))
self.turnIval3 = self.panda.hprInterval(0.5, Vec3(0, 0, 0), startHpr = Vec3(90, 0, 0))
self.turnIval4 = self.panda.hprInterval(0.5, Vec3(-90, 0, 0), startHpr = Vec3(0, 0, 0))
self.pandaWalk = Sequence(self.walkIval1, self.turnIval1,
self.walkIval2, self.turnIval2,
self.walkIval3, self.turnIval3,
self.walkIval4, self.turnIval4)
self.pandaWalk.loop()
self.followCam = FollowCam(self.cam, self.panda)
def update(self):
x, y, z = self.xyz
coordinates = [[x, y, z], [x, -y, z], [-x, -y, z], [-x, y, z]]
self.targets.clear()
targets = [Vec3(x, y, z) for x, y, z in coordinates]
self.targets += targets
def doBillboardEffect(self):
billboardEffect = BillboardEffect.make(
Vec3(0, 0, 1), True, False, self.billboardOffset, base.cam,
Point3(0, 0, 0))
self.contents.setEffect(billboardEffect)
def setup(self):
# Debug (useful to turn on for physics)
self.debugNP = self.render.attachNewNode(BulletDebugNode('Debug'))
self.debugNP.hide()
# Physics World
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.world.setDebugNode(self.debugNP.node())
# Main Character
self.player = Player()
self.player.createPlayer(render, self.world)
# Enemies
self.createEnemies()
# Music
self.backgroundMusic = loader.loadSfx(
'../sounds/elfman-piano-solo.ogg')
self.backgroundMusic.setLoop(True)
self.backgroundMusic.stop()
self.backgroundMusic.setVolume(
0.9) # lower this when I add sound effects
# Sound Effects
self.collect = base.loader.loadSfx("../sounds/collect-sound.wav")
self.collect.setVolume(1)
self.damage = base.loader.loadSfx("../sounds/damage.wav")
self.damage.setVolume(0.5)
self.winner = base.loader.loadSfx("../sounds/win-yay.wav")
self.winner.setVolume(1)
self.dead = base.loader.loadSfx("../sounds/severe-damage.wav")
self.dead.setVolume(1)
# Level 1 Skybox
self.skybox = loader.loadModel('../models/skybox_galaxy.egg')
self.skybox.setScale(1000) # make big enough to cover whole terrain
self.skybox.setBin('background', 1)
self.skybox.setDepthWrite(0)
self.skybox.setLightOff()
self.skybox.reparentTo(render)
# Lighting
dLight = DirectionalLight("dLight")
dLight.setColor(Vec4(0.8, 0.8, 0.5, 1))
dLight.setDirection(Vec3(-5, -5, -5))
dlnp = render.attachNewNode(dLight)
dlnp.setHpr(0, 60, 0)
render.setLight(dlnp)
aLight = AmbientLight("aLight")
aLight.setColor(Vec4(0.5, 0.5, 0.5, 1))
alnp = render.attachNewNode(aLight)
render.setLight(alnp)
# Fog
colour = (0.2, 0.2, 0.3)
genfog = Fog("general fog")
genfog.setColor(*colour)
genfog.setExpDensity(0.003)
render.setFog(genfog)
base.setBackgroundColor(*colour)
# Create wall (x, y, z, h)
self.createWall(-30.2215, -6.2, -2, 45)
self.createWall(-203, 555.8, -2, 70)
#-----Level 1 Platforms-----
# Platform to collect B
self.createPlatform(72, 70.2927, -1)
# Platforms to collect R
self.createPlatform(211, 210, -1)
self.createPlatform(225, 223, 2.7)
# Platforms to collect E and A
self.createPlatform(330, 462, -0.4)
self.createPlatform(340, 471, 2.1)
self.createPlatform(350, 480, 4)
self.createPlatform(335, 483, 5)
# Platforms to collect K
self.createPlatform(184, 712, -1)
self.createPlatform(208, 730, -1)
self.createPlatform(207, 711, -1)
self.createPlatform(186, 731, -1)
#-----Level 2 Platforms-----
# Moving platforms
if self.movingPlatforms > 0:
del self.movingPlatforms[:]
self.createMovingPlatforms()
# Create complex mesh for Track using BulletTriangleMeshShape
mesh = BulletTriangleMesh()
self.track = loader.loadModel("../models/mountain_valley_track.egg")
self.track.flattenStrong()
for geomNP in self.track.findAllMatches('**/+GeomNode'):
geomNode = geomNP.node()
ts = geomNP.getTransform(self.track)
for geom in geomNode.getGeoms():
mesh.addGeom(geom, ts)
shape = BulletTriangleMeshShape(mesh, dynamic=False)
node = BulletRigidBodyNode('Track')
node.setMass(0)
node.addShape(shape)
tracknn = render.attachNewNode(node)
self.world.attachRigidBody(tracknn.node())
tracknn.setPos(27, -5, -2)
self.track.reparentTo(tracknn)
def world_scale(self):
scale = self.getScale(base.render)
return Vec3(scale[0], scale[2], scale[1])
def world_scale(self, value):
if isinstance(value, (int, float, complex)):
value = (value, value, value)
self.setScale(base.render, Vec3(value[0], value[2], value[1]))
def world_rotation(self):
rotation = self.getHpr(base.render)
return Vec3(-rotation[1], -rotation[0], rotation[2])
def rotation(self):
rotation = self.getHpr()
return Vec3(-rotation[1], -rotation[0], rotation[2])
def position(self):
return Vec3(self.getX(), self.getZ(), self.getY())
def world_position(self, value):
value = Vec3(value[0], value[2], value[1])
self.setPos(render, value)
def __setattr__(self, name, value):
if name == 'enabled':
try:
# try calling on_enable() on classes inheriting from Entity
if value == True:
self.on_enable()
else:
self.on_disable()
except:
pass
if value == True:
if not self.is_singleton():
self.unstash()
else:
if not self.is_singleton():
self.stash()
if name == 'eternal':
for c in self.children:
c.eternal = value
if name == 'world_parent':
self.reparent_to(value)
if name == 'model':
if value is None:
if hasattr(self, 'model') and self.model:
self.model.removeNode()
# print('removed model')
object.__setattr__(self, name, value)
return None
if isinstance(value, NodePath): # pass procedural model
if self.model is not None and value != self.model:
self.model.removeNode()
object.__setattr__(self, name, value)
elif isinstance(value, str): # pass model asset name
m = load_model(value, application.asset_folder)
if not m:
m = load_model(value, application.internal_models_folder)
if m:
if self.model is not None:
self.model.removeNode()
object.__setattr__(self, name, m)
if isinstance(m, Mesh):
m.recipe = value
# print('loaded model successively')
else:
print('missing model:', value)
return
if self.model:
self.model.reparentTo(self)
self.model.setTransparency(TransparencyAttrib.M_dual)
setattr(self, 'color', self.color) # reapply color after changing model
setattr(self, 'texture', self.texture) # reapply texture after changing model
self._vert_cache = None
if isinstance(value, Mesh):
if hasattr(value, 'on_assign'):
value.on_assign(assigned_to=self)
return
if name == 'color' and value is not None:
if not isinstance(value, Vec4):
value = Vec4(value[0], value[1], value[2], value[3])
if self.model:
self.model.setColorScale(value)
object.__setattr__(self, name, value)
if name == 'texture_scale':
if self.model and self.texture:
self.model.setTexScale(TextureStage.getDefault(), value[0], value[1])
if name == 'texture_offset':
if self.model and self.texture:
self.model.setTexOffset(TextureStage.getDefault(), value[0], value[1])
self.texture = self.texture
if name == 'position':
# automatically add position instead of extending the tuple
new_value = Vec3()
if len(value) % 2 == 0:
for i in range(0, len(value), 2):
new_value.add_x(value[i])
new_value.add_y(value[i+1])
new_value.add_z(self.getY())
if len(value) % 3 == 0:
for i in range(0, len(value), 3):
new_value.add_x(value[i])
new_value.add_y(value[i+1])
new_value.add_z(value[i+2])
try:
self.setPos(new_value[0], new_value[2], new_value[1])
except:
pass # can't set position
if name == 'x': self.setX(value)
if name == 'y': self.setZ(value)
if name == 'z': self.setY(value)
if name == 'origin' and self.model:
new_value = Vec3()
if len(value) % 2 == 0:
for i in range(0, len(value), 2):
new_value.add_x(value[i])
new_value.add_y(value[i+1])
new_value.add_z(self.model.getY())
if len(value) % 3 == 0:
for i in range(0, len(value), 3):
new_value.add_x(value[i])
new_value.add_y(value[i+1])
new_value.add_z(value[i+2])
self.model.setPos(-new_value[0], -new_value[2], -new_value[1])
object.__setattr__(self, name, new_value)
return
if name == 'rotation':
new_value = Vec3()
if len(value) % 2 == 0:
for i in range(0, len(value), 2):
new_value.add_x(value[i])
new_value.add_y(value[i+1])
new_value.add_z(self.getR())
if len(value) % 3 == 0:
for i in range(0, len(value), 3):
new_value.add_x(value[i])
new_value.add_y(value[i+1])
new_value.add_z(value[i+2])
self.setHpr(Vec3(-new_value[1], -new_value[0], new_value[2]))
if name == 'rotation_x': self.setP(-value)
if name == 'rotation_y': self.setH(-value)
if name == 'rotation_z': self.setR(value)
if name == 'scale':
if isinstance(value, (int, float, complex)):
value = (value, value, value)
new_value = Vec3()
if len(value) % 2 == 0:
for i in range(0, len(value), 2):
new_value.add_x(value[i])
new_value.add_y(value[i+1])
new_value.add_z(self.getSy())
if len(value) % 3 == 0:
for i in range(0, len(value), 3):
new_value.add_x(value[i])
new_value.add_y(value[i+1])
new_value.add_z(value[i+2])
for e in new_value:
if e == 0:
e = .001
self.setScale(new_value[0], new_value[2], new_value[1])
if name == 'scale_x':
self.set_scale(value, self.scale_z, self.scale_y)
if name == 'scale_y':
self.set_scale(self.scale_x, self.scale_z, value)
if name == 'scale_z':
self.set_scale(self.scale_x, value, self.scale_y)
if name == 'collision' and hasattr(self, 'collider') and self.collider:
if value:
self.collider.node_path.unstash()
else:
self.collider.node_path.stash()
object.__setattr__(self, name, value)
return
if name == 'render_queue':
if self.model:
self.model.setBin('fixed', value)
if name == 'double_sided':
self.setTwoSided(value)
try:
super().__setattr__(name, value)
except:
pass
def set_position(self, value, relative_to=scene):
self.setPos(relative_to, Vec3(value[0], value[2], value[1]))
def world_scale_z(self, value):
self.setScale(base.render, Vec3(self.world_scale_x, value, self.world_scale_y))
def animate_scale(self, value, duration=.1, delay=0, curve=curve.in_expo, resolution=None, interrupt=True, time_step=None):
if isinstance(value, (int, float, complex)):
value = Vec3(value, value, value)
return self.animate('scale', value, duration, delay, curve, resolution, interrupt, time_step)
def scale(self):
scale = self.getScale()
return Vec3(scale[0], scale[2], scale[1])
def camera_init(self):
x, y, z = self.player.get_position()
self.camera.setPos(Vec3(x, y + 10, z + 17))
self.camera.setHpr(180, -15, 0)
self.camera.reparentTo(self.player.actor)
def forward(self):
vec = render.getRelativeVector(self, (0, 1, 0))
return Vec3(vec[0], vec[2], vec[1])
def update(self, keys, dt):
GameObject.update(self, dt)
self.walking = False
if keys["up"]:
self.walking = True
self.velocity.addY(self.acceleration*dt)
if keys["down"]:
self.walking = True
self.velocity.addY(-self.acceleration*dt)
if keys["left"]:
self.walking = True
self.velocity.addX(-self.acceleration*dt)
if keys["right"]:
self.walking = True
self.velocity.addX(self.acceleration*dt)
if self.walking:
standControl = self.actor.getAnimControl("stand")
if standControl.isPlaying():
standControl.stop()
walkControl = self.actor.getAnimControl("walk")
if not walkControl.isPlaying():
self.actor.loop("walk")
else:
standControl = self.actor.getAnimControl("stand")
if not standControl.isPlaying():
self.actor.stop("walk")
self.actor.loop("stand")
mouseWatcher = base.mouseWatcherNode
if mouseWatcher.hasMouse():
mousePos = mouseWatcher.getMouse()
else:
mousePos = self.lastMousePos
mousePos3D = Point3()
nearPoint = Point3()
farPoint = Point3()
base.camLens.extrude(mousePos, nearPoint, farPoint)
self.groundPlane.intersectsLine(mousePos3D,
render.getRelativePoint(base.camera, nearPoint),
render.getRelativePoint(base.camera, farPoint))
firingVector = Vec3(mousePos3D - self.actor.getPos())
firingVector2D = firingVector.getXy()
firingVector2D.normalize()
firingVector.normalize()
heading = self.yVector.signedAngleDeg(firingVector2D)
self.actor.setH(heading)
if keys["shoot"]:
if self.rayQueue.getNumEntries() > 0:
self.rayQueue.sortEntries()
rayHit = self.rayQueue.getEntry(0)
hitPos = rayHit.getSurfacePoint(render)
hitNodePath = rayHit.getIntoNodePath()
if hitNodePath.hasPythonTag("owner"):
hitObject = hitNodePath.getPythonTag("owner")
if not isinstance(hitObject, TrapEnemy):
hitObject.alterHealth(self.damagePerSecond*dt)
beamLength = (hitPos - self.actor.getPos()).length()
self.beamModel.setSy(beamLength)
self.beamModel.show()
else:
self.beamModel.hide()
if firingVector.length() > 0.001:
self.ray.setOrigin(self.actor.getPos())
self.ray.setDirection(firingVector)
self.lastMousePos = mousePos
def right(self):
vec = render.getRelativeVector(self, (1, 0, 0))
return Vec3(vec[0], vec[2], vec[1])
def __init__(self, character_list):
super().__init__(self)
self.clock = 0
for character in character_list:
character.HP = character.BaseHP
# displayHP(Character)
self.characterList = character_list
self.buttons = []
self.index = 0
# Set up the World
# The World
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -gravity))
# Camera
self.cam.setPos(0, -15, 2)
self.cam.lookAt(0, 0, 0)
# The Ground
np = self.render.attachNewNode(BulletRigidBodyNode('Ground'))
np.node().addShape(BulletPlaneShape(Vec3(0, 0, 1), 1))
np.setPos(0, 0, -2)
self.world.attachRigidBody(np.node())
# Characters
character_list[0].insert(self.world, self.render, -1, (-2, 0))
character_list[1].insert(self.world, self.render, 1, (2, 0))
# Debug
debug_node = BulletDebugNode('Debug')
debug_node.showWireframe(True)
debug_node.showConstraints(False)
debug_node.showBoundingBoxes(False)
debug_node.showNormals(False)
self.debugNP = self.render.attachNewNode(debug_node)
self.debugNP.show()
self.world.setDebugNode(self.debugNP.node())
debug_object = DirectObject()
debug_object.accept('f1', self.toggle_debug)
# Testing Controls
shoulder_moving_object = ShoulderMovingObject(character_list)
target_moving_object = TargetMovingObject()
self.targets = target_moving_object.set_targets(*DefaultTargetPos)
for i in range(3):
shoulder_moving_object.move_arms(i, 0)
self.taskMgr.add(self.update, 'update')
# Set up GUI
self.sharedInfo = OnscreenText(text="No information to display yet.",
pos=(0, 0.5),
scale=0.07,
align=TextNode.ACenter,
mayChange=1)
self.actionBoxes, self.infoBoxes, self.useButtons, self.healthBars = [], [], [], []
self.selectedAction, self.selection = None, None
for side in (LEFT, RIGHT):
action_box = DirectFrame(frameColor=(0, 0, 0, 1),
frameSize=(-frame_width, frame_width,
-frame_height, frame_height),
pos=(side * (window_width - frame_width),
0, -(window_height - frame_height)))
info_box = OnscreenText(text="No info available",
scale=0.07,
align=TextNode.ACenter,
mayChange=1)
info_box.reparentTo(action_box)
info_box.setPos(0, frame_height + 0.25)
use_button = DirectButton(frameSize=(-button_width, button_width,
-button_height,
button_height),
text="N/A",
text_scale=0.1,
borderWidth=(0.025, 0.025),
command=self.use_action,
state=DGG.DISABLED)
use_button.reparentTo(action_box)
use_button.setPos(frame_width - button_width, 0, 0)
hp = self.characterList[0 if side < 0 else side].HP
bar = DirectWaitBar(text="",
range=hp,
value=hp,
pos=(side * 0.5, 0, 0.75),
frameSize=(side * -0.4, side * 0.5, 0, -0.05))
self.actionBoxes.append(action_box)
self.infoBoxes.append(info_box)
self.useButtons.append(use_button)
self.healthBars.append(bar)
self.query_action()
def up(self):
vec = render.getRelativeVector(self, (0, 0, 1))
return Vec3(vec[0], vec[2], vec[1])
def initIntervals(self):
dur = Globals.LegalEagle.LiftOffTime
nestPos = self.nest.getPos(render)
airPos = nestPos + Vec3(0.0, 0.0, Globals.LegalEagle.LiftOffHeight)
self.takeOffSeq = Sequence(Parallel(
Sequence(
Wait(dur * 0.6),
LerpPosInterval(self.suit,
dur * 0.4,
startPos=nestPos,
pos=airPos,
blendType='easeInOut'))),
Wait(1.5),
Func(self.request, 'next'),
name='%s.takeOffSeq-%i' %
(self.__class__.__name__, self.index))
self.landOnNestPosLerp = LerpPosInterval(self.suit,
1.0,
startPos=airPos,
pos=nestPos,
blendType='easeInOut')
self.landingSeq = Sequence(Func(self.updateLandOnNestPosLerp),
Parallel(self.landOnNestPosLerp),
Func(self.request, 'next'),
name='%s.landingSeq-%i' %
(self.__class__.__name__, self.index))
dur = Globals.LegalEagle.ChargeUpTime
self.chargeUpPosLerp = LerpFunc(
self.moveAlongChargeUpMopathFunc,
fromData=0.0,
toData=self.chargeUpMotionPath.getMaxT(),
duration=dur,
blendType='easeInOut')
self.chargeUpAttackSeq = Sequence(
Func(self.updateChargeUpPosLerp),
self.chargeUpPosLerp,
Func(self.request, 'next'),
name='%s.chargeUpAttackSeq-%i' %
(self.__class__.__name__, self.index))
dur = Globals.LegalEagle.RetreatToNestTime
self.retreatToNestPosLerp = LerpPosInterval(self.suit,
dur,
startPos=Vec3(0, 0, 0),
pos=airPos,
blendType='easeInOut')
self.retreatToNestSeq = Sequence(Func(self.updateRetreatToNestPosLerp),
self.retreatToNestPosLerp,
Func(self.request, 'next'),
name='%s.retreatToNestSeq-%i' %
(self.__class__.__name__, self.index))
dur = Globals.LegalEagle.RetreatToSkyTime
self.retreatToSkyPosLerp = LerpFunc(
self.moveAlongRetreatMopathFunc,
fromData=0.0,
toData=self.retreatToSkyMotionPath.getMaxT(),
duration=dur,
blendType='easeOut')
self.retreatToSkySeq = Sequence(Func(self.updateRetreatToSkyPosLerp),
self.retreatToSkyPosLerp,
Func(self.request, 'next'),
name='%s.retreatToSkySeq-%i' %
(self.__class__.__name__, self.index))
dur = Globals.LegalEagle.PreAttackTime
self.preAttackLerpXY = LerpFunc(self.updateAttackXY,
fromData=0.0,
toData=1.0,
duration=dur)
self.preAttackLerpZ = LerpFunc(self.updateAttackZ,
fromData=0.0,
toData=1.0,
duration=dur,
blendType='easeOut')
dur = Globals.LegalEagle.PostAttackTime
self.postAttackPosLerp = LerpPosInterval(self.suit,
dur,
startPos=Vec3(0, 0, 0),
pos=Vec3(0, 0, 0))
self.attackSeq = Sequence(
Parallel(self.preAttackLerpXY, self.preAttackLerpZ),
Func(self.updatePostAttackPosLerp),
self.postAttackPosLerp,
Func(self.request, 'next'),
name='%s.attackSeq-%i' % (self.__class__.__name__, self.index))
dur = Globals.LegalEagle.CooldownTime
self.cooldownSeq = Sequence(Wait(dur),
Func(self.request, 'next'),
name='%s.cooldownSeq-%i' %
(self.__class__.__name__, self.index))
self.propTrack = Sequence(
ActorInterval(self.prop, 'propeller', startFrame=0, endFrame=14))
self.hoverOverNestSeq = Sequence(
ActorInterval(self.suit,
'landing',
startFrame=10,
endFrame=20,
playRate=0.5),
ActorInterval(self.suit,
'landing',
startFrame=20,
endFrame=10,
playRate=0.5))
def bounds(self):
return Vec3(
self.model_bounds[0] * self.scale_x,
self.model_bounds[1] * self.scale_y,
self.model_bounds[2] * self.scale_z
)
]
# base.add_system(system) adds the system to the world *and* creates
# a task that will trigger updates. This is how WECS integrates into
# Panda3D's task manager.
for sort, system_type in enumerate(system_types):
base.add_system(system_type(), sort)
# All systems are set up now, so all that's missing are the
# entities.
paddle_left = base.ecs_world.create_entity(
panda3d.Model(),
panda3d.Geometry(file='paddle.bam'),
panda3d.Scene(node=base.aspect2d),
panda3d.Position(value=Vec3(-1.1, 0, 0)),
movement.Movement(value=Vec3(0, 0, 0)),
paddles.Paddle(player=paddles.Players.LEFT),
)
paddle_right = base.ecs_world.create_entity(
panda3d.Model(),
panda3d.Geometry(file='paddle.bam'),
panda3d.Scene(node=base.aspect2d),
panda3d.Position(value=Point3(1.1, 0, 0)),
movement.Movement(value=Vec3(0, 0, 0)),
paddles.Paddle(player=paddles.Players.RIGHT),
)
ball = base.ecs_world.create_entity(
panda3d.Position(value=Point3(0, 0, 0)),
def get_position(self, relative_to=scene):
pos = self.getPos(relative_to)
return Vec3(pos[0], pos[2], pos[1])
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)
def __init__(self):
ShowBase.__init__(self)
self.disableMouse()
properties = WindowProperties()
properties.setSize(1000, 750)
self.win.requestProperties(properties)
mainLight = DirectionalLight("main light")
self.mainLightNodePath = render.attachNewNode(mainLight)
self.mainLightNodePath.setHpr(45, -45, 0)
render.setLight(self.mainLightNodePath)
ambientLight = AmbientLight("ambient light")
ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1))
self.ambientLightNodePath = render.attachNewNode(ambientLight)
render.setLight(self.ambientLightNodePath)
render.setShaderAuto()
self.environment = loader.loadModel("Models/Misc/environment")
self.environment.reparentTo(render)
self.camera.setPos(0, 0, 32)
self.camera.setP(-90)
self.keyMap = {
"up" : False,
"down" : False,
"left" : False,
"right" : False,
"shoot" : False
}
self.accept("w", self.updateKeyMap, ["up", True])
self.accept("w-up", self.updateKeyMap, ["up", False])
self.accept("s", self.updateKeyMap, ["down", True])
self.accept("s-up", self.updateKeyMap, ["down", False])
self.accept("a", self.updateKeyMap, ["left", True])
self.accept("a-up", self.updateKeyMap, ["left", False])
self.accept("d", self.updateKeyMap, ["right", True])
self.accept("d-up", self.updateKeyMap, ["right", False])
self.accept("mouse1", self.updateKeyMap, ["shoot", True])
self.accept("mouse1-up", self.updateKeyMap, ["shoot", False])
self.pusher = CollisionHandlerPusher()
self.cTrav = CollisionTraverser()
self.pusher.setHorizontal(True)
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(-8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(-8.0)
self.updateTask = taskMgr.add(self.update, "update")
self.player = Player(Vec3(0, 0, 0),
"Models/PandaChan/act_p3d_chan",
{
"stand" : "Models/PandaChan/a_p3d_chan_idle",
"walk" : "Models/PandaChan/a_p3d_chan_run"
},
5,
10,
"player")
self.tempEnemy = WalkingEnemy(Vec3(5, 0, 0))
