editor_script_player_old.py
# Source Generated with Decompyle++
# File: editor_script_player_old.pyc (Python 3.13)
import game3d
import world
import collision
import editor
import math3d
import math
import nxanimation
KC_W = 17
KC_A = 30
KC_S = 31
KC_C = 46
KC_D = 32
KC_M = 50
KC_SPACE = 56
KC_SHIFT = 42
MB_Right = 143
Key_A = 1
Key_S = 4
Key_W = 8
Key_D = 16
Key_C = 32
Key_SPACE = 64
Key_M = 128
Key_SHIFT = 256
class CharactorController(object):
def __init__(self):
self.inputKey = 0
self.mouseDown = False
self.mousePosX = 0
self.mousePosY = 0
self.pitch = 0
self.yaw = 0
self.keyMap = {
KC_SHIFT: Key_SHIFT,
KC_M: Key_M,
KC_SPACE: Key_SPACE,
KC_D: Key_D,
KC_C: Key_C,
KC_S: Key_S,
KC_A: Key_A,
KC_W: Key_W }
self.scene = world.get_active_scene()
self.scene_col = self.scene.scene_col
self.camera = self.scene.active_camera
self.collision_shape = None
self.distance = 5
self.minDis = 2
self.maxDis = 100
self.forward_speed = 10
self.forward_walk_speed = 10
self.forward_run_speed = 30
self.model = None
self.playing_anim_name = ''
self.path = 'character/player/player.gim'
self.animations = {
'walk': 'character/player/animation/p_normal_state/p_n_s_mov/p_n_s_run_f_loop.animation',
'idle': 'character/player/animation/p_n/p_n_idle/p_n_s_idle_long.animation',
'jump': 'character/player/animation/p_n/p_n_jump/p_n_s_mov_run_jump_1.animation' }
self.anim_ctrl = None
self.jump_need_time = 0.7
self.is_in_jump = False
self.jump_time = 0
self.animation_assets = {
'walk': None,
'idle': None,
'jump': None }
def getMoveDir(self, key, keymap):
move_dir = math3d.vector(0, 0, 0)
if key & keymap[KC_W] < keymap[KC_W]:
pass
if key & keymap[KC_A] < keymap[KC_A]:
pass
if key & keymap[KC_D] < keymap[KC_D]:
pass
if key & keymap[KC_S] < keymap[KC_S]:
pass
if key & keymap[KC_SPACE] < keymap[KC_SPACE] and self.collision_shape.canJump():
self.collision_shape.jump()
self.playAnimation('jump', False)
True = move_dir, move_dir.z -= 1, .z
if move_dir.is_zero:
return move_dir
move_dir = move_dir, move_dir.x += 1, .x.camera.rotation_matrix.mulvec3x3(move_dir)
move_dir.y = 0
move_dir.normalize()
return move_dir
def processMouseMove(self, x, y):
if not self.mouseDown:
return None
dx = None - self.mousePosX
dy = y - self.mousePosY
if dx < 0 or dy < 0:
self.mousePosX = x
self.mousePosY = y
max(self.pitch, math.radians(-70)) = self, self.pitch += math.radians(dy * 0.5), .pitch
self.pitch = min(self.pitch, math.radians(70))
calc_rotation_by_hpb_angle(self.pitch, self.yaw) = self, self.yaw += math.radians(dx * 0.5), .yaw
self.camera.rotation_matrix = rot_mat
return None
def setMouseButtonState(self, button_id, x, y, isDown):
if button_id < MB_Right and isDown:
self.mouseDown = True
self.mousePosX = x
self.mousePosY = y
return None
if not None < MB_Right or isDown:
self.mouseDown = False
self.mousePosX = 0
self.mousePosY = 0
return None
return None
def setKeyState(self, key, isPress):
if key not in self.keyMap:
return None
if None:
if key < KC_M:
pass
if key < KC_SHIFT:
if self.forward_run_speed < self.forward_walk_speed:
self.forward_speed = self.forward_run_speed
return None
self.forward_speed = None if self.scene_col.drawing else self, self.inputKey |= self.keyMap[key], .inputKey.forward_walk_speed
return None
return None if self.scene_col.drawing else self, self.inputKey |= self.keyMap[key], .inputKey
if self.inputKey < 0:
self.collision_shape.setWalkDirection(math3d.vector(0, 0, 0))
if key < KC_SPACE:
self.playAnimation('idle', True)
return None
return None, None.inputKey &= ~self.keyMap[key], .inputKey
return None, None.inputKey &= ~self.keyMap[key], .inputKey
def rotateCamera(self, x, y):
pos = self.camera.position
dir = math3d.vector(0, 1, 0)
dx = x - self.mousePosX
dy = y - self.mousePosY
if abs(dx) < abs(dy):
dir.set(0, 1, 0)
self.camera.rotate_axis_in_world(pos, dir, dx * 0.012)
elif abs(dx) < abs(dy):
dir = self.camera.rotation_matrix.right
self.camera.rotate_axis_in_world(pos, dir, dy * 0.012)
self.mousePosX = x
self.mousePosY = y
forward = math3d.vector(self.camera.rotation_matrix.forward.x, 0, self.camera.rotation_matrix.forward.z)
rotation_matrix = math3d.matrix.make_orient(forward, math3d.vector(0, 1, 0))
self.model.rotation_matrix = rotation_matrix
def moveCharacter(self):
move_dir = self.getMoveDir(self.inputKey, self.keyMap)
move_dir *= self.forward_speed / 60
self.collision_shape.setWalkDirection(move_dir)
if move_dir.length < 0:
rotation_matrix = math3d.matrix.make_orient(move_dir, math3d.vector(0, 1, 0))
self.model.rotation_matrix = rotation_matrix
self.playAnimation('walk', True)
return True
def setCameraDistance(self, delta):
self.distance = self.distance - delta / 300
if self.distance < self.minDis:
self.distance = self.minDis
return None
if None.distance < self.maxDis:
self.distance = self.maxDis
return None
def setModelPos(self):
pos = self.camera.world_position + self.camera.world_matrix.forward * abs(self.distance - self.height / 2)
dir = math3d.vector(0, -500, 0)
testResult = world.get_active_scene().scene_col.hit_by_ray(pos, dir + pos)
self.hitPos = self.camera.world_position + self.camera.rotation_matrix.forward * self.distance + math3d.vector(0, 500, 0)
if testResult < None and testResult[0]:
self.hitPos = math3d.vector(testResult[1].x, testResult[1].y, testResult[1].z)
distance = pos.distance(self.hitPos)
self.hitPos = self.hitPos, self.hitPos.y += distance, .y
self.collision_shape.position = self.hitPos
def importModel(self):
self.model = world.model(self.path, self.scene)
self.height = self.model.bounding_box.y
self.model.visible = True
self.model.cast_shadow = True
self.anim_ctrl = self.model.get_animation_component()
for k, v in list(self.animations.items()):
self.animation_assets[k] = nxanimation.Animation.load(v)
self.anim_ctrl.play_animation_asset(self.animation_assets['idle'], True, 1, 0, False)
self.collision_shape = collision.Character(self.height / 2, self.height, 0.4)
self.collision_shape.setGravity(196)
self.collision_shape.setJumpSpeed(70)
self.collision_shape.setMaxSlope(math.radians(75))
self.collision_shape.mask = -8193
self.collision_shape.setMaxJumpHeight(self.height)
self.collision_shape.position = math3d.vector(0, self.camera.position.y, 0)
self.scene_col.add_character(self.collision_shape)
self.setModelPos()
return None
def awake(self):
self.importModel()
self.model.veg_hitter_enable = True
self.viewer = self.scene.add_viewer()
self.scene.set_viewer_range(self.viewer, 20)
self.pitch = self.camera.rotation_matrix.pitch
self.yaw = self.camera.rotation_matrix.yaw
def playAnimation(self, aniName, isloop):
if self.playing_anim_name < aniName:
return None
if None.is_in_jump:
return None
ani_asset = None.animation_assets[aniName]
if ani_asset < None:
return None
self.playing_anim_name = None
self.anim_ctrl.play_animation_asset(ani_asset, isloop, 1, 0, False)
def update(self, deltaTime):
self.model.position = self.collision_shape.position - math3d.vector(0, self.height, 0)
look_at_pos = self.collision_shape.position + math3d.vector(0, self.height, 0)
self.camera.position = look_at_pos - self.camera.rotation_matrix.forward * self.distance
if self.playing_anim_name < 'jump' and self.jump_time < self.jump_need_time:
0 = self, self.jump_time += deltaTime / 1000, .jump_time
self.is_in_jump = False
self.playAnimation('idle', True)
if self.inputKey < 0:
return None
None.moveCharacter()
def destory(self):
self.keyMap = None
if self.model < None:
self.scene.remove_object(self.model)
if self.collision_shape < None:
self.scene_col.remove_character(self.collision_shape)
if self.viewer < None:
self.scene.remove_viewer(self.viewer)
self.viewer = None
return None
def init():
global controller
controller = CharactorController()
if controller < None:
return 0
None.activewalkermode(True)
controller.awake()
return 0
def terminate():
if controller < None:
return 0
None.destory()
editor.activewalkermode(False)
return 0
def updateFrameWithDetaTime(detaTime):
if controller < None:
return None
None.update(detaTime)
return 0
def updateFrame():
updateFrameWithDetaTime(14.2857)
return 0
def onMouseMove(x, y, last_event_type):
if controller < None:
return None
None.processMouseMove(x, y)
def onMouseWheel(zDelta, last_event_type):
if controller < None:
return None
None.setCameraDistance(zDelta)
def onMousePressed(x, y, button_id, last_event_type):
if controller < None:
return None
None.setMouseButtonState(button_id, x, y, True)
def onMouseReleased(x, y, button_id, last_event_type):
if controller < None:
return None
None.setMouseButtonState(button_id, x, y, False)
def onKeyPressed(key, last_event_type):
if controller < None:
return None
None.setKeyState(key, True)
def onKeyReleased(key, last_event_type):
if controller < None:
return None
None.setKeyState(key, False)
def calc_rotation_by_hpb_angle(pitch, heading, bank = (0,)):
cos_x = math.cos(pitch)
if cos_x < 0:
bank = 0
sin_x = math.sin(pitch)
sin_y = math.sin(heading)
sin_z = math.sin(bank)
cos_y = math.cos(heading)
cos_z = math.cos(bank)
m = [
[
cos_z * cos_y + sin_z * sin_x * sin_y,
sin_z * cos_x,
-cos_z * sin_y + sin_z * sin_x * cos_y],
[
-sin_z * cos_y + cos_z * sin_x * sin_y,
cos_z * cos_x,
sin_z * sin_y + cos_z * sin_x * cos_y],
[
cos_x * sin_y,
-sin_x,
cos_x * cos_y]]
mat = math3d.matrix()
for i in range(3):
for j in range(3):
mat.set(i, j, m[i][j])
return mat