def test_collision_handler_event_pickle():
from panda3d.core import CollisionHandlerEvent
handler = CollisionHandlerEvent()
handler.add_in_pattern("abcdefg")
handler.add_in_pattern("test")
handler.add_again_pattern("again pattern")
handler.add_again_pattern("another again pattern")
handler.add_out_pattern("out pattern")
handler = loads(dumps(handler, -1))
assert tuple(handler.in_patterns) == ("abcdefg", "test")
assert tuple(handler.again_patterns) == ("again pattern",
"another again pattern")
assert tuple(handler.out_patterns) == ("out pattern", )
class NeoITPyApp(ShowBase):
"""The NeoITPy app."""
def __init__(self):
"""Setup this app."""
ShowBase.__init__(self)
#Setup window
wnd_props = WindowProperties()
wnd_props.set_title("Neo Impressive Title")
#wnd_props.set_origin(0, 0)
wnd_props.set_size(1024, 768)
self.win.request_properties(wnd_props)
self.set_background_color(0, .5, 1, 1)
#Init GUI sub-system
self.gui = GUI(self)
self.gui.run()
#Init app state
self.state = APP_STATE_LOGO
self.logo_delay = 600
#Start title music
self.title_music = loader.loadMusic("./data/sounds/title.ogg")
self.title_music.set_loop(True)
self.title_music.play()
#Setup collision detection
self.cTrav = CollisionTraverser()
self.portal_handler = CollisionHandlerEvent()
self.portal_handler.add_in_pattern("%fn-entered-%in")
#Init other sub-systems
self.cam_mgr = CameraManager()
self.world_mgr = WorldManager()
#Setup lighting
self.ambient = AmbientLight("Ambient Light")
self.ambient.set_color(Vec4(.5, .5, .5, 1))
self.ambient_np = self.render.attach_new_node(self.ambient)
self.render.set_light(self.ambient_np)
self.sun = DirectionalLight("Sun")
self.sun_np = self.render.attach_new_node(self.sun)
self.sun_np.set_p(-135)
self.render.set_light(self.sun_np)
#Setup auto-shaders
self.render.set_shader_auto()
#Debug stats
#self.messenger.toggle_verbose()
PStatClient.connect()
def new_game(self):
"""Start a new game."""
self.gui.switch_to_screen("CampaignSelectScreen",
SlideTransition(direction = "left"))
self.state = APP_STATE_CAMPAIGN_SELECT
def multiplayer(self):
"""Start multiplayer mode."""
self.gui.switch_to_screen("LoginScreen",
SlideTransition(direction = "left"))
self.state = APP_STATE_LOGIN
def quit(self):
"""Close the app."""
self.user_exit()
def start_campaign(self, name):
"""Start the given campaign."""
print("Starting campaign '{}'...".format(name))
self.gui.show_multiplayer_hud(False)
self.gui.show_target_info(False)
self.gui.switch_to_screen("HUD", FadeTransition())
self.cam_mgr.change_mode(CAM_MODE_FREE)
self.world_mgr.load_map("./data/maps/Waterfall Cave")
def leave_campaign_select(self):
"""Leave the campaign select screen and return to the title screen."""
self.gui.switch_to_screen("TitleScreen",
SlideTransition(direction = "right"))
self.state = APP_STATE_TITLE
def login(self):
"""Begin login process."""
print("Logging in...")
def new_account(self):
"""Enter the account creation screen."""
self.gui.switch_to_screen("NewAccountScreen",
SlideTransition(direction = "left"))
self.state = APP_STATE_NEW_ACCOUNT
def change_password(self):
"""Enter the password change screen."""
self.gui.switch_to_screen("ChangePasswordScreen",
SlideTransition(direction = "left"))
self.state = APP_STATE_CHANGE_PASSWORD
def leave_login_screen(self):
"""Leave the login screen and return to the title screen."""
self.gui.switch_to_screen("TitleScreen",
SlideTransition(direction = "right"))
self.state = APP_STATE_TITLE
def create_new_account(self):
"""Create a new account."""
print("Creating new account...")
def leave_new_account_screen(self):
"""Leave the new account screen and return to the login screen."""
self.gui.switch_to_screen("LoginScreen",
SlideTransition(direction = "right"))
self.state = APP_STATE_LOGIN
def do_password_change(self):
"""Change the user's current password."""
print("Changing password...")
def leave_change_password_screen(self):
"""Leave the change password screen and return to the login screen."""
self.gui.switch_to_screen("LoginScreen",
SlideTransition(direction = "right"))
self.state = APP_STATE_LOGIN
def run_logic(self, task):
"""Run the game logic for each frame."""
#Update logo screen
if self.state == APP_STATE_LOGO:
#Is the logo delay over?
if self.logo_delay == 0:
self.gui.switch_to_screen("TitleScreen", FadeTransition())
self.gui.start_title_anim()
self.state = APP_STATE_TITLE
#If not, update the delay timer
else:
self.logo_delay -= 1
#Update title screen
elif self.state == APP_STATE_TITLE:
pass
#Update campaign select screen
elif self.state == APP_STATE_CAMPAIGN_SELECT:
pass
#Update login screen
elif self.state == APP_STATE_LOGIN:
pass
#Update campaign mode screen
elif self.state == APP_STATE_CAMPAIGN:
pass
#Update new account screen
elif self.state == APP_STATE_NEW_ACCOUNT:
pass
#Update change password screen
elif self.state == APP_STATE_CHANGE_PASSWORD:
pass
#This task continues infinitely
return Task.cont
user_exit = ShowBase.userExit
class Player():
def __init__(self, world):
self.world = world
self.root = self.world.root.attach_new_node("player")
self.root_target = self.world.root.attach_new_node("player_target")
self.pivot = self.root.attach_new_node("player_pivot")
base.camera.reparent_to(self.pivot)
base.camera.set_z(1.7)
base.cam.node().get_lens().set_fov(90)
self.traverser = CollisionTraverser()
self.ray = setup_ray(
self.pivot,
self.traverser,
self.world.mask,
# ray ends well below feet to register downward slopes
(0, 0, 1),
(0, 0, -1))
self.xyh_inertia = Vec3(0, 0, 0)
h_acc = ConfigVariableDouble('mouse-accelleration', 0.1).get_value()
self.xyh_acceleration = Vec3(0.8, 0.8, h_acc)
self.friction = 0.15
self.torque = 0.5
self.last_up = Vec3(0, 0, 1)
# Collider for portals
csphere = CollisionSphere(0, 0, 1.25, 1.5)
cnode = CollisionNode('player')
cnode.add_solid(csphere)
cnode.set_from_collide_mask(0x2)
cnode.set_into_collide_mask(CollideMask.all_off())
self.collider = self.root.attach_new_node(cnode)
self.event_handler = CollisionHandlerEvent()
self.event_handler.add_in_pattern('into-%in')
self.traverser.add_collider(self.collider, self.event_handler)
self.collider.show()
self.teleported = False
base.input.set_mouse_relativity(True)
def handle_input(self):
dt = globalClock.get_dt()
directional_keys = (["strafe_right",
"strafe_left"], ["forward", "backward"])
for k, keys in enumerate(directional_keys):
if base.input.buttons[keys[0]]:
self.xyh_inertia[k] += self.xyh_acceleration[k] * dt
elif base.input.buttons[keys[1]]:
self.xyh_inertia[k] -= self.xyh_acceleration[k] * dt
self.xyh_inertia[k] /= 1 + self.friction
if base.mouseWatcherNode.hasMouse():
h = base.input.mouse_movement.x * self.xyh_acceleration[2] * dt
self.pivot.set_h(self.pivot, h)
p = base.input.mouse_movement.y * self.xyh_acceleration[2] * dt
base.cam.set_p(base.cam, p)
base.cam.set_p(max(-70, min(base.cam.get_p(), 70)))
#base.cam.set_r(0)
def ray_to_destination(self, xonly=0):
if xonly:
self.ray["node"].set_x(self.pivot, self.xyh_inertia[1] * xonly)
self.ray["node"].set_y(self.pivot, 0)
else:
self.ray["node"].set_x(self.pivot, self.xyh_inertia[0])
self.ray["node"].set_y(self.pivot, self.xyh_inertia[1])
def move_to_ray(self):
self.ray["handler"].sort_entries()
#closest_entry = list(self.ray["handler"].entries)[0]
closest_entry = None
delta = float('inf')
dot = -1.0
for c in list(self.ray["handler"].entries):
if closest_entry is None:
closest_entry = c
delta = c.get_surface_point(self.root).length()
dot = self.last_up.dot(c.get_surface_normal(render))
continue
if c.get_surface_point(self.root).length() < delta:
if self.last_up.dot(c.get_surface_normal(render)) > dot:
closest_entry = c
dot = self.last_up.dot(c.get_surface_normal(render))
delta = c.get_surface_point(self.root).length()
collision_point = closest_entry.get_surface_point(render)
collision_normal = closest_entry.get_surface_normal(render)
self.last_up = collision_normal
# take heed of the ray ending well below feet
#collision_point.set_z(max(0,collision_point.z))
self.root.set_pos(render, collision_point)
self.root_target.set_pos(render, collision_point)
self.root_target.heads_up(render, collision_point, collision_normal)
def update(self):
if self.teleported:
self.xyh_inertia = Vec3(0, self.xyh_acceleration[1], 0)
self.teleported = False
dt = globalClock.get_dt()
self.handle_input()
if self.xyh_inertia.length() > 0:
self.ray_to_destination()
self.traverser.traverse(render)
if self.ray["handler"].get_num_entries() > 0:
self.move_to_ray()
else:
self.ray_to_destination(-1)
self.traverser.traverse(render)
if self.ray["handler"].get_num_entries() > 0:
self.move_to_ray()
else:
self.ray_to_destination(1)
self.traverser.traverse(render)
if self.ray["handler"].get_num_entries() > 0:
self.move_to_ray()
self.ray["node"].set_y(self.pivot, 0)
current_quat = self.root.get_quat()
target_quat = self.root_target.get_quat()
current_quat.normalize()
target_quat.normalize()
if current_quat.is_same_direction(target_quat):
self.root.set_quat(target_quat)
return
self.root.set_quat(current_quat + (target_quat - current_quat) *
(ROTATION_SPEED * dt))
