def update(self, dt):
# Update player position
movvec = self.target - self.player.get_pos()
newpos = self.player.get_pos()
if movvec.length_squared() < 0.4:
newpos.set_x(self.target.x)
newpos.set_y(self.target.y)
else:
movvec.normalize()
movvec *= self.PLAYER_SPEED * dt
newpos.set_x(self.player.get_x() + movvec.x)
newpos.set_y(self.player.get_y() + movvec.y)
self.player.look_at(newpos)
if self.dungeon.is_walkable(*newpos.xy):
self.player.set_pos(newpos)
if self.dungeon.is_exit(*newpos.xy):
next_didx = self.dungeon_idx + 1
if next_didx >= len(self.dungeons):
# Create a new dungeon
self.dungeons.append(
Dungeon(self.mapgen, self.DUNGEON_SX, self.DUNGEON_SY))
self.switch_to_dungeon(next_didx)
if self.last_tele_loc is not None:
if (self.last_tele_loc -
self.player.get_pos()).length_squared() > 3:
self.last_tele_loc = None
if self.last_tele_loc is None:
teleloc = self.dungeon.get_tele_loc(*newpos.xy)
if teleloc is not None:
newpos.x, newpos.y = teleloc
self.last_tele_loc = p3d.LVector3(newpos)
self.target = p3d.LVector3(newpos)
self.player.set_pos(newpos)
self.reset_camera()
if not self.debug_cam and base.mouseWatcherNode.has_mouse():
mousex, mousey = base.mouseWatcherNode.get_mouse()
border = self.CAM_MOVE_BORDER
camdelta = p3d.LVector2(0, 0)
if mousex < -border:
camdelta.x -= 1
elif mousex > border:
camdelta.x += 1
if mousey < -border:
camdelta.y -= 1
elif mousey > border:
camdelta.y += 1
camdelta.normalize()
camdelta *= self.CAM_MOVE_SPEED * dt
campos = base.cam.get_pos()
campos.x += camdelta.x
campos.y += camdelta.y
base.cam.set_pos(campos)
def update(self, dt, components):
for camcomp in components['CAMERA3P']:
cam = camcomp.camera
target = camcomp.target
# Clamp pitch value
camcomp.pitch = max(min(camcomp.pitch, camcomp.pitch_max + 90),
camcomp.pitch_min + 90)
# Normalize pitch
pitch_t = (camcomp.pitch - 90) / 90
# Compute distance and FoV scaling based on pitch
if pitch_t < 0:
distance_t = (camcomp.pitch - 90) / camcomp.pitch_min
distance_t = tween.easeInCubic(distance_t)
distance_t = 1.0 - 0.6 * distance_t
else:
distance_t = (camcomp.pitch - 90) / camcomp.pitch_max
distance_t = tween.easeInQuad(distance_t)
distance_t = 1.0 + 0.7 * distance_t
# Apply rotation and distance
rotation = p3d.Mat3.rotate_mat(90 - (0.5 * pitch_t + 0.5) * 180,
p3d.LVector3(1, 0, 0))
rotation = rotation * p3d.Mat3.rotate_mat(camcomp.yaw,
p3d.LVector3(0, 0, 1))
position = p3d.LVector3(0, -camcomp.distance * distance_t, 0)
position = rotation.xform(position)
position += target.get_pos(base.render)
cam.set_pos(position)
cam.look_at(target.get_pos(base.render) + p3d.LVector3(0, 0, 1))
def _update_character(self, t, dt):
# Compute motion inputs
input_vel = core.LVector3(self.pad_input, 0)
input_vel = core.LMatrix3.rotateMat(90 + self.camera_angle).xform(input_vel)
input_vel = (input_vel * 7.5).getXy()
if input_vel.length() < 1.5: input_vel.set(0, 0) # deadzone
self.target_vel = self.target_vel*0.1 + input_vel*0.9
self.strafe_amount = self.strafe_amount*0.1 + self.strafe_pressed*0.9
input_dir = (atan2(self.target_vel[1], self.target_vel[0]) * 180 / pi
if self.target_vel.length() > 1e-5 else self.target_dir)
input_dir = mix_angles(input_dir, 180 + self.camera_angle, self.strafe_amount)
self.target_dir = mix_angles(self.target_dir, input_dir, 0.9)
# Compute gait
self.crouch_amount = self.crouch_amount*0.1 + self.crouch_pressed*0.9
if self.target_vel.length() < 0.1:
gaits = [1 - 10*self.target_vel.length(), 0, 0, 0, 0, 0]
elif self.crouch_amount > 0.1:
gaits = [0, 0, 0, self.crouch_amount, 0, 0]
elif self.run_pressed:
gaits = [0, 0, 1, 0, 0, 0]
else:
gaits = [0, 1, 0, 0, 0, 0]
self.gaits = self.gaits*0.9 + np.array(gaits)*0.1
# Run motion controller
pos, xforms = self.motion_controller.frame(self.target_vel, self.target_dir,
self.gaits, self.strafe_amount)
self.char_pos = core.LVector3(*pos)
self.joint_global_xforms = xforms
self.heightmap.update_trajectory(*self.motion_controller.get_trajectory())
def __init__(self):
super().__init__()
self.accept('toggle-debug-cam', self.toggle_debug_cam)
self.accept('move', self.move_player)
self.accept('ability1', self.toggle_range, [0])
self.accept('ability2', self.toggle_range, [1])
self.accept('ability3', self.toggle_range, [2])
self.accept('ability4', self.toggle_range, [3])
self.mapgen = 'static'
dungeon = Dungeon(self.mapgen, self.DUNGEON_SX, self.DUNGEON_SY)
dungeon.model_root.reparent_to(self.root_node)
dlight = p3d.DirectionalLight('sun')
dlight.set_color(p3d.LVector3(0.2, 0.2, 0.2))
dlight.set_shadow_caster(True, 4096, 4096)
dlnp = self.root_node.attach_new_node(dlight)
dlnp.set_z(10)
dlnp.set_p(-90)
lens = dlight.get_lens()
lens.set_film_size(60)
lens.set_near(1)
lens.set_far(100)
self.root_node.set_light(dlnp)
dlight2 = p3d.DirectionalLight('ground')
dlight2.set_color(p3d.LVector3(0.1, 0.1, 0.1))
dlnp2 = self.root_node.attach_new_node(dlight2)
self.root_node.set_light(dlnp2)
loader = p3d.Loader.get_global_ptr()
player = p3d.NodePath(
loader.load_sync('dungeon.bam')).find('**/MonsterSpawn').node()
playernp = self.root_node.attach_new_node(player)
playernp.set_pos(dungeon.player_start)
playernp.set_z(1.5)
self.player_ranges = [
RangeIndicator('box', length=5, width=1),
RangeIndicator('circle', radius=2),
RangeIndicator('circle', radius=3),
RangeIndicator('circle', radius=4),
]
for rangeindicator in self.player_ranges:
rangeindicator.graphics.reparent_to(playernp)
rangeindicator.visible = False
# self.root_node.ls()
# self.root_node.analyze()
self.dungeons = [dungeon]
self.dungeon_idx = 0
self.dungeon = dungeon
self.player = playernp
self.last_tele_loc = None
self.target = self.player.get_pos()
self.debug_cam = False
self.reset_camera()
def test_camera_sync(graphics_context, camera):
graphics_context['camera'] = camera
rpass = lionrender.Pass('test', **graphics_context)
camera.set_pos(p3d.LVector3(1, 2, 3))
camera.set_hpr(p3d.LVector3(1, 2, 3))
graphics_context['engine'].render_frame()
graphics_context['engine'].render_frame()
graphics_context['engine'].render_frame()
graphics_context['engine'].render_frame()
rcam = rpass.display_region.get_camera()
assert rcam.get_pos().compare_to(camera.get_pos()) == 0
assert rcam.get_hpr().compare_to(camera.get_hpr()) == 0
assert rcam.get_node(0).get_lens() == camera.get_node(0).get_lens()
def test_camera_sync_indirect(graphics_context, camera):
graphics_context['camera'] = p3d.NodePath(p3d.ModelNode('indirect'))
camera.reparent_to(graphics_context['camera'])
indirect = graphics_context['camera']
rpass = lionrender.Pass('test', **graphics_context)
camera.set_pos(p3d.LVector3(1, 2, 3))
camera.set_hpr(p3d.LVector3(1, 2, 3))
graphics_context['engine'].render_frame()
rcam = rpass.display_region.get_camera()
assert rcam.get_pos().compare_to(indirect.get_pos()) == 0
assert rcam.get_hpr().compare_to(indirect.get_hpr()) == 0
assert rcam.get_node(0).get_lens() == camera.get_node(0).get_lens()
def update(self, dt, components):
self.physics_world.do_physics(dt, 10, 1.0 / 180.0)
for character in components.get('PHY_CHARACTER', []):
phynode = character.physics_node
np = character.entity.get_component('NODEPATH').nodepath
# Air Check
frompt = np.get_pos(base.render) - p3d.LVector3(
0, 0, character.height / 2.1)
topt = frompt + p3d.LVector3(0, 0, -0.25)
result = self.physics_world.ray_test_closest(frompt, topt)
#print(frompt, topt, result.has_hit(), result.get_node())
character.airborne = not result.has_hit()
def update_weapon(self, weapon):
if isinstance(weapon, str):
gdb = gamedb.get_instance()
weapon = gdb['weapons'][weapon]
meshname = weapon.mesh['root_node']
if meshname == '':
return
weapon_joint = self._path.expose_joint(None, 'modelRoot', 'weapon')
modelroot = base.loader.load_model('models/{}.bam'.format(
weapon.mesh['bam_file']))
mesh = modelroot.find(f'**/{meshname}')
if mesh.is_empty():
print(f'Warning: could not find weapon {meshname}')
modelroot.ls()
return
elif weapon_joint is None:
print(f'Warning: could not find weapon joint on {self.form.name}')
return
# Update weapon transform
weaponxf = self.form.weapon_offset
pos, hpr, scale = weaponxf['position'][:], weaponxf[
'hpr'][:], weaponxf['scale'][:]
pos = [i * 0.1 for i in pos]
pos[1] += 0.4
mesh.set_pos(mesh.get_pos() + p3d.LVector3(*pos))
mesh.set_hpr(*hpr)
scale = [
scale[idx] / inv
for idx, inv in enumerate(weapon_joint.get_scale())
]
mesh.set_scale(*scale)
mesh.instance_to(weapon_joint)
def update_camera(self, task):
dt = task.time - self.last_update_cam_time
# Update camera angle
self.camera_angle += 90 * (self.cam_right_pressed -
self.cam_left_pressed) * dt
# Reposition camera
ang_rads = self.camera_angle * pi / 180
cam_offset = core.LVector3(300 * cos(ang_rads), 300 * sin(ang_rads),
320)
self.camera.setPos(self.char_pos + cam_offset)
self.camera.lookAt(self.char_pos + core.LVector3(0, 0, 80),
core.LVector3(0, 0, 1))
self.last_update_cam_time = task.time
return Task.cont
def setupLights(self): # This function sets up some default lighting
ambientLight = p3dc.AmbientLight("ambientLight")
ambientLight.setColor((.8, .8, .8, 1))
directionalLight = p3dc.DirectionalLight("directionalLight")
directionalLight.setDirection(p3dc.LVector3(0, 45, -45))
directionalLight.setColor((0.2, 0.2, 0.2, 1))
self.render.setLight(self.render.attachNewNode(directionalLight))
self.render.setLight(self.render.attachNewNode(ambientLight))
def func():
textnp.set_pos(target.as_nodepath, 0, 0, 2)
intervals.Sequence(
intervals.Func(textnp.show),
intervals.LerpPosInterval(
textnp, 1.0,
textnp.get_pos() + p3d.LVector3(0, 0, 0.5)),
intervals.Func(textnp.remove_node),
).start()
def __init__(self):
super().__init__()
self.physics_world = bullet.BulletWorld()
self.physics_world.set_gravity(p3d.LVector3(0, 0, -9.8))
phydebug = bullet.BulletDebugNode('Physics Debug')
phydebug.show_wireframe(True)
#phydebug.show_bounding_boxes(True)
self._debugnp = p3d.NodePath(phydebug)
self.physics_world.set_debug_node(phydebug)
def init_components(self, dt, components):
for static_mesh in components.get('PHY_STATICMESH', []):
self.physics_world.attach(static_mesh.physics_node)
for character in components.get('PHY_CHARACTER', []):
np = character.entity.get_component('NODEPATH').nodepath
phynp = np.get_parent().attach_new_node(character.physics_node)
phynp.set_pos(np.get_pos())
np.reparent_to(phynp)
np.set_pos(p3d.LVector3(0, 0, 0))
self.physics_world.attach(character.physics_node)
def __init__(self):
ShowBase.__init__(self)
dlight = core.DirectionalLight('dlight')
dlight.setDirection(core.LVector3(1, 0, 1))
dlnode = self.render.attachNewNode(dlight)
self.render.setLight(dlnode)
alight = core.AmbientLight('alight')
alight.setColor((0.3, 0.3, 0.3, 1))
alnode = self.render.attachNewNode(alight)
self.render.setLight(alnode)
def test_combat_coords(app):
arena = Arena(p3d.NodePath('root'), 5, 5)
assert arena.tile_coord_to_world((2, 2)) == p3d.LVector3(4, 4, 0)
assert arena.tilenp_to_coord(arena.tilenps[2][1]) == (2, 1)
assert arena.tile_distance((0, 0), (0, 0)) == 0
assert arena.tile_distance((0, 1), (0, -1)) == 2
assert arena.tile_distance((1, 1), (3, 3)) == 4
assert arena.tile_get_facing_to((0, 0), (1, 1)) == (1, 0)
assert arena.tile_get_facing_to((1, 1), (0, 0)) == (-1, 0)
assert arena.tile_get_facing_to((1, 1), (1, 3)) == (0, 1)
def __init__(self, shape, **kwargs):
sdftex = None
frame = p3d.LVector4(-1, 1, -1, 1)
scale = p3d.LVector3(1, 1, 1)
offset = p3d.LVector3(0, 0, 0)
if shape == 'circle':
sdftex = _SDF_CIRCLE
scale *= kwargs['radius']
elif shape == 'box':
sdftex = _SDF_BOX
scale = p3d.LVector3(kwargs['width'] / 2.0, 1,
kwargs['length'] / 2.0)
offset = p3d.LVector3(0, kwargs['length'] / 2.0, 0)
else:
raise ValueError(
"Unknown shape for RangeIndicator: {}".format(shape))
cardmaker = p3d.CardMaker('RI_' + shape)
cardmaker.set_frame(frame)
card = p3d.NodePath(cardmaker.generate())
card.set_p(-90)
card.set_scale(scale)
card.set_pos(offset)
card.set_transparency(p3d.TransparencyAttrib.MAlpha)
card.set_texture(sdftex)
card.set_shader(_SHADER)
card.set_shader_input('sdftex', sdftex)
card.set_shader_input('ricolor', p3d.LVector4(0.8, 0.0, 0.0, 0.3))
card.set_shader_input('outline_color',
p3d.LVector4(0.0, 0.0, 0.0, 0.8))
self.graphics = card
def update_movement(direction, activate):
move_delta = p3d.LVector3(0, 0, 0)
if direction == 'forward':
move_delta.set_y(1)
elif direction == 'backward':
move_delta.set_y(-1)
elif direction == 'left':
move_delta.set_x(-1)
elif direction == 'right':
move_delta.set_x(1)
if not activate:
move_delta *= -1
self.player_movement += move_delta
def process_tile(x, y):
tile = self._bsp[y][x]
if tile != '.':
tilenp = self._tile_root.attach_new_node('TileNode')
tile_model.instance_to(tilenp)
tile_pos = p3d.LVector3(x - sizex / 2.0, y - sizey / 2.0,
-random.random() * 0.1)
tilenp.set_pos(tile_pos)
if tile == '*':
# Player start
self.player_start.x = tile_pos.x
self.player_start.y = tile_pos.y
elif tile == '&':
# Exit
self.exit_loc.x = tile_pos.x
self.exit_loc.y = tile_pos.y
exitnp = p3d.NodePath('Exit')
tele_model.instance_to(exitnp)
exitnp.set_pos(tile_pos + p3d.LVector3(0, 0, 1))
exitnp.reparent_to(self.model_root)
elif tile == '$':
# Monster spawn
spawnnp = p3d.NodePath('Spawn')
spawn_model.instance_to(spawnnp)
spawnnp.set_pos(tile_pos + p3d.LVector3(0, 0, 1))
spawnnp.set_h(180)
spawnnp.reparent_to(self.model_root)
self.spawners.append(spawnnp)
elif tile.isdigit():
# Teleporter
telenp = self.model_root.attach_new_node('Teleporter')
tele_model.instance_to(telenp)
telenp.set_pos(tile_pos + p3d.LVector3(0, 0, 1))
if tile not in self._telemap:
self._telemap[tile] = [(x, y)]
else:
self._telemap[tile].append((x, y))
# This is the second teleporter we found for this pair so add a link
tlnp = self.model_root.attach_new_node(
'TeleporterLink')
telelink_model.instance_to(tlnp)
tlnp.set_pos(tile_pos + p3d.LVector3(0, 0, 1))
teleloc = self._tile_to_world(
*self._get_tele_loc_from_tile(x, y))
tovec = p3d.LVector3(teleloc, tlnp.get_z())
linkvec = tovec - tlnp.get_pos()
tlnp.set_scale(1, linkvec.length(), 1)
tlnp.look_at(tovec)
def __init__(self,
rendernp,
targetpos=None,
scene=None,
calc_shadow_bounds=True):
self.rendernp = rendernp
targetpos = targetpos or p3d.LVector3(0, 0, 0)
# Lights
self.key_light = p3d.DirectionalLight('sun')
self.key_light.color_temperature = 6000
self.key_lightnp = rendernp.attach_new_node(self.key_light)
self.key_lightnp.set_pos(targetpos + (0, -15, 15))
self.key_lightnp.look_at(targetpos)
base.render.set_light(self.key_lightnp)
self.fill_light = p3d.DirectionalLight('fill light')
self.fill_light.color_temperature = 4800
self.fill_light.color = self.fill_light.color * 0.5
self.fill_lightnp = rendernp.attach_new_node(self.fill_light)
self.fill_lightnp.set_pos(targetpos + (-20, 0, 10))
self.fill_lightnp.look_at(targetpos)
base.render.set_light(self.fill_lightnp)
self.back_light = p3d.DirectionalLight('fill light')
self.back_light.color_temperature = 4800
self.back_light.color = self.back_light.color * 0.25
self.back_lightnp = rendernp.attach_new_node(self.back_light)
self.back_lightnp.set_pos(20, 20, 0)
self.back_lightnp.look_at(targetpos)
base.render.set_light(self.back_lightnp)
ambient_power = 0.1
self.ambient_light = p3d.AmbientLight('ambient')
self.ambient_light.color = (ambient_power, ambient_power,
ambient_power, 1.0)
self.ambient_lightnp = rendernp.attach_new_node(self.ambient_light)
base.render.set_light(self.ambient_lightnp)
# Shadows
self.key_light.set_shadow_caster(True, 512, 512)
if calc_shadow_bounds:
self.recalc_bounds(scene)
def load_monster_models(self, forms=None, weapons=None):
for monact in self.monster_actors:
monact.cleanup()
monact.remove_node()
self.monster_actors = []
labels = []
if forms is None:
forms = [i.form for i in self.player.monsters]
labels = [i.name for i in self.player.monsters]
weapons = [i.weapon for i in self.player.monsters]
if not labels:
labels = itertools.repeat('')
if weapons is None:
weapons = itertools.repeat(None)
stride = 2
offset = 0
for form, weapon, labelstr in zip(forms, weapons, labels):
actor = MonsterActor(form, self.monsters_root, weapon)
actor.set_h(45)
actor.set_pos(self.monsters_root, p3d.LVector3(offset, 0, 0))
self.monster_actors.append(actor)
label = p3d.TextNode('monster label')
label.set_align(p3d.TextNode.ACenter)
label.set_text(labelstr)
labelnp = actor.attach_new_node(label)
labelnp.set_pos(0, 0, 2.3)
labelnp.set_scale(0.2)
labelnp.set_billboard_point_eye()
labelnp.set_bin("fixed", 0)
labelnp.set_depth_test(False)
labelnp.set_depth_write(False)
labelnp.set_shader_auto(True)
labelnp.set_color_scale((0, 0, 0, 1))
labelnp.set_light_off()
offset += stride
if self.monster_actors:
self.lighting.recalc_bounds(self.monsters_root)
def update(self, dt, components):
for aicomp in components['AI']:
# Pick target
try:
target = components['PLAYER'][0]
except IndexError:
continue
targetnp = target.entity.get_component('NODEPATH').nodepath
# Face target
ainp = aicomp.entity.get_component('NODEPATH')
look_point = targetnp.get_pos()
look_point.z = ainp.nodepath.get_pos().z
ainp.nodepath.look_at(look_point, p3d.LVector3(0, 0, 1))
# Attack target
aichar = aicomp.entity.get_component('CHARACTER')
aichar.action_set.add('ATTACK')
def addFirefly(self):
pos1 = p3dc.LPoint3(random.uniform(-50, 50), random.uniform(-100, 150),
random.uniform(-10, 80))
dir = p3dc.LVector3(random.uniform(-1, 1), random.uniform(-1, 1),
random.uniform(-1, 1))
dir.normalize()
pos2 = pos1 + (dir * 20)
fly = self.lightroot.attachNewNode(p3dc.PandaNode("fly"))
glow = fly.attachNewNode(p3dc.PandaNode("glow"))
dot = fly.attachNewNode(p3dc.PandaNode("dot"))
color_r = 1.0
color_g = random.uniform(0.8, 1.0)
color_b = min(color_g, random.uniform(0.5, 1.0))
fly.setColor(color_r, color_g, color_b, 1.0)
fly.setShaderInput("lightcolor", (color_r, color_g, color_b, 1.0))
int1 = fly.posInterval(random.uniform(7, 12), pos1, pos2)
int2 = fly.posInterval(random.uniform(7, 12), pos2, pos1)
si1 = fly.scaleInterval(random.uniform(0.8, 1.5),
p3dc.LPoint3(0.2, 0.2, 0.2),
p3dc.LPoint3(0.2, 0.2, 0.2))
si2 = fly.scaleInterval(random.uniform(1.5, 0.8),
p3dc.LPoint3(1.0, 1.0, 1.0),
p3dc.LPoint3(0.2, 0.2, 0.2))
si3 = fly.scaleInterval(random.uniform(1.0, 2.0),
p3dc.LPoint3(0.2, 0.2, 0.2),
p3dc.LPoint3(1.0, 1.0, 1.0))
siseq = Sequence(si1, si2, si3)
siseq.loop()
siseq.setT(random.uniform(0, 1000))
seq = Sequence(int1, int2)
seq.loop()
self.spheremodel.instanceTo(glow)
self.firefly.instanceTo(dot)
glow.setScale(self.fireflysize * 1.1)
glow.hide(p3dc.BitMask32(self.modelMask | self.plainMask))
dot.hide(p3dc.BitMask32(self.modelMask | self.lightMask))
dot.setColor(color_r, color_g, color_b, 1.0)
self.fireflies.append(fly)
self.sequences.append(seq)
self.glowspheres.append(glow)
self.scaleseqs.append(siseq)
def start(self):
# The main initialization of our class
# This creates the on screen title that is in every tutorial
self.title = OnscreenText(text="Panda3D: Tutorial - Lighting",
style=1, fg=(1, 1, 0, 1), shadow=(0, 0, 0, 0.5),
pos=(0.87, -0.95), scale = .07)
# Creates labels used for onscreen instructions
self.ambientText = self.makeStatusLabel(0)
self.directionalText = self.makeStatusLabel(1)
self.spotlightText = self.makeStatusLabel(2)
self.pointLightText = self.makeStatusLabel(3)
self.spinningText = self.makeStatusLabel(4)
self.ambientBrightnessText = self.makeStatusLabel(5)
self.directionalBrightnessText = self.makeStatusLabel(6)
self.spotlightBrightnessText = self.makeStatusLabel(7)
self.spotlightExponentText = self.makeStatusLabel(8)
self.lightingPerPixelText = self.makeStatusLabel(9)
self.lightingShadowsText = self.makeStatusLabel(10)
self.disco = self.loader.loadModel("disco_lights_models/disco_hall")
self.disco.reparentTo(self.render)
self.disco.setPosHpr(0, 50, -4, 90, 0, 0)
# First we create an ambient light. All objects are affected by ambient
# light equally
# Create and name the ambient light
self.ambientLight = self.render.attachNewNode(p3dc.AmbientLight("ambientLight"))
# Set the color of the ambient light
self.ambientLight.node().setColor((.1, .1, .1, 1))
# add the newly created light to the lightAttrib
# Now we create a directional light. Directional lights add shading from a
# given angle. This is good for far away sources like the sun
self.directionalLight = self.render.attachNewNode(
p3dc.DirectionalLight("directionalLight"))
self.directionalLight.node().setColor((.35, .35, .35, 1))
# The direction of a directional light is set as a 3D vector
self.directionalLight.node().setDirection(p3dc.LVector3(1, 1, -2))
# These settings are necessary for shadows to work correctly
self.directionalLight.setZ(6)
dlens = self.directionalLight.node().getLens()
dlens.setFilmSize(41, 21)
dlens.setNearFar(50, 75)
# self.directionalLight.node().showFrustum()
# Now we create a spotlight. Spotlights light objects in a given cone
# They are good for simulating things like flashlights
self.spotlight = self.camera.attachNewNode(p3dc.Spotlight("spotlight"))
self.spotlight.node().setColor((.45, .45, .45, 1))
self.spotlight.node().setSpecularColor((0, 0, 0, 1))
# The cone of a spotlight is controlled by it's lens. This creates the lens
self.spotlight.node().setLens(p3dc.PerspectiveLens())
# This sets the Field of View (fov) of the lens, in degrees for width
# and height. The lower the numbers, the tighter the spotlight.
self.spotlight.node().getLens().setFov(16, 16)
# Attenuation controls how the light fades with distance. The three
# values represent the three attenuation constants (constant, linear,
# and quadratic) in the internal lighting equation. The higher the
# numbers the shorter the light goes.
self.spotlight.node().setAttenuation(p3dc.LVector3(1, 0.0, 0.0))
# This exponent value sets how soft the edge of the spotlight is.
# 0 means a hard edge. 128 means a very soft edge.
self.spotlight.node().setExponent(60.0)
# Now we create three colored Point lights. Point lights are lights that
# radiate from a single point, like a light bulb. Like spotlights, they
# are given position by attaching them to NodePaths in the world
self.redHelper = self.loader.loadModel('disco_lights_models/sphere')
self.redHelper.setColor((1, 0, 0, 1))
self.redHelper.setPos(-6.5, -3.75, 0)
self.redHelper.setScale(.25)
self.redPointLight = self.redHelper.attachNewNode(
p3dc.PointLight("redPointLight"))
self.redPointLight.node().setColor((.35, 0, 0, 1))
self.redPointLight.node().setAttenuation(p3dc.LVector3(.1, 0.04, 0.0))
# The green point light and helper
self.greenHelper = self.loader.loadModel('disco_lights_models/sphere')
self.greenHelper.setColor((0, 1, 0, 1))
self.greenHelper.setPos(0, 7.5, 0)
self.greenHelper.setScale(.25)
self.greenPointLight = self.greenHelper.attachNewNode(
p3dc.PointLight("greenPointLight"))
self.greenPointLight.node().setAttenuation(p3dc.LVector3(.1, .04, .0))
self.greenPointLight.node().setColor((0, .35, 0, 1))
# The blue point light and helper
self.blueHelper = self.loader.loadModel('disco_lights_models/sphere')
self.blueHelper.setColor((0, 0, 1, 1))
self.blueHelper.setPos(6.5, -3.75, 0)
self.blueHelper.setScale(.25)
self.bluePointLight = self.blueHelper.attachNewNode(
p3dc.PointLight("bluePointLight"))
self.bluePointLight.node().setAttenuation(p3dc.LVector3(.1, 0.04, 0.0))
self.bluePointLight.node().setColor((0, 0, .35, 1))
self.bluePointLight.node().setSpecularColor((1, 1, 1, 1))
# Create a dummy node so the lights can be spun with one command
self.pointLightHelper = self.render.attachNewNode("pointLightHelper")
self.pointLightHelper.setPos(0, 50, 11)
self.redHelper.reparentTo(self.pointLightHelper)
self.greenHelper.reparentTo(self.pointLightHelper)
self.blueHelper.reparentTo(self.pointLightHelper)
# Finally we store the lights on the root of the scene graph.
# This will cause them to affect everything in the scene.
self.render.setLight(self.ambientLight)
self.render.setLight(self.directionalLight)
self.render.setLight(self.spotlight)
self.render.setLight(self.redPointLight)
self.render.setLight(self.greenPointLight)
self.render.setLight(self.bluePointLight)
# Create and start interval to spin the lights, and a variable to
# manage them.
self.pointLightsSpin = self.pointLightHelper.hprInterval(
6, p3dc.LVector3(360, 0, 0))
self.pointLightsSpin.loop()
self.arePointLightsSpinning = True
# Per-pixel lighting and shadows are initially off
self.perPixelEnabled = False
self.shadowsEnabled = False
# listen to keys for controlling the lights
self.accept("escape", sys.exit)
self.accept("a", self.toggleLights, [[self.ambientLight]])
self.accept("d", self.toggleLights, [[self.directionalLight]])
self.accept("s", self.toggleLights, [[self.spotlight]])
self.accept("p", self.toggleLights, [[self.redPointLight,
self.greenPointLight,
self.bluePointLight]])
self.accept("r", self.toggleSpinningPointLights)
self.accept("l", self.togglePerPixelLighting)
self.accept("e", self.toggleShadows)
self.accept("z", self.addBrightness, [self.ambientLight, -.05])
self.accept("x", self.addBrightness, [self.ambientLight, .05])
self.accept("c", self.addBrightness, [self.directionalLight, -.05])
self.accept("v", self.addBrightness, [self.directionalLight, .05])
self.accept("b", self.addBrightness, [self.spotlight, -.05])
self.accept("n", self.addBrightness, [self.spotlight, .05])
self.accept("q", self.adjustSpotlightExponent, [self.spotlight, -1])
self.accept("w", self.adjustSpotlightExponent, [self.spotlight, 1])
# Finally call the function that builds the instruction texts
self.updateStatusLabel()
def _update_character(self, t, dt):
root_pos, global_xforms, forward, gaits = self.anim
# Interpolate pos and xform
frame = min(60 * t, root_pos.shape[0] - 2)
f_num, f_off = int(frame), frame % 1.0
pos = root_pos[f_num] * (1 - f_off) + root_pos[f_num + 1] * f_off
xforms = global_xforms[f_num] * (1 - f_off) + global_xforms[f_num +
1] * f_off
self.char_pos = core.LVector3(*pos)
self.joint_global_xforms = xforms
# Update displayed trajectory
nearest_frame = min(root_pos.shape[0] - 60, max(60, round(60 * t)))
if nearest_frame > 100: return
positions = root_pos[nearest_frame - 60:nearest_frame + 60].copy()
positions[:, 2] = self.heightmap.get_height(positions[:, 0],
positions[:, 1])
directions = forward[nearest_frame - 60:nearest_frame + 60, :2]
self.heightmap.update_trajectory(positions, directions)
if nearest_frame == 100: print('---------')
if BUILD_NETWORK_INPUTS and nearest_frame == 100:
td_angles = np.arctan2(directions[:, 1],
directions[:, 0]) * 180 / np.pi
prev_joint_pos = global_xforms[nearest_frame - 1, :, 3, :3]
prev_joint_vels = global_xforms[nearest_frame, :,
3, :3] - prev_joint_pos
prev_joint_vels += root_pos[nearest_frame] - root_pos[nearest_frame
- 1]
prev_joint_pos[:, 2] += root_pos[nearest_frame - 1, 2]
gts = gaits[nearest_frame - 60:nearest_frame + 60]
rpos = np.empty(3)
rpos[:2] = positions[60, :2]
rpos[2] = positions[::10, 2].mean()
rrot = td_angles[60] - 90
x = np.empty(342, dtype=np.float32)
# Trajectory positions and directions
pos = rot2(-rrot) @ (positions[::10, :2] - rpos[:2]).T
drc = ang2vec(td_angles[::10] - rrot).T
x[0:12] = -pos[0]
x[12:24] = pos[1]
x[24:36] = -drc[0]
x[36:48] = drc[1]
# Gaits
x[48:120] = gts[::10].T.flatten()
# Last frame's joint positions and velocities
jpos = prev_joint_pos
jpos[:, :2] = jpos[:, :2] @ rot2(90 - td_angles[59]).T
jvel = prev_joint_vels.copy()
jvel[:, :2] = jvel[:, :2] @ rot2(90 - td_angles[59]).T
x[120:213:3] = -jpos[:, 0]
x[121:213:3] = jpos[:, 2] - self.rheight
x[122:213:3] = jpos[:, 1]
x[213:306:3] = -jvel[:, 0]
x[214:306:3] = jvel[:, 2]
x[215:306:3] = jvel[:, 1]
# Trajectory heights (r and l are switched here for consistency with paper)
positions_r = positions[::10, :2] + 25 * ang2vec(td_angles[::10] +
90)
positions_l = positions[::10, :2] + 25 * ang2vec(td_angles[::10] -
90)
x[306:318] = self.heightmap.get_height(positions_r[:, 0],
positions_r[:, 1])
x[318:330] = self.heightmap.get_height(positions_l[:, 0],
positions_l[:, 1])
x[330:342] = positions[::10, 2]
# Subtract off root position height
x[306:342] -= rpos[2]
x -= PFNN_XMEAN
x /= PFNN_XSTD
np.save('12345', x)
self.rheight = positions[::10, 2].mean()
def __init__(self):
# Setup a space to work with
base.ecsmanager.space = Entity(None)
base.ecsmanager.space.add_component(components.NodePathComponent())
spacenp = base.ecsmanager.space.get_component('NODEPATH').nodepath
spacenp.reparent_to(base.render)
# Load assets
self.level_entity = base.ecsmanager.create_entity()
self.level = loader.load_model('cathedral.bam')
level_start = self.level.find('**/PlayerStart')
self.level.reparent_to(spacenp)
for phynode in self.level.find_all_matches('**/+BulletBodyNode'):
if not phynode.is_hidden():
self.level_entity.add_component(
components.PhysicsStaticMeshComponent(phynode.node()))
else:
print("Skipping hidden node", phynode)
self.player = base.template_factory.make_character(
'character.bam', self.level, level_start.get_pos())
# Attach camera to player
playernp = self.player.get_component('NODEPATH').nodepath
self.camera = base.ecsmanager.create_entity()
self.camera.add_component(
components.Camera3PComponent(base.camera, playernp))
# Player movement
self.player_movement = p3d.LVector3(0, 0, 0)
def update_movement(direction, activate):
move_delta = p3d.LVector3(0, 0, 0)
if direction == 'forward':
move_delta.set_y(1)
elif direction == 'backward':
move_delta.set_y(-1)
elif direction == 'left':
move_delta.set_x(-1)
elif direction == 'right':
move_delta.set_x(1)
if not activate:
move_delta *= -1
self.player_movement += move_delta
self.accept('move-forward', update_movement, ['forward', True])
self.accept('move-forward-up', update_movement, ['forward', False])
self.accept('move-backward', update_movement, ['backward', True])
self.accept('move-backward-up', update_movement, ['backward', False])
self.accept('move-left', update_movement, ['left', True])
self.accept('move-left-up', update_movement, ['left', False])
self.accept('move-right', update_movement, ['right', True])
self.accept('move-right-up', update_movement, ['right', False])
def jump():
char = self.player.get_component('CHARACTER')
char.jump = True
self.accept('jump', jump)
# Mouse look
props = p3d.WindowProperties()
props.set_cursor_hidden(True)
props.set_mouse_mode(p3d.WindowProperties.M_confined)
base.win.request_properties(props)
def pixels_to_im_coords(self, point):
px, py = point
px, py = px - self.window_w / 2, py - self.window_h / 2
return core.LVector3(px, 0,
-py) * (2.0 / min(self.window_w, self.window_h))
def __init__(self):
super().__init__()
# Allow panda to synthesize shaders. Make sure hardware-animated-vertices is set
# to true in panda config.
render.setShaderAuto()
# Show FPS
self.setFrameRateMeter(True)
# Load character
self.character = Actor('data/character/character')
self.character.reparentTo(self.render)
self.joints = []
for name in JOINT_NAMES:
j = self.character.controlJoint(None, 'modelRoot', name)
j.reparentTo(self.render)
self.joints.append(j)
# Add lights
dlight = core.DirectionalLight('DirectionalLight')
dlight.setDirection(core.LVector3(2, 0, -1))
dlight.setColor(core.LColor(1, 1, 1, 1))
dlnp = self.render.attachNewNode(dlight)
self.render.setLight(dlnp)
alight = core.AmbientLight('AmbientLight')
alight.setColor(core.LColor(0.6, 0.6, 0.6, 1))
alnp = self.render.attachNewNode(alight)
self.render.setLight(alnp)
# Camera angle in xy-plane (degrees)
self.camera_angle = 0
# Camera control
self.cam_left_pressed, self.cam_right_pressed = 0, 0
self.accept('a', self.set_cam_left_pressed, [1])
self.accept('a-up', self.set_cam_left_pressed, [0])
self.accept('d', self.set_cam_right_pressed, [1])
self.accept('d-up', self.set_cam_right_pressed, [0])
# Pad display
self.pad_radius = 60
self.pad_outline = OnscreenImage('project/data/pad/pad_outline.png',
(0, 0, 0))
self.pad_outline.setTransparency(core.TransparencyAttrib.MAlpha)
self.pad_outline.hide()
self.pad_response_circle = OnscreenImage(
'project/data/pad/pad_response_indicator.png', (0, 0, 0))
self.pad_response_circle.setTransparency(
core.TransparencyAttrib.MAlpha)
self.pad_response_circle.hide()
self.accept('window-event', self.handle_window_event)
# Pad control
self.mouse1_pressed, self.controlling_pad = False, False
self.accept('mouse1', self.set_mouse1_pressed, [True])
self.accept('mouse1-up', self.set_mouse1_pressed, [False])
# Load terrain
self.heightmaps = {}
self.set_heightmap('hmap2', 'project/data/heightmaps/hmap2.npy')
# Heightmap choice
self.accept('1', self.set_heightmap,
['hmap1', 'project/data/heightmaps/hmap1.npy'])
self.accept('2', self.set_heightmap,
['hmap2', 'project/data/heightmaps/hmap2.npy'])
self.accept('3', self.set_heightmap,
['hmap3', 'project/data/heightmaps/hmap3.npy'])
self.accept('4', self.set_heightmap,
['hmap4', 'project/data/heightmaps/hmap4.npy'])
self.accept('5', self.set_heightmap,
['hmap5', 'project/data/heightmaps/hmap5.npy'])
# Tasks
self.taskMgr.add(self.update_pad, 'UpdatePadTask', sort=1)
self.last_update_char_time = 0
self.taskMgr.add(self.update_character, 'UpdateCharacterTask', sort=2)
self.last_update_cam_time = 0
self.taskMgr.add(self.update_camera, 'UpdateCameraTask', sort=3)
def reset_level(self):
self.camera_angle = 0
self.char_pos = core.LVector3()
def __init__(self):
super().__init__()
# Background Image
bgnode.generate(self.root_node, 'arena')
bgnode.generate(self.root_node, 'arena', True)
# Background Music
self.play_bg_music('the_last_encounter')
# Arena
self.arena = Arena(self.root_node, 10, 10)
self.selected_tile = (0, 0)
self.move_range_tiles = []
self.ability_range_tiles = []
self.player = base.blackboard['player']
# Player Combatants
self.player_combatants = [
Combatant(mon, self.root_node) for mon in self.player.monsters
]
random_placement = p3d.ConfigVariableBool(
'mercury-random-combat-placement', True).get_value()
possible_positions = [(x, y) for x in range(2)
for y in range(self.arena.sizey - 1)]
if random_placement:
placements = random.sample(possible_positions,
len(self.player_combatants))
else:
placements = possible_positions
for combatant, placement in zip(self.player_combatants, placements):
self.move_combatant_to_tile(combatant, placement, True)
combatant.set_h(90)
self.starting_tile_position = (0, 0)
# Enemy Combatants
default_combat_type = p3d.ConfigVariableString(
'mercury-default-combat-type', 'skirmish')
self.combat_type = base.blackboard.get('combat_type',
default_combat_type)
if self.combat_type == 'tournament':
num_enemies = {1: 3, 2: 5, 3: 8}.get(self.player.rank, 8)
else:
num_enemies = len(self.player_combatants)
self.enemy_combatants = [
Combatant(Monster.gen_random(f'combatant{i}', 1), self.root_node)
for i in range(num_enemies)
]
possible_positions = [
(x, y)
for x in range(self.arena.sizex - 1, self.arena.sizex - 3, -1)
for y in range(self.arena.sizey - 1)
]
placements = random.sample(possible_positions,
len(self.enemy_combatants))
for combatant, placement in zip(self.enemy_combatants, placements):
self.move_combatant_to_tile(combatant, placement, True)
combatant.set_h(-90)
# Setup Lighting
arena_world_center = self.arena.tile_coord_to_world(self.arena.center)
CommonLighting(self.root_node, arena_world_center)
# Setup Camera
base.camera.set_pos(-15, -15, 15)
lookat_offset = p3d.LVector3(-3, -3, 0)
base.camera.look_at(
self.arena.tile_coord_to_world(self.arena.center) + lookat_offset)
# Setup UI
self.load_ui('combat')
# Setup AI
self.aicontroller = AiController(self.arena, self, self.root_node)
# Set initial input state
self.input_state = 'END_TURN'
def tile_coord_to_world(self, tile_pos):
xtile, ytile = tile_pos
return p3d.LVector3(xtile * 2, ytile * 2, 0)
