def __init__(self, space, pos, dim, surface=SurfaceType.FLOOR):
'''
kirjoita numerot float muodossa 1.0
@param space: fysiikka-avaruus?
'''
MovingPlane.id += 1
self.id = id
self.dim = dim # dimension
self.pos = pos # position
self.h = (dim[0] / 2, dim[1] / 2, dim[2] / 2) # center
self.t = 0
self.geom = OdeBoxGeom(space, dim[0], dim[1], dim[2])
space.setSurfaceType(self.geom, surface)
self.model = loader.loadModel(self.MODEL)
self.model.setScale(dim[0], dim[1], dim[2])
# http://www.panda3d.org/wiki/index.php/Creating_a_New_Node_Class
self.model.flattenLight()
self.model.reparentTo(render)
self.rotate = False
if surface == SurfaceType.SAND:
self.model.setColor(1, 0, 0)
self.updateModelNode()
def createCubicObstacle(self, pos, obstacleIndex):
self.notify.debug('create obstacleindex %s' % obstacleIndex)
sideLength = IceGameGlobals.TireRadius * 2
geom = OdeBoxGeom(self.space, sideLength, sideLength, sideLength)
geom.setCollideBits(self.allTiresMask)
geom.setCategoryBits(self.obstacleMask)
self.space.setCollideId(geom, self.obstacleCollideId)
tireModel = loader.loadModel('phase_4/models/minigames/ice_game_crate')
tireModel.setPos(pos)
tireModel.reparentTo(render)
geom.setPosition(tireModel.getPos())
tireModel.setZ(0)
return tireModel
def __init__(self, world):
GameObject.__init__(self, world)
# Set the speed parameters
self.vel = Vec3(0, 0, 0)
self.strafespeed = 20.0
self.forwardspeed = 32.0
self.backspeed = 24.0
self.jumpspeed = 20
self.wasJumping = False
# Set character dimensions
self.size = (4.0, 3.0, 10.0)
self.eyeHeight = 9.0
self.offset = Point3(0, 0, self.eyeHeight - (self.size[2]/2))
# Create character node
self.node = base.render.attachNewNode("character")
self.node.setPos(0, 0, self.eyeHeight)
self.node.lookAt(0, 1, self.eyeHeight)
# Create physics representation
self.mass = OdeMass()
self.mass.setBox(50, *self.size)
self.body = OdeBody(world.world)
self.body.setMass(self.mass)
self.updatePhysicsFromPos()
self.body.setData(self)
self.geom = OdeBoxGeom(world.space, Vec3(*self.size))
self.geom.setBody(self.body)
world.space.setSurfaceType(self.geom, world.surfaces["box"])
# Adjust collision bitmasks.
self.geom.setCategoryBits(GameObject.bitmaskCharacter)
self.geom.setCollideBits(GameObject.bitmaskAll & ~GameObject.bitmaskBullet)
# Setup event handling
self.keys = [0, 0, 0, 0, 0]
self.setupKeys()
base.taskMgr.add(self.moveTask, "character-move")
# Create footsteps sound
self.footstepsSound = base.loader.loadSfx("media/footsteps.wav")
self.footstepsSound.setLoop(1)
self.footsteps = SoundWrapper(self.footstepsSound)
# Create other sounds.
self.jumpSound = base.loader.loadSfx("media/jump_start.wav")
self.landSound = base.loader.loadSfx("media/jump_fall.wav")
def __init__(self, world, parent, color, pos, dir, size, density, unglueThreshold=None, shatterLimit=None, shatterThreshold=None):
GameObject.__init__(self, world)
if unglueThreshold == None: unglueThreshold = 20
if shatterLimit == None: shatterLimit = 0
if shatterThreshold == None: shatterThreshold = 30
self.size = size
self.density = density
self.dir = dir
self.parent = parent
self.color = color = makeVec4Color(color)
self.node = parent.attachNewNode("")
self.node.setPos(*pos)
self.node.setColorScale(color)
self.node.setScale(*size)
self.node.lookAt(self.node, *dir)
self.model = loader.loadModel("models/box.egg")
self.model.reparentTo(self.node)
self.model.setScale(2.0)
self.model.setPos(-1.0, -1.0, -1.0)
self.applyTexture()
self.mass = OdeMass()
self.mass.setBox(density, Vec3(*size) * 2)
self.body = OdeBody(world.world)
self.body.setMass(self.mass)
self.body.setPosition(self.node.getPos())
self.body.setQuaternion(self.node.getQuat())
self.body.setData(self)
self.geom = OdeBoxGeom(world.space, Vec3(*size) * 2.0)
self.geom.setBody(self.body)
world.space.setSurfaceType(self.geom, world.surfaces["box"])
# Adjust collision bitmasks.
self.geom.setCategoryBits(GameObject.bitmaskBox)
self.geom.setCollideBits(GameObject.bitmaskAll & ~GameObject.bitmaskTileGlued)
# Tile, cement and shatter variables.
self.tiles = []
self.cements = []
self.disableCount = 0
self.unglueThreshold = unglueThreshold
self.shatterLimit = shatterLimit
self.shatterThreshold = shatterThreshold
def createCubicObstacle(self, pos, obstacleIndex):
"""Create one physics obstacle. Returns a nodePath"""
self.notify.debug("create obstacleindex %s" % (obstacleIndex))
sideLength = IceGameGlobals.TireRadius * 2
geom = OdeBoxGeom(self.space, sideLength, sideLength, sideLength)
geom.setCollideBits(self.allTiresMask) # we only collide against tires
geom.setCategoryBits(self.obstacleMask)
self.space.setCollideId(geom, self.obstacleCollideId)
#tireModel = render.attachNewNode('cubicObstacle-%d'% obstacleIndex)
#BuildGeometry.addBoxGeom(tireModel, sideLength, sideLength, sideLength)
#tireModel.setPos(pos)
#tireModel.setColor(0.5,0.5,0.5)
tireModel = loader.loadModel("phase_4/models/minigames/ice_game_crate")
tireModel.setPos(pos)
tireModel.reparentTo(render)
geom.setPosition(tireModel.getPos())
# the real assets are set at Z zero
tireModel.setZ(0)
return tireModel
def setVehicle(self, model):
'''
Choose what vehicle the player has chosen. This method initializes all data of this vehicle
'''
self.cleanResources()
self._notify.debug("Set new vehicle: %s" % model)
# Load the attributes of the vehicle
attributes = model.find("**/Attributes")
if attributes.isEmpty():
self._notify.warning("No Attribute-Node found")
for tag in self._tags:
value = attributes.getNetTag(tag[0])
if value:
self._notify.debug("%s: %s" % (tag[0], value))
# translate the value if its a string
if type(tag[2](value)) == str:
tag[1](_(tag[2](value)))
else:
tag[1](tag[2](value))
else:
self._notify.warning("No value defined for tag: %s" % (tag[0]))
self._weight = 10 # for testing purposes
blowout = model.find("**/Blowout")
if not blowout.isEmpty():
self._notify.debug("Loading Blowout-Particles")
for node in blowout.getChildren():
particle = ParticleEffect()
self._blowout.append(particle)
particle.loadConfig('./data/particles/blowout_test.ptf')
try: # try to read out the particle scale
scale = float(node.getTag("scale"))
except Exception: # default is 0.5
scale = .5
renderer = particle.getParticlesList()[0].getRenderer()
renderer.setInitialXScale(scale)
renderer.setInitialYScale(scale)
particle.setLightOff()
particle.start(node)
particle.softStop()
else:
self._notify.warning("No Blowout-Node found")
if self._model is not None:
heading = self._model.getH()
self._model.removeNode()
else:
heading = 160
# display the attributes
text = model.getParent().find("AttributeNode")
if not text.isEmpty():
node = text.find("name")
if not node.isEmpty():
node = node.node()
node.setText(self._name)
node.update()
text.show()
node = text.find("description")
if not node.isEmpty():
node = node.node()
node.setText(self._name)
node.update()
text.show()
self._model = model
self._model.setPos(0, 0, 2)
self._model.setHpr(heading, 0, 0)
# #Test
# plightCenter = NodePath( 'plightCenter' )
# plightCenter.reparentTo( render )
# self.interval = plightCenter.hprInterval(12, Vec3(360, 0, 0))
# self.interval.loop()
#
# plight = PointLight('plight')
# plight.setColor(VBase4(0.8, 0.8, 0.8, 1))
# plight.setAttenuation(Vec3(1,0,0))
# plnp = plightCenter.attachNewNode(plight)
# plnp.setPos(5, 5, 10)
# render.setLight(plnp)
#
# alight = AmbientLight('alight')
# alight.setColor(VBase4(0,0,0, 1))
# alnp = render.attachNewNode(alight)
# render.setLight(alnp)
# GlowTextur
# self.glowSize=10
# self.filters = CommonFilters(base.win, self._model)
# self.filters.setBloom(blend=(0,self.glowSize,0,0) ,desat=1, intensity=1, size='medium')
# tex = loader.loadTexture( 'data/textures/glowmap.png' )
# ts = TextureStage('ts')
# ts.setMode(TextureStage.MGlow)
# self._model.setTexture(ts, tex)
# Initialize the physics-simulation for the vehicle
self._physics_model = OdeBody(self._ode_world)
self._physics_model.setPosition(self._model.getPos(render))
self._physics_model.setQuaternion(self._model.getQuat(render))
# Initialize the mass of the vehicle
physics_mass = OdeMass()
physics_mass.setBoxTotal(self._weight, 1, 1, 1)
self._physics_model.setMass(physics_mass)
# Initialize the collision-model of the vehicle
# for use with blender models
# try:
# col_model = loader.loadModel("data/models/vehicles/%s.collision" %(self._model.getName()))
# self.collision_model = OdeTriMeshGeom(self._ode_space, OdeTriMeshData(col_model, True))
# self._notify.info("Loading collision-file: %s" %("data/models/vehicles/%s.collision" %(self._model.getName())))
# for fast collisions
# except:
# self._notify.warning("Could not load collision-file. Using standard collision-box")
# self.collision_model = OdeTriMeshGeom(self._ode_space, OdeTriMeshData(model, False))
# self._collision_model = OdeBoxGeom(self._ode_space, 3,3,2)
self._collision_model = OdeBoxGeom(self._ode_space, 3, 3, 2)
self._collision_model.setBody(self._physics_model)
self._collision_model.setCollideBits(7)
self._collision_model.setCategoryBits(2)
# Add collision-rays for the floating effect
self._ray = CollisionRay(Vec3(5, 0, 0),
Vec3(0, 0, -1),
self._ode_space,
parent=self._collision_model,
collide_bits=0,
length=20.0)
# This one is used for the floating effect but also for slipstream
self._frontray = CollisionRay(Vec3(0, 0, 0),
Vec3(1, 0, 0),
self._ode_space,
parent=self._collision_model,
collide_bits=0,
length=15.0)
# Overwrite variables for testing purposes
self._grip_strength = 0.9
self._track_grip = 0.2
self._boost_strength = 1400
self._control_strength = 2.5
# Loading finished
self._model_loading = False
