def __init__(self):
p3d.lens.set_far(FAR)
self.focus = NodePath(PandaNode('focus'))
self.focus.set_compass()
self.focus.reparent_to(p3d.render)
self.focus.set_pos(0.0, 0.0, FOCUS_HEIGHT)
self.rotator = NodePath(PandaNode('rotator'))
self.rotator.reparent_to(self.focus)
self.rotator.set_pos(0.0, 0.0, 0.0)
self.following = None
p3d.camera.set_pos(0.0, 0.0, DEFAULT_HEIGHT)
p3d.camera.look_at(self.rotator)
p3d.camera.reparent_to(self.rotator)
self.focus.set_h(DEFAULT_ROTATION)
self.rotator.set_p(DEFAULT_PITCH)
self.speed = [0.0, 0.0]
self.rot_speed = [0.0, 0.0]
self.zoom_speed = 0.0
self._cinematic = None
self.set_cinematic_mode(False)
def _toggle_cinematic():
self.set_cinematic_mode(not self._cinematic)
def _zoom(amount):
self.zoom_speed += amount * self._zoom_accel
p3d.base.accept('f8', _toggle_cinematic)
p3d.base.accept('wheel_up', partial(_zoom, -10.0))
p3d.base.accept('wheel_down', partial(_zoom, 10.0))
def test_particle_burst_emission():
effect = ParticleEffect()
system = Particles("testSystem", 10)
effect.add_particles(system)
# Setup some dummy nodes, since it seems to want them
# We might normally call "start", but that calls "enable", which
# seems to assume that "base" exists and has physics and particle managers...
system.setRenderParent(NodePath(PandaNode("test")))
system.setSpawnRenderNodePath(NodePath(PandaNode("test")))
# However, we don't want normal emission, so we now soft-stop it immediately,
# before the system has a chance to update and emit.
effect.softStop()
# Now, a sanity-check: assert that we have no particles,
# Then update the system, and assert again that we
# have no particles. If so, then we're (hopefully)
# not emitting normally!
assert system.getLivingParticles() == 0
system.update(1)
assert system.getLivingParticles() == 0
# Now, the real test: emit a particle-burst!
effect.birthLitter()
# And assert that a particle has, in fact, been emitted.
assert system.getLivingParticles() == 1
# Check the snake-case version, too.
effect.birth_litter()
assert system.getLivingParticles() == 2
def __init__(self, pos, modelName, modelAnims, maxHealth, maxSpeed,
colliderName, weaponIntoMask, size):
self.root = Common.framework.showBase.render.attachNewNode(
PandaNode("obj"))
self.colliderName = colliderName
self.modelName = modelName
if modelName is None:
self.actor = NodePath(PandaNode("actor"))
elif modelAnims is None:
self.actor = Common.framework.showBase.loader.loadModel(modelName)
else:
self.actor = Actor(modelName, modelAnims)
self.actor.reparentTo(self.root)
if pos is not None:
self.root.setPos(pos)
self.maxHealth = maxHealth
self.health = maxHealth
self.healthRechargeRate = 2.0
self.healthRechargeSuppressionTimer = 0
self.healthRechargeSuppressionDuration = 0.5
self.maxSpeed = maxSpeed
self.terminalVelocity = 50
self.flinchCounter = 0
self.velocity = Vec3(0, 0, 0)
self.acceleration = 300.0
self.inControl = True
self.outOfControlTimer = 0
self.walking = False
self.size = size
if colliderName is not None:
colliderNode = CollisionNode(colliderName)
colliderNode.addSolid(CollisionSphere(0, 0, 0, size))
self.colliderNP = self.root.attachNewNode(colliderNode)
self.colliderNP.setPythonTag(TAG_OWNER, self)
colliderNode.setFromCollideMask(0)
colliderNode.setIntoCollideMask(weaponIntoMask)
#self.colliderNP.show()
else:
self.colliderNP = self.root.attachNewNode(PandaNode("stand-in"))
self.deathSound = None
def apply(self):
winprops = WindowProperties.size(2048, 2048)
props = FrameBufferProperties()
props.setRgbColor(1)
props.setAlphaBits(1)
props.setDepthBits(1)
lbuffer = base.graphicsEngine.makeOutput(base.pipe, 'offscreen buffer',
-2, props, winprops,
GraphicsPipe.BFRefuseWindow,
base.win.getGsg(), base.win)
self.buffer = lbuffer
ldepthmap = Texture()
lbuffer.addRenderTexture(ldepthmap, GraphicsOutput.RTMBindOrCopy,
GraphicsOutput.RTPDepthStencil)
ldepthmap.setMinfilter(Texture.FTShadow)
ldepthmap.setMagfilter(Texture.FTShadow)
base.camLens.setNearFar(1.0, 10000)
base.camLens.setFov(75)
self.lcam = base.makeCamera(lbuffer)
self.lcam.node().setScene(render)
self.lcam.node().getLens().setFov(45)
self.lcam.node().getLens().setNearFar(1, 100)
render.setShaderInput('light', self.lcam)
render.setShaderInput('depthmap', ldepthmap)
render.setShaderInput('ambient', .15, .15, .15, 1.0)
lci = NodePath(PandaNode('light camera initializer'))
with open('yyagl/assets/shaders/caster.vert') as f:
vert = f.read()
with open('yyagl/assets/shaders/caster.frag') as f:
frag = f.read()
lci.setShader(Shader.make(Shader.SLGLSL, vert, frag))
self.lcam.node().setInitialState(lci.getState())
mci = NodePath(PandaNode('main camera initializer'))
with open('yyagl/assets/shaders/main.vert') as f:
vert = f.read()
with open('yyagl/assets/shaders/main.frag') as f:
frag = f.read()
frag = frag.replace('<LIGHTS>', str(len(self.lights)))
# use PTALVecBaseX instead
# setShaderInput('vec3argname', PTALVecBase3(((0, 0, 0), (1, 1, 1))))
render.setShader(Shader.make(Shader.SLGLSL, vert, frag))
render.setShaderInput('num_lights', len(self.lights))
map(lambda lgt: self.set_lgt_args(*lgt), enumerate(self.lights))
mci.setShader(Shader.make(Shader.SLGLSL, vert, frag))
base.cam.node().setInitialState(mci.getState())
self.lcam.setPos(15, 30, 45)
self.lcam.lookAt(0, 15, 0)
self.lcam.node().getLens().setNearFar(1, 100)
def __init__(self, pos, modelName, modelAnims, maxHealth, maxSpeed,
colliderName, height, weaponIntoMask):
self.root = render.attachNewNode(PandaNode("obj"))
self.colliderName = colliderName
self.modelName = modelName
if modelName is None:
self.actor = NodePath(PandaNode("actor"))
elif modelAnims is None:
self.actor = loader.loadModel(modelName)
else:
self.actor = Actor(modelName, modelAnims)
self.actor.reparentTo(self.root)
if pos is not None:
self.root.setPos(pos)
self.height = height
self.maxHealth = maxHealth
self.health = maxHealth
self.maxSpeed = maxSpeed
self.terminalVelocity = 15
self.flinchCounter = 0
self.velocity = Vec3(0, 0, 0)
self.acceleration = 300.0
self.inControl = True
self.walking = False
self.noZVelocity = True
if colliderName is not None:
colliderNode = CollisionNode(colliderName)
colliderNode.addSolid(CollisionCapsule(0, 0, 0, 0, 0, height, 0.3))
self.weaponCollider = self.root.attachNewNode(colliderNode)
self.weaponCollider.setPythonTag(TAG_OWNER, self)
colliderNode.setFromCollideMask(0)
colliderNode.setIntoCollideMask(weaponIntoMask)
#self.weaponCollider.show()
else:
self.weaponCollider = self.root.attachNewNode(
PandaNode("stand-in"))
self.deathSound = None
self.currentWeapon = None
def test_nodepath_flatten_tags_same_value():
from panda3d.core import NodePath, PandaNode
# Don't flatten nodes with different tag values
node1 = PandaNode("node1")
node1.set_tag("key", "value1")
node2 = PandaNode("node2")
node2.set_tag("key", "value2")
path = NodePath("parent")
path.node().add_child(node1)
path.node().add_child(node2)
path.flatten_strong()
assert len(path.children) == 2
def test_nodepath_flatten_tags_identical():
from panda3d.core import NodePath, PandaNode
# Do flatten nodes with same tags
node1 = PandaNode("node1")
node1.set_tag("key", "value")
node2 = PandaNode("node2")
node2.set_tag("key", "value")
path = NodePath("parent")
path.node().add_child(node1)
path.node().add_child(node2)
path.flatten_strong()
assert len(path.children) == 1
def test_nodepath_transform_composition():
"""Tests that NodePath composes transform states according to the path it holds."""
from panda3d.core import PandaNode, NodePath, LPoint3, LVector3
# Create 3 PandaNodes, and give each some interesting transform state:
node1 = PandaNode('node1')
node2 = PandaNode('node2')
node3 = PandaNode('node3')
node1.set_transform(node1.get_transform().set_pos(LPoint3(
0, 0, 1)).set_hpr(LVector3(90, 0, -90)))
node2.set_transform(node2.get_transform().set_pos(LPoint3(
0, 1, 0)).set_hpr(LVector3(180, 180, 0)))
node3.set_transform(node3.get_transform().set_pos(LPoint3(
1, 0, 0)).set_hpr(LVector3(270, 0, 270)))
# node3 is going to be attached under both node1 and node2 and we will
# hold a path both ways:
node1.add_child(node3)
node2.add_child(node3)
assert len(node1.children) == 1
assert len(node2.children) == 1
assert len(node3.children) == 0
assert len(node1.parents) == 0
assert len(node2.parents) == 0
assert len(node3.parents) == 2
# np1 is the path to node3 via node1:
np1 = NodePath(node1).children[0]
# np2 is the path to node3 via node2:
np2 = NodePath(node2).children[0]
# Both should point to node3:
assert np1.node() == node3
assert np2.node() == node3
# However if we ask for the net transform to node3, it should compose:
assert np1.get_transform(NodePath()) == node1.get_transform().compose(
node3.get_transform())
assert np2.get_transform(NodePath()) == node2.get_transform().compose(
node3.get_transform())
# If we ask for np1 RELATIVE to np2, it should compose like so:
leg1 = node2.get_transform().compose(node3.get_transform())
leg2 = node1.get_transform().compose(node3.get_transform())
relative_transform = leg1.get_inverse().compose(leg2)
assert np1.get_transform(np2) == relative_transform
def launch_panda_window(panda_widget, size):
"""
Configure and create Panda window
Connect to the gtk widget resize event
Load a panda
"""
props = WindowProperties().getDefault()
props.setOrigin(0, 0)
props.setSize(*size)
props.setParentWindow(panda_widget.window.xid)
base.openDefaultWindow(props=props)
# ==
panda_widget.connect("size_allocate", resize_panda_window)
# ==
panda = loader.loadModel("panda")
panda.reparentTo(render)
panda.setPos(0, 40, -5)
pl = render.attachNewNode(PointLight("redPointLight"))
pl.node().setColor(Vec4(.9, .8, .8, 1))
render.setLight(pl)
pl.node().setAttenuation(Vec3(0, 0, 0.05))
slight = Spotlight('slight')
slight.setColor(VBase4(1, 1, 1, 1))
lens = PerspectiveLens()
slight.setLens(lens)
slnp = render.attachNewNode(slight)
slnp.setPos(2, 20, 0)
mid = PandaNode('mid')
panda.attachNewNode(mid)
# slnp.lookAt(mid)
render.setLight(slnp)
def __init__(self, parent=None, pitch=None, id=None):
NetEnt.__init__(self, id)
self.node = NetNodePath(PandaNode('projectile'))
if parent:
self.parent = parent
self.node.setPos(parent.node.getPos() + (0, 0, 1))
self.node.setHpr(parent.node.getHpr())
self.node.setP(pitch)
self.node.reparentTo(render)
ProjectilePool.add(self)
#print 'there are',len(ProjectilePool.values()),'projectiles'
self.flyTime = 0
self.sprite = Sprite2d('resources/missile.png',
rows=3,
cols=1,
rowPerFace=(0, 1, 2, 1),
anchorY=Sprite2d.ALIGN_CENTER)
self.sprite.node.reparentTo(self.node)
# set up 'from' collisions - for detecting projectile hitting things
self.collisionHandler = CollisionHandlerQueue()
self.fromCollider = self.node.attachNewNode(
CollisionNode('fromCollider'))
self.fromCollider.node().addSolid(CollisionRay(0, 0, 0, 0, 1, 0))
self.fromCollider.node().setIntoCollideMask(BITMASK_EMPTY)
self.fromCollider.node().setFromCollideMask(BITMASK_TERRAIN
| BITMASK_CHARACTER)
if SHOW_COLLISIONS:
self.fromCollider.show()
Character.collisionTraverser.addCollider(self.fromCollider,
self.collisionHandler)
def main():
base = ShowBase()
cm = CardMaker('')
cm.set_frame(-.5, .5, -.5, .5)
# Node which contains all the cards equally spaced apart and which is
# animated to move the cards in front of the camera.
cards = base.render.attach_new_node(PandaNode(''))
cards.setPos(-2, 5, 0)
cards.posInterval(2, Point3(-6, 5, 0)).loop()
for i in range(5):
card = cards.attach_new_node(cm.generate())
card.setPos(i * 2, 0, 0)
def on_every_frame(task):
# Time which has elapsed since the last frame measured in units of
# the time quota available at 60 fps (e.g. 1/60 second).
time_quota = taskMgr.globalClock.get_dt() * 60
# Print time use as percent of the 60-fps-quota.
print(f'{round(time_quota * 100):4}', end='', flush=True)
return Task.DSCont
taskMgr.add(on_every_frame)
taskMgr.run()
def configureDance(self):
self.PRESSED,self.NPRESSED,self.PERFECT,self.GOOD,self.MISS=10,-10,2,1,0
danceNode = self.render.attachNewNode(PandaNode('dance'))
# load and set up scene
danceScene = self.loader.loadModel("../models/disco_hall")
danceScene.reparentTo(danceNode)
danceScene.setPosHpr(0, 50, -4, 90, 0, 0)
self.configureLights(danceNode)
self.configureDancer(danceNode)
scoreCircle=OnscreenImage(
image = '../textures/arrivalCircle.png', pos = (-1,0,0.8))
scoreCircle.setTransparency(TransparencyAttrib.MAlpha)
scoreCircle.setScale(0.2)
scoreText= OnscreenText(text =str(0), pos = (-1.02,0.76),
scale = 0.1,fg=(1,1,1,1))
position=self.dancer.getPos()
position[1]=0
position[2]=-0.4
GUIarrows=DirectFrame(frameColor=(0.3,0.3,0.7,0.3),
frameSize=(-0.8,.8,0.2,-0.2),
pos=position)
hitSign=OnscreenImage(image ='../textures/circle.png', pos = (-0.6, 0, -0.4))
hitSign.setTransparency(TransparencyAttrib.MAlpha)
hitSign.setScale(0.15)
scoreReminder=OnscreenText(text ='PERFECT', pos = (-0.6,-0.4),
scale = 0.04,fg=(1,1,1,1),shadow=(0.4,0.4,0.7,0.3))
self.setPanel('dance',Panel(danceNode, {'scoreCircle': scoreCircle,
'GUIarrows':GUIarrows,'hitSign': hitSign,'scoreText': scoreText,
'scoreReminder': scoreReminder}))
def createCharacter(self):
charColl = BulletCapsuleShape(0.4, 1.75 - 2 * 0.4, ZUp)
self.diamondChar = BulletCharacterControllerNode(
charColl, 0.4, 'Player')
self.diamondCharNP = self.worldNP.attachNewNode(self.diamondChar)
self.diamondCharNP.setPos(0, 0, 0)
self.diamondCharNP.setH(-90)
self.diamondCharNP.setCollideMask(BitMask32.allOn())
self.world.attachCharacter(self.diamondChar)
# Summon the lord Diamondback
self.diamondbackChar = Actor(
"Resources/models/CHAR/CHRIS", {
"walk": "Resources/models/CHAR/CHRIS-Walk2",
"idle": "Resources/models/CHAR/CHRIS-Idle2",
"jump": "Resources/models/CHAR/CHRIS-Jump"
})
self.diamondbackChar.reparentTo(self.diamondCharNP)
self.diamondbackChar.setPos(0, 0, -.83)
self.diamondbackChar.setScale(1)
self.diamondbackChar.setBlend(animBlend=True, frameBlend=True)
# Set the camera position tracker
self.camPos = NodePath(PandaNode("camTracker"))
self.camPos.reparentTo(self.diamondbackChar)
# Set the camera to track the lord
base.camera.reparentTo(self.camPos)
base.camera.setPosHpr(0, 6, 2.5, 180, -5, 0)
base.camLens.setFov(90)
def create(self):
winprops = WindowProperties.size(self.size, self.size)
props = FrameBufferProperties()
props.setRgbColor(0)
props.setAlphaBits(0)
props.setDepthBits(1)
self.buffer = base.graphicsEngine.makeOutput(
base.pipe, "shadowsBuffer", -2, props, winprops,
GraphicsPipe.BFRefuseWindow, base.win.getGsg(), base.win)
if not self.buffer:
print("Video driver cannot create an offscreen buffer.")
return
self.depthmap = Texture()
self.buffer.addRenderTexture(self.depthmap,
GraphicsOutput.RTMBindOrCopy,
GraphicsOutput.RTPDepthStencil)
self.depthmap.setMinfilter(Texture.FTShadow)
self.depthmap.setMagfilter(Texture.FTShadow)
self.depthmap.setBorderColor(LColor(1, 1, 1, 1))
self.depthmap.setWrapU(Texture.WMBorderColor)
self.depthmap.setWrapV(Texture.WMBorderColor)
self.cam = base.makeCamera(self.buffer, lens=OrthographicLens())
self.cam.reparent_to(render)
self.node = self.cam.node()
lci = NodePath(PandaNode("Light Camera Initializer"))
lci.set_attrib(ColorWriteAttrib.make(ColorWriteAttrib.M_none), 1000)
lci.set_attrib(
CullFaceAttrib.make(CullFaceAttrib.MCullCounterClockwise), 1000)
self.node.setInitialState(lci.getState())
self.node.setScene(render)
if settings.debug_shadow_frustum:
self.node.showFrustum()
def __init__(self,
context,
outline,
menuRootID=None,
title='',
closeAction='_',
scale=.07,
pos=(-.8, 0, .8),
parent=aspect2d,
style=None,
tipe='vertical'):
self.context = context
if menuRootID == None: self.menuRootID = newID()
else: self.menuRootID = menuRootID
self.scale = scale
self.style = style
t = indent2tree(outline)
if tipe == 'titleBar':
t = [{
'itmTxt': title + delimiter,
'children': t[:]
}, {
'itmTxt':
'X' + delimiter + ' kind=close, closeAction=' + closeAction
}]
root = self.makeMenu('root', t, PandaNode('ehh'), tipe)
self.np = parent.attachNewNode(root)
self.np.setScale(scale)
firstItemPath = self.np.find('-PGItem')
f = firstItemPath.node().getPythonTag('extras').getFFrame()
self.np.setPos(pos[0], pos[0], pos[2] - f[3] * scale)
self.showing = False
self.menu_Click = False
self.clickBlock = False
self.showIt()
def __init__(self, world, name, basedir):
self.world = world
self.name = name
self.basedir = basedir
self.load_complete = 0
self.world.consoleOut('zone initializing: ' + self.name)
# store the in memory WLDFile objects that make uo the zone for direct access
self.wld_containers = {} # and as a directory
self.zone_wld_container = None
self.obj1_wld_container = None
self.obj2_wld_container = None
self.chr_wld_container = None
# init our texture manager
self.tm = TextureManager()
# init our model manager
self.mm = ModelManager(self)
self.nulltex = Texture(
) # create dummy exture object for use in non textured polys
self.rootNode = NodePath(PandaNode("zone_root"))
self.rootNode.reparentTo(render)
self.delta_t = 0
def addLight(self):
self.render.clearLight()
self.lightCenter = self.render.attachNewNode(PandaNode("center"))
#self.lightCenter.setCompass()
# ambient light
self.ambientLight = AmbientLight('ambientLight')
self.ambientLight.setColor(Vec4(0.5, 0.5, 0.5, 1))
self.alight = self.lightCenter.attachNewNode(self.ambientLight)
self.render.setLight(self.alight)
# point light
self.pointlight = PointLight("pLight")
self.light = self.lightCenter.attachNewNode(self.pointlight)
self.pointlight.setColor(Vec4(0.8, 0.8, 0.8, 1))
self.light.setPos(0, 0, 2)
self.render.setLight(self.light)
# directional light
self.dirlight = DirectionalLight("dLight")
self.dlight = self.lightCenter.attachNewNode(self.dirlight)
self.dirlight.setColor(Vec4(0.8, 0.8, 0.8, 1))
self.dirlight.setShadowCaster(True)
self.dlight.setPos(0, 0, 5)
self.dlight.lookAt(5, 10, 0)
self.render.setLight(self.dlight)
self.render.setShaderAuto()
def traverse(self, nodePath, dnaStorage):
node = PandaNode(self.name)
node = nodePath.attachNewNode(node, 0)
node.setPosHprScale(self.pos, self.hpr, self.scale)
for child in self.children_:
child.traverse(node, dnaStorage)
node.flattenMedium()
def __init__(self, parent: NodePath):
super().__init__()
self.parent = parent
self.mouse_np = p3d.camera.attach_new_node(PandaNode('mouse'))
self.mouse_np.set_y(p3d.lens.get_near())
picker_node = CollisionNode('mouse_ray')
picker_np = p3d.camera.attach_new_node(picker_node)
self._picker_ray = CollisionRay()
picker_node.add_solid(self._picker_ray)
self._collision_handler = CollisionHandlerQueue()
self._traverser = CollisionTraverser('mouse_traverser')
self._traverser.add_collider(picker_np, self._collision_handler)
self.actor = Actor(
resource_filename('tsim', 'data/models/cursor'),
{'spin': resource_filename('tsim', 'data/models/cursor-spin')})
self.actor.loop('spin')
self.actor.reparent_to(parent)
self.actor.set_pos(0.0, 0.0, 0.0)
self.actor.set_shader_off()
self._position = Point(0.0, 0.0)
self.last_position = self._position
self.moved = False
self.pointed_at = None
self._tool: Optional[Tool] = None
self._register_events()
def test_node_prev_transform():
identity = TransformState.make_identity()
t1 = TransformState.make_pos((1, 0, 0))
t2 = TransformState.make_pos((2, 0, 0))
t3 = TransformState.make_pos((3, 0, 0))
node = PandaNode("node")
assert node.transform == identity
assert node.prev_transform == identity
assert not node.has_dirty_prev_transform()
node.transform = t1
assert node.transform == t1
assert node.prev_transform == identity
assert node.has_dirty_prev_transform()
node.transform = t2
assert node.transform == t2
assert node.prev_transform == identity
assert node.has_dirty_prev_transform()
node.reset_prev_transform()
assert node.transform == t2
assert node.prev_transform == t2
assert not node.has_dirty_prev_transform()
node.transform = t3
assert node.prev_transform == t2
assert node.has_dirty_prev_transform()
PandaNode.reset_all_prev_transform()
assert node.transform == t3
assert node.prev_transform == t3
assert not node.has_dirty_prev_transform()
def __init__(self, name):
self.name = name
self.poly_groups = []
# GeomVertexFormats
#
# GeomVertexFormat.getV3cpt2() - vertex, color, uv
# GeomVertexFormat.getV3t2() - vertex, uv
# GeomVertexFormat.getV3cp() - vertex, color
# GeomVertexFormat.getV3n3t2() - vertex, normal, uv
# GeomVertexFormat.getV3n3cpt2()- vertex, normal, rgba, uv
# textured
self.vdata = GeomVertexData(name, GeomVertexFormat.getV3n3cpt2(),
Geom.UHStatic)
# plain color filled polys
# self.vdata = GeomVertexData(name, GeomVertexFormat.getV3cp(), Geom.UHStatic)
self.vertex = GeomVertexWriter(self.vdata, 'vertex')
self.vnormal = GeomVertexWriter(self.vdata, 'normal')
self.color = GeomVertexWriter(self.vdata, 'color')
self.texcoord = GeomVertexWriter(self.vdata, 'texcoord')
self.root = NodePath(PandaNode(name + '_mesh'))
def draw_floor(self):
# Load the scene.
# if self.box.dimensions < 3:
# return
floorTex = self.loader.loadTexture('maps/grid.jpg')
cm = CardMaker('')
# cm.setFrame(-2, 2, -2, 2)
X = self.box.box_sizes[0]
if self.box.dimensions > 1:
Y = self.box.box_sizes[1]
else:
Y = X
cm.setFrame(0, X, 0, Y)
# cm.setFrame(0, 0, self.box.box_sizes[0], self.box.box_sizes[1])
floor = self.render.attachNewNode(PandaNode("floor"))
floor.reparentTo(self.boxnode)
for y in range(1):
for x in range(1):
nn = floor.attachNewNode(cm.generate())
nn.setP(-90)
# nn.setPos((x - 6) * 4, (y - 6) * 4, 0)
nn.setPos((x - 0) * 4, (y - 0) * 4, 0)
floor.setTexture(floorTex)
floor.flattenStrong()
floor.setTwoSided(True)
def __init__(self, cr):
self.cr = cr
self.ralph = DistributedSmoothActor(self.cr)
self.cr.createDistributedObject(
distObj = self.ralph,
zoneId = 2)
# Create a floater object, which floats 2 units above ralph. We
# use this as a target for the camera to look at.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(self.ralph)
self.floater.setZ(2.0)
# We will use this for checking if keyboard keys are pressed
self.isDown = base.mouseWatcherNode.isButtonDown
taskMgr.add(self.move, "moveTask")
# Set up the camera
base.camera.setPos(self.ralph.getX(), self.ralph.getY() + 10, 2)
# start the avatar
self.ralph.start()
def addchildren_(self, items, parent, insertPoint):
menuItms = self.makeMenu('tmp', indent2tree(items), PandaNode('tmp'))
sybGroup = parent.find('-PandaNode')
sybs = []
if sybGroup.isEmpty():
sybGroup = parent.attachNewNode(parent.getName())
sybGroup.setX(parent.node().getPythonTag('extras').getFWidth())
else:
sybs = sybGroup.getChildren()
sybGroup.node().removeAllChildren()
n, inserted = 0, False
for s in sybs:
#print "@@hi"
if n == insertPoint:
for m in NodePath(menuItms).getChildren():
m.getPythonTag('extras').deformat()
m.reparentTo(sybGroup)
#print "@@inserted"
inserted = True
s.getPythonTag('extras').deformat()
s.reparentTo(sybGroup)
n += 1
if not inserted: #insertPoint was beyond last child...
#print "@@not hi"
for m in NodePath(menuItms).getChildren():
m.getPythonTag('extras').deformat()
m.reparentTo(sybGroup)
verticalGroupFinish(sybGroup, True)
sybGroup.hide()
def Start(self,pl_name,pl_char,pl_count,pl_list):
# Set up the environment
#
self.environ = loader.loadModel("models/square")
self.environ.reparentTo(render)
self.environ.setPos(0,0,0)
self.environ.setScale(100,100,1)
self.moon_tex = loader.loadTexture("models/moon_1k_tex.jpg")
self.environ.setTexture(self.moon_tex, 1)
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
# # add spheres
earth = Earth(self)
sun = Sun(self)
venus = Venus(self)
controls = Control()
chat = Chat(self)
if pl_char == "Panda1" or pl_char == "Panda2":
print "hi"
player = Panda(self)
elif pl_char == "Car":
player = Car(self)
else :
player = Ralph(self)
#player = Car(self)
# player = Panda(self)
# player = Car(self)
taskMgr.add(player.move,"moveTask" )
taskMgr.add(sun.rotatePlanets,"rotateSun", extraArgs = [self.sun,self.player], appendTask = True)
taskMgr.add(earth.rotatePlanets,"rotateEarth", extraArgs = [self.earth, self.player], appendTask = True)
taskMgr.add(venus.rotatePlanets,"rotateVenus", extraArgs = [self.venus, self.player], appendTask = True)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def startCamera(self):
"""Starts the camera module."""
# to enhance readability
self.cam_floater = self.mainNode
self.cam_floater = self.mainNode.attachNewNode(
PandaNode("playerCamFloater"))
self.cam_floater.setPos(self.cam_floater_pos)
taskMgr.add(self.updateCamera, "task_camActualisation", priority=-4)
def __init__(self):
base.win.setClearColor(Vec4(0, 0, 0, 1))
# Network Setup
print "before"
self.cManager = ConnectionManager(self)
self.startConnection()
print "after"
# Set up the environment
#
self.environ = loader.loadModel("models/square")
self.environ.reparentTo(render)
self.environ.setPos(0, 0, 0)
self.environ.setScale(100, 100, 1)
self.moon_tex = loader.loadTexture("models/moon_1k_tex.jpg")
self.environ.setTexture(self.moon_tex, 1)
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
# add spheres
earth = Earth(self)
sun = Sun(self)
venus = Venus(self)
controls = Control()
chat = Chat(self)
player = Ralph(self)
# player = Panda(self)
# player = Car(self)
taskMgr.add(player.move, "moveTask")
taskMgr.add(sun.rotatePlanets,
"rotateSun",
extraArgs=[self.player],
appendTask=True)
taskMgr.add(earth.rotatePlanets,
"rotateEarth",
extraArgs=[self.player],
appendTask=True)
taskMgr.add(venus.rotatePlanets,
"rotateVenus",
extraArgs=[self.player],
appendTask=True)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self, modelName):
self.root = render.attachNewNode(PandaNode("obj"))
self.actor = loader.loadModel(modelName)
self.actor.reparentTo(self.root)
self.actor.setLightOff(1)
self.actor.setBillboardAxis()
self.auraName = None
def loadGame(self):
# Setting up key maps and the instruction set into the scene...
LandwalkerGlobals.setKeys()
LandwalkerGlobals.setInstructions()
# Loads our world.
scene = self.loadWorld()
# Makes our local avatar.
localAvatar = actor.makeActor()
base.localAvatar = localAvatar
base.localAvatar.reparentTo(render)
# Load our buttons.
self.LoadButtons()
# Load our shaders.
#fog = loadFog()
#print(fogStats(fog))
EffectsManager.loadShaders()
#FogDensity = EffectsManager.loadFog(1)
# Floater Object (For camera)
floater = NodePath(PandaNode("floater"))
floater.reparentTo(localAvatar)
floater.setY(-10)
floater.setZ(8.5)
floater.setHpr(0, -10, 0)
# Set Camera
camera.reparentTo(floater)
wallBitmask = BitMask32(1)
floorBitmask = BitMask32(2)
base.cTrav = CollisionTraverser()
# Walk controls
walkControls = GravityWalker(legacyLifter=True)
walkControls.setWallBitMask(wallBitmask)
walkControls.setFloorBitMask(floorBitmask)
walkControls.setWalkSpeed(16.0, 24.0, 8.0, 80.0)
walkControls.initializeCollisions(base.cTrav,
localAvatar,
floorOffset=0.025,
reach=4.0)
walkControls.setAirborneHeightFunc(
LandwalkerAvatarControls.getAirborneHeight())
walkControls.enableAvatarControls()
# controlManager.add(walkControls, 'walk')
localAvatar.physControls = walkControls
localAvatar.physControls.placeOnFloor()
# Some debug stuff, should be moved later once I can toggle stuff from different files./
self.onScreenDebug.enabled = True
base.setFrameRateMeter(True)
base.taskMgr.add(LandwalkerAvatarControls.move, "moveTask")
base.taskMgr.add(self.updateOnScreenDebug, 'UpdateOSD')
def __init__(self):
__builtin__.main = self
self.taskMgr = taskMgr
self.base = base
# Connect to the server
self.cManager = ConnectionManager()
self.startConnection()
self.characters = dict()
self.cpList = dict()
base.win.setClearColor(Vec4(0, 0, 0, 1))
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
self.environ.setPos(0, 0, 0)
self.ralphStartPos = self.environ.find("**/start_point").getPos()
# Create a floater object. We use the "floater" as a temporary
# variable in a variety of calculations.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
self.accept("escape", sys.exit)
# Login as 'CPHandler'
# Temporary workaround, can add a seperate request/response for client/NPC client logins later
self.name = "CPHandler"
factionId = 0
self.cManager.sendRequest(Constants.CMSG_AUTH, [self.name, factionId])
# Create two control points
cp1 = ControlPoint(1, -107.575, 0.6066, 0.490075, 10, RED)
cp2 = ControlPoint(2, -100.575, -35.6066, 0.090075, 10, BLUE)
self.cpList[1] = cp1
self.cpList[2] = cp2
taskMgr.doMethodLater(0.1, self.refresh, "heartbeat")
taskMgr.doMethodLater(1, self.CPHandler, 'CPHandler')
# Set up the camera
base.disableMouse()
#base.camera.setPos(self.character.actor.getX(),self.character.actor.getY()+10,2)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))