def __localCannonMoveTask(self, task):
pos = self.cannonPosition
oldRot = pos[0]
oldAng = pos[1]
rotVel = 0
if self.leftPressed:
rotVel += CANNON_ROTATION_VEL
if self.rightPressed:
rotVel -= CANNON_ROTATION_VEL
pos[0] += rotVel * globalClock.getDt()
if pos[0] < CANNON_ROTATION_MIN:
pos[0] = CANNON_ROTATION_MIN
elif pos[0] > CANNON_ROTATION_MAX:
pos[0] = CANNON_ROTATION_MAX
angVel = 0
if self.upPressed:
angVel += CANNON_ANGLE_VEL
if self.downPressed:
angVel -= CANNON_ANGLE_VEL
pos[1] += angVel * globalClock.getDt()
if pos[1] < CANNON_ANGLE_MIN:
pos[1] = CANNON_ANGLE_MIN
elif pos[1] > CANNON_ANGLE_MAX:
pos[1] = CANNON_ANGLE_MAX
if oldRot != pos[0] or oldAng != pos[1]:
if self.cannonMoving == 0:
self.cannonMoving = 1
base.playSfx(self.sndCannonMove, looping=1)
self.__updateCannonPosition()
elif self.cannonMoving:
self.cannonMoving = 0
if self.sndCannonMove:
self.sndCannonMove.stop()
return Task.cont
def update_bullet(task):
"""
Invokes the physics engine to update and simulate the next step.
"""
dt = globalClock.getDt() # get elapsed time
self.world.doPhysics(dt) # actually update
return task.cont
def camera_movement(self, task):
dt = globalClock.getDt()
direction = self.render.getRelativeVector(self.camera, (0, 1, 0))
direction.normalize()
position = self.camera.getPos()
move_speed = VisualizerApp.MOVE_SPEED
if self.keyMap['shift']:
move_speed *= VisualizerApp.MOVE_SPEED_MULTIPLIER
if self.keyMap['forward']:
position += direction * dt * move_speed
if self.keyMap['backward']:
position += direction * dt * -move_speed
self.camera.setPos(position)
chunk_x = position.x // self.level.chunk_width
chunk_z = position.y // self.level.chunk_depth
self.position_text.text = 'Position: (x: %04d, y: %04d, z: %04d)\nChunk (x: %02d, z: %02d)' % (position.x, position.z, position.y, chunk_x, chunk_z)
return task.cont
def camera_control(self, task):
dt = globalClock.getDt()
if dt > .20:
return task.cont
if self.master.mouseWatcherNode.hasMouse():
mouse_position = self.master.mouseWatcherNode.getMouse()
self.rotation[0] += mouse_position.getY() * 30
self.rotation[1] += mouse_position.getX() * -50
self.master.camera.setP(self.rotation[0])
self.master.camera.setH(self.rotation[1])
self.player_node_path.setH(self.player_node_path.getH() +
mouse_position.getX() * -1)
self.master.win.movePointer(0, int(self.master.win.getXSize() / 2),
int(self.master.win.getYSize() / 2))
if self.keyMap["w"]:
self.player_node_path.setY(self.player_node_path, SPEED * dt)
if self.keyMap["s"]:
self.player_node_path.setY(self.player_node_path, -SPEED * dt)
if self.keyMap["a"]:
self.player_node_path.setX(self.player_node_path, -SPEED * dt)
if self.keyMap["d"]:
self.player_node_path.setX(self.player_node_path, SPEED * dt)
if self.keyMap["shift"]:
self.player_node_path.setZ(self.player_node_path, SPEED * dt)
if self.keyMap["control"]:
self.player_node_path.setZ(self.player_node_path, -SPEED * dt)
if self.keyMap["space"]:
self.jump()
return task.cont
def update(self, task):
"""Updates the actor action following the key event
It is use as a callback task and instructs a movement to the actor
following the key pressed by the player which relates to a specific
type of movement (or other action). The movement is also based on
the amount of time since the last movement.
:param task: the task received by the callback
:return: the priority of the task
"""
dt = globalClock.getDt()
result_pos = Vec3(0, 0, 0)
if self.action_map["up"][1]:
result_pos = Vec3(0, 5.0 * dt, 0)
if self.action_map["down"][1]:
result_pos = Vec3(0, -5.0 * dt, 0)
if self.action_map["left"][1]:
result_pos = Vec3(-5.0 * dt, 0, 0)
if self.action_map["right"][1]:
result_pos = Vec3(5.0 * dt, 0, 0)
if self.action_map["shoot"][1]:
result_pos = Vec3(0, 0, 0)
print("Zap!")
if self.action_map["lift"][1]:
result_pos = Vec3(0, 0, 5.0 * dt)
if self.action_map["fall"][1]:
result_pos = Vec3(0, 0, -5.0 * dt)
self.dice_actor.setPos(self.dice_actor.getPos() + result_pos)
return task.cont
def update(self, task: Task):
dt, ft = globalClock.getDt(), globalClock.getFrameTime()
heading, position, pitch = self.player.get_h(), self.player.get_pos(), self.player.get_p()
# self.sun.set_p(self.sun.get_p() - (dt * 20))
# self.sun.set_h(self.sun.get_h() - (dt * 20))
if KEY_MAP["up"]:
position.z += self.SPEED * dt
self.player.set_pos(position)
if KEY_MAP["down"]:
position.z -= self.SPEED * dt
self.player.set_pos(position)
if KEY_MAP["q"]:
position.x -= self.SPEED * dt
self.player.set_pos(position)
if KEY_MAP["e"]:
position.x += self.SPEED * dt
self.player.set_pos(position)
if KEY_MAP["w"]:
dx = (self.SPEED * dt) * np.cos(np.radians(heading + 90))
dy = (self.SPEED * dt) * np.sin(np.radians(heading + 90))
position.y, position.x = position.y + dy, position.x + dx
self.player.set_pos(position)
if KEY_MAP["s"]:
dx = - (self.SPEED * dt) * np.cos(np.radians(heading + 90))
dy = - (self.SPEED * dt) * np.sin(np.radians(heading + 90))
position.y, position.x = position.y + dy, position.x + dx
self.player.set_pos(position)
if KEY_MAP["d"] and not KEY_MAP["s"]:
heading -= self.SPEED * dt * 2
self.player.set_h(heading)
if KEY_MAP["a"] and not KEY_MAP["s"]:
heading += self.SPEED * dt * 2
self.player.set_h(heading)
if KEY_MAP["d"] and KEY_MAP["s"]:
heading += self.SPEED * dt * 2
self.player.set_h(heading)
if KEY_MAP["a"] and KEY_MAP["s"]:
heading -= self.SPEED * dt * 2
self.player.set_h(heading)
if KEY_MAP["left"]:
pitch += self.SPEED * dt * 2
self.player.set_p(pitch)
if KEY_MAP["right"]:
pitch -= self.SPEED * dt * 2
self.player.set_p(pitch)
return task.cont
def update(self, task):
# Get the amount of time since the last update
dt = globalClock.getDt()
# If any movement keys are pressed, use the above time
# to calculate how far to move the character, and apply that.
if self.keyMap["up"]:
self.player.move(Vec3(0, - dt, 0))
if self.keyMap["down"]:
self.player.move(Vec3(0, dt, 0))
if self.keyMap["left"]:
self.player.move(Vec3(dt, 0, 0))
if self.keyMap["right"]:
self.player.move(Vec3(- dt, 0, 0))
if self.keyMap["quit"]:
self.exit_game()
if self.mouseWatcherNode.hasMouse():
if self.mouseWatcherNode.getMouseX() < -self.mouse_check_value:
self.player.rotate(Vec3(100.0 * dt, 0, 0))
elif self.mouseWatcherNode.getMouseX() > self.mouse_check_value:
self.player.rotate(Vec3(-100.0 * dt, 0, 0))
if self.keyMap["shoot"]:
self.player.shoot()
if not (self.keyMap["up"] or self.keyMap["down"] or self.keyMap["left"] or self.keyMap["right"]):
self.player.stop()
self.scene.update(dt)
return task.cont
def update(self, task: Task):
dt = globalClock.getDt()
if KEY_MAP["e"]:
pos = self.sphere.get_pos()
pos.z += self.SPEED * dt
self.sphere.set_pos(pos)
if KEY_MAP["q"]:
pos = self.sphere.get_pos()
pos.z -= self.SPEED * dt
self.sphere.set_pos(pos)
if KEY_MAP["a"]:
pos = self.sphere.get_pos()
pos.x -= self.SPEED * dt
self.sphere.set_pos(pos)
if KEY_MAP["d"]:
pos = self.sphere.get_pos()
pos.x += self.SPEED * dt
self.sphere.set_pos(pos)
if KEY_MAP["w"]:
pos = self.sphere.get_pos()
pos.y += self.SPEED * dt
self.sphere.set_pos(pos)
if KEY_MAP["s"]:
pos = self.sphere.get_pos()
pos.y -= self.SPEED * dt
self.sphere.set_pos(pos)
return task.cont
def update(self, task: Task):
dt = globalClock.getDt()
self.plane.setTexOffset(TextureStage.getDefault(), self.tx, 0)
self.texture_update += 5
if self.texture_update % 6 * dt == 0:
self.tx += self.tx_offset
self.texture_update = 0
return task.cont
def update(self, task: Task):
dt, ft = globalClock.getDt(), globalClock.getFrameTime()
if KEY_MAP["up"]:
self.bc304.set_pos(self.x, self.y, self.z)
self.z += self.speed * dt
if KEY_MAP["down"]:
self.bc304.set_pos(self.x, self.y, self.z)
self.z -= self.speed * dt
if KEY_MAP["right"]:
self.bc304.set_pos(self.x, self.y, self.z)
self.x += self.speed * dt
if KEY_MAP["left"]:
self.bc304.set_pos(self.x, self.y, self.z)
self.x -= self.speed * dt
if KEY_MAP["e"]:
pos = self.sphere.get_pos()
pos.z += self.speed * dt
self.sphere.set_pos(pos)
if KEY_MAP["q"]:
pos = self.sphere.get_pos()
pos.z -= self.speed * dt
self.sphere.set_pos(pos)
if KEY_MAP["a"]:
pos = self.sphere.get_pos()
pos.x -= self.speed * dt
self.sphere.set_pos(pos)
if KEY_MAP["d"]:
pos = self.sphere.get_pos()
pos.x += self.speed * dt
self.sphere.set_pos(pos)
if KEY_MAP["w"]:
pos = self.sphere.get_pos()
pos.y += self.speed * dt
self.sphere.set_pos(pos)
if KEY_MAP["s"]:
pos = self.sphere.get_pos()
pos.y -= self.speed * dt
self.sphere.set_pos(pos)
# self.sphere.set_pos(float(np.cos(ft) * 4), float(np.sin(ft) * 4), float(np.sin(ft) * 10))
# self.z -= 0.5 * dt
# self.bc304.set_hpr(self.h, self.p, 0)
# self.h += 0.1
# self.p += 0.1
return task.cont
def update(self, task):
"""Update the world using physics."""
dt = globalClock.getDt()
self.world.doPhysics(dt)
self.clock += 1
if TARGETING[0] and self.clock % 10 == 0:
for (character,
side), target in zip(product(self.characterList, sides),
self.targets):
character.position_shoulder(side, target)
return Task.cont
def updateState(self):
'''
Called every frame - if w,a,s,d pressed, move self accordingly
If mouse location different and not in a menu, rotate actor by delta radians
Adjust camera to keep up with move
'''
# call parent
entity.updateState(self)
# get time since last frame (multiply by distance to get actual distance to displace
dt = globalClock.getDt()
#update camera (also updates model using mouselook)
self.updateCamera()
# check if there is any movement
if (self.keyMap["forward"] or self.keyMap["back"]
or self.keyMap["left"] or self.keyMap["right"]):
#isMobile tracks whether object is moving or not for other functions
#TODO: direction specific animations
#for now just loop walking
if not self.isMobile:
self.loop("walk", restart=0)
self.isMobile = True
# for every direction that is true, move object that way
# do the same with the camera
if self.keyMap["forward"]:
self.setY(self, -self.speed * dt)
# camera too..
#self.camera.setY(self.camera.getY() - 25 * dt)
if self.keyMap["back"]:
self.setY(self, +self.speed * dt)
#self.camera.setY(self.camera.getY() + 25 * dt)
if self.keyMap["left"]:
#self.setX(self, + 100 * dt)
self.setH(self.getH() + self.turnSpeed * dt)
#counter movement of torso
self.neck.setR(self.neck.getR() - self.turnSpeed * dt)
if self.keyMap["right"]:
#self.setX(self, - 100 * dt)
self.setH(self.getH() - self.turnSpeed * dt)
self.neck.setR(self.neck.getR() + self.turnSpeed * dt)
# lastly if attempting move simulate gravity as well
#self.setZ(self.getZ() - 50 * dt)
else:
self.isMobile = False
#otherwise stop walk animation
self.stop()
#check if shooting, if so, shoot
if self.keyMap['firing']:
self.shoot()
def move_orbital_camera_task(self, task):
# First compute new camera angles and distance
if self.key_map["left"] != 0:
self.longitude_deg = self.longitude_deg - self.deg_per_sec * globalClock.getDt(
)
if self.key_map["right"] != 0:
self.longitude_deg = self.longitude_deg + self.deg_per_sec * globalClock.getDt(
)
if self.key_map["up"] != 0:
self.latitude_deg = self.latitude_deg - self.deg_per_sec * globalClock.getDt(
)
if self.key_map["down"] != 0:
self.latitude_deg = self.latitude_deg + self.deg_per_sec * globalClock.getDt(
)
if self.key_map["wheelup"] != 0:
self.dist = self.dist * (
1 + (self.zoom_per_sec - 1) * globalClock.getDt())
self.update_key_map("wheelup", 0)
if self.key_map["wheeldown"] != 0:
self.dist = self.dist / (
1 + (self.zoom_per_sec - 1) * globalClock.getDt())
self.update_key_map("wheeldown", 0)
if self.key_map["top_view"] != 0:
self.latitude_deg = -90
self.longitude_deg = 0
self.update_key_map("top_view", 0)
if self.longitude_deg > 180.0:
self.longitude_deg = self.longitude_deg - 360.0
if self.longitude_deg < -180.0:
self.longitude_deg = self.longitude_deg + 360.0
if self.dist < self.min_dist:
self.dist = self.min_dist
if self.dist > self.max_dist:
self.dist = self.max_dist
# Convert to Radians
angle_longitude_radians = self.longitude_deg * (pi / 180.0)
angle_latitude_radians = self.latitude_deg * (pi / 180.0)
# Compute the target object's position with respect to the camera
x = -self.dist * self.target_size * sin(angle_longitude_radians) * cos(
angle_latitude_radians)
y = self.dist * self.target_size * cos(angle_longitude_radians) * cos(
angle_latitude_radians)
z = self.dist * self.target_size * sin(angle_latitude_radians)
# Compute the world origin's position with respect to the camera
x = (x * self.render_ratio)
y = (y * self.render_ratio)
z = (z * self.render_ratio)
# Apply the position
self.__origin.set_pos(x, y, z)
# Rotate the camera
self.__cam.set_hpr(self.longitude_deg, self.latitude_deg, 0)
# End task
return task.cont
def execute(self, task):
dt = globalClock.getDt()
if self.stater.states["walk"]:
self.straight_walk(dt)
if self.stater.states["jump"]:
self.jump(dt)
if self.stater.states["fly"]:
self.fly(dt)
self.turn(dt)
if self.actor.getZ() > initial_actor_pos.z:
self.actor_obj.apply_gravity()
else:
self.actor_obj.v = util.VEC3_NULL
self.actor_obj.move(dt)
return Task.cont
def doGravity(self):
dt = globalClock.getDt()
#gravity - if not grounded, make it so
if not self.isGrounded:
self.setZ(self.getZ() - 50 * dt)
return
else:
entries = []
for entry in base.groundHandler.getEntries():
if entry.getFromNodePath().getParent() == self \
or entry.getIntoNodePath().getParent() == self:
entries.append(entry)
if (len(entries) > 0) and (entries[0].getIntoNode().getName()
== "terrain"):
self.setZ(entries[0].getSurfacePoint(base.render).getZ() + 2)
def update(self, task: Task):
dt = globalClock.getDt()
if KEY_MAP["up"]:
self.bc304.set_pos(self.x, self.y, self.z)
self.z += 2.0 * dt
if KEY_MAP["down"]:
self.bc304.set_pos(self.x, self.y, self.z)
self.z -= 2.0 * dt
if KEY_MAP["right"]:
self.bc304.set_pos(self.x, self.y, self.z)
self.x += 2.0 * dt
if KEY_MAP["left"]:
self.bc304.set_pos(self.x, self.y, self.z)
self.x -= 2.0 * dt
if KEY_MAP["w"]:
pos = self.sphere.get_pos()
pos.z += 3 * dt
self.sphere.set_pos(pos)
if KEY_MAP["s"]:
pos = self.sphere.get_pos()
pos.z -= 3 * dt
self.sphere.set_pos(pos)
if KEY_MAP["a"]:
pos = self.sphere.get_pos()
pos.x -= 3 * dt
self.sphere.set_pos(pos)
if KEY_MAP["d"]:
pos = self.sphere.get_pos()
pos.x += 3 * dt
self.sphere.set_pos(pos)
# self.z -= 0.5 * dt
# self.bc304.set_hpr(self.h, self.p, 0)
# self.h += 0.1
# self.p += 0.1
return task.cont
def accelerate(self, task):
"""
Task moves bullet forward until it hits an object or range is met
"""
#range is decremented each tick
#check to make sure not 0
if self.range <= 0:
#if range has ran out kill task and this object
self.delete()
return task.done
#otherwise proceed, move object and decrement range
dt = globalClock.getDt()
#distVec=min((self.start-self.target),(self.target-self.start))
#distVec=distVec.normalized()
#print(distVec)
#print(self.direction)
#take normalized direction vector and apply to transform
self.model.setFluidX(self.model, self.direction[0] * self.speed * dt)
self.model.setFluidY(self.model, self.direction[1] * self.speed * dt)
self.model.setFluidZ(self.model, self.direction[2] * self.speed * dt)
self.range -= (self.speed * dt)
return task.cont
def update_bullets(self, task: Task):
if settings.SHOW_COLLIDERS:
for b_collider in self.bullet_colliders:
b_collider.show()
dt = globalClock.getDt()
rmi = [] + self.object_ids_to_indices()
for idx, entry in enumerate(self.bullets):
bullet, heading = entry
bullet_pos = bullet.get_pos()
if abs(np.sqrt(bullet_pos.y**2 + bullet_pos.x**2)) > 300:
rmi.append(idx)
continue
dx = (self.BULLET_SPEED * dt) * np.cos(np.radians(heading))
dy = (self.BULLET_SPEED * dt) * np.sin(np.radians(heading))
bullet_pos.y += dy
bullet_pos.x += dx
bullet.set_fluid_pos(bullet_pos)
for idx in rmi:
self.bullets[idx][0].removeNode()
self.bullet_colliders[idx].node().clearSolids()
self.f.cTrav.removeCollider(self.bullet_colliders[idx])
pass
self.bullet_colliders = [
b for i, b in enumerate(self.bullet_colliders) if i not in rmi
]
self.bullets = [b for i, b in enumerate(self.bullets) if i not in rmi]
# print(f"available {len(self.bullet_colliders)} colliders and {len(self.bullets)} bullets")
return task.cont
def shoot(self):
dt = globalClock.getDt()
# print(self.rayQueue.getNumEntries())
# print(self.rayQueue)
if self.rayQueue.getNumEntries() > 0:
self.rayQueue.sortEntries()
rayHit = self.rayQueue.getEntry(1)
hitPos = rayHit.getSurfacePoint(self.base.render)
# print(hitPos, "hitpos")
# print(rayHit, "rayhit")
# beamLength = (hitPos - self.actor.getPos()).length()
# print("length: ", beamLength)
hitNodePath = rayHit.getIntoNodePath()
# print(hitNodePath)
# print(hitNodePath.getPythonTag)
# print(hitPos)
# print(hitNodePath.getTag)
# print(hitNodePath.hasPythonTag("enemy"))
# print(rayHit.getFrom())
if hitNodePath.hasPythonTag("enemy"):
# print("here")
hitObject = hitNodePath.getPythonTag("enemy")
hitObject.change_health(-1)
# Find out how long the beam is, and scale the
# beam-model accordingly.
# print(self.actor.getPos())
beamLength = (hitPos - (self.actor.getPos())).length()
self.beamModel.setSy(-beamLength)
self.score += 1
self.update_score()
self.beamModel.show()
else:
# If we're not shooting, don't show the beam-model.
self.beamModel.hide()
def update(self, task):
dt = globalClock.getDt()
self.world.doPhysics(dt, 10, 0.008)
return task.cont
def physics_task(self, task):
dt = globalClock.getDt()
self.physics_world.doPhysics(dt)
return Task.cont
def move_backward(self, task):
self.controlling_node.set_y(
self.controlling_node, self.movement_speed * globalClock.getDt()
)
self.controlled_node.set_h(180)
return Task.cont
def move_right(self, task):
self.controlling_node.set_x(
self.controlling_node, -self.movement_speed * 0.7 * globalClock.getDt()
)
self.controlled_node.set_h(-90)
return Task.cont
def rotate_right(self, task):
self.controlling_node.set_h(
self.controlling_node, -self.movement_speed * 80 * globalClock.getDt()
)
return Task.cont
def update(self, task: Task):
if self.f.state == settings.IN_MENU_STATE:
return task.cont
dt, ft = globalClock.getDt(), globalClock.getFrameTime()
tank_heading, tank_position = self.tank.tank.get_h(
), self.tank.tank.get_pos()
# # self.sun.set_p(self.sun.get_p() - (dt * 40))
# # self.sun.set_h(self.sun.get_h() - (dt * 20))
# self.tank.hit()
z_pos = 0.01 if settings.DISABLE_Z_MOV else tank_position.z
self.tank.tank.set_fluid_pos(tank_position.x, tank_position.y, z_pos)
self.tank.handle_sfx()
if self.enemy.hp <= 0 and self.enemy.is_alive:
self.enemy.tank.removeNode()
del self.environment["enemy"]
self.enemy.is_alive = False
print("defeated")
if KEY_MAP["up"]:
tank_position.z += self.SPEED * dt
self._tank.set_fluid_pos(tank_position)
if KEY_MAP["down"]:
tank_position.z -= self.SPEED * dt
self._tank.set_fluid_pos(tank_position)
if KEY_MAP["q"]:
tank_position.x -= self.SPEED * dt
self._tank.set_fluid_pos(tank_position)
if KEY_MAP["e"]:
tank_position.x += self.SPEED * dt
self._tank.set_fluid_pos(tank_position)
if KEY_MAP["w"]:
dx = (self.SPEED * dt) * np.cos(np.radians(tank_heading + 90))
dy = (self.SPEED * dt) * np.sin(np.radians(tank_heading + 90))
tank_position.y, tank_position.x = tank_position.y + dy, tank_position.x + dx
self._tank.set_fluid_pos(tank_position)
if KEY_MAP["s"]:
dx = -(self.SPEED * dt) * np.cos(np.radians(tank_heading + 90))
dy = -(self.SPEED * dt) * np.sin(np.radians(tank_heading + 90))
tank_position.y, tank_position.x = tank_position.y + dy, tank_position.x + dx
self._tank.set_fluid_pos(tank_position)
if KEY_MAP["d"] and not KEY_MAP["s"]:
tank_heading -= self.TURN_SPEED * dt * 2
self._tank.set_h(tank_heading)
if KEY_MAP["a"] and not KEY_MAP["s"]:
tank_heading += self.TURN_SPEED * dt * 2
self._tank.set_h(tank_heading)
if KEY_MAP["d"] and KEY_MAP["s"]:
tank_heading += self.TURN_SPEED * dt * 2
self._tank.set_h(tank_heading)
if KEY_MAP["a"] and KEY_MAP["s"]:
tank_heading -= self.TURN_SPEED * dt * 2
self._tank.set_h(tank_heading)
return task.cont
def update(self, task):
dt = globalClock.getDt()
self.world.doPhysics(dt)
self.camera.look_at(self.follow_np)
return task.cont
