function setup_jumping(touch_jump, on_ground_sens) {
var key_space = m_ctl.create_keyboard_sensor(m_ctl.KEY_SPACE);
var jump_cb = function(obj, id, pulse) {
if (pulse == 1 && _char_wrapper.state != m_conf.CH_ATTACK) {
_char_wrapper.state = m_conf.CH_JUMP;
m_phy.character_jump(obj);
var id = Math.floor(_char_jump_spks.length * Math.random());
m_sfx.play_def(_char_jump_spks[id]);
m_anim.apply(_char_wrapper.rig, m_conf.CHAR_JUMP_ANIM);
m_anim.set_behavior(_char_wrapper.rig, m_anim.AB_FINISH_STOP);
m_anim.play(_char_wrapper.rig);
_char_wrapper.move_state.forw_back = 0;
_char_wrapper.move_state.left_right = 0;
}
}
var landing_cb = function(obj, id, pulse) {
if (pulse == 1) {
m_sfx.play_def(_char_land_spk);
if (_char_wrapper.state != m_conf.CH_ATTACK)
_char_wrapper.state = m_conf.CH_STILL;
}
}
m_ctl.create_sensor_manifold(_char_wrapper.phys_body, "JUMP",
m_ctl.CT_TRIGGER, [key_space, touch_jump, on_ground_sens],
function(s){return (s[0] || s[1]) && s[2]}, jump_cb);
m_ctl.create_sensor_manifold(_char_wrapper.phys_body, "LANDING",
m_ctl.CT_TRIGGER, [on_ground_sens], null, landing_cb);
}
function setup_movement(up_arrow, down_arrow) {
var key_w = m_ctl.create_keyboard_sensor(m_ctl.KEY_W);
var key_s = m_ctl.create_keyboard_sensor(m_ctl.KEY_S);
var key_up = m_ctl.create_keyboard_sensor(m_ctl.KEY_UP);
var key_down = m_ctl.create_keyboard_sensor(m_ctl.KEY_DOWN);
var move_array = [
key_w, key_up, up_arrow,
key_s, key_down, down_arrow
];
var forward_logic = function(s){return (s[0] || s[1] || s[2])};
var backward_logic = function(s){return (s[3] || s[4] || s[5])};
function move_cb(obj, id, pulse) {
if (pulse == 1) {
switch(id) {
case "FORWARD":
var move_dir = 1;
m_anim.apply(_character_rig, "character_run");
break;
case "BACKWARD":
var move_dir = -1;
m_anim.apply(_character_rig, "character_run");
break;
}
} else {
var move_dir = 0;
m_anim.apply(_character_rig, "character_idle_01");
}
m_phy.set_character_move_dir(obj, move_dir, 0);
m_anim.play(_character_rig);
m_anim.set_behavior(_character_rig, m_anim.AB_CYCLIC);
};
m_ctl.create_sensor_manifold(_character, "FORWARD", m_ctl.CT_TRIGGER,
move_array, forward_logic, move_cb);
m_ctl.create_sensor_manifold(_character, "BACKWARD", m_ctl.CT_TRIGGER,
move_array, backward_logic, move_cb);
m_anim.apply(_character_rig, "character_idle_01");
m_anim.play(_character_rig);
m_anim.set_behavior(_character_rig, m_anim.AB_CYCLIC);
}
function setup_jumping() {
var key_space = m_ctl.create_keyboard_sensor(m_ctl.KEY_SPACE);
var jump_cb = function(obj, id, pulse) {
m_phy.character_jump(obj);
}
m_ctl.create_sensor_manifold(_character, "JUMP", m_ctl.CT_SHOT,
[key_space], null, jump_cb);
}
function setup_jumping(touch_jump) {
var key_space = m_ctl.create_keyboard_sensor(m_ctl.KEY_SPACE);
var jump_cb = function(obj, id, pulse) {
if (pulse == 1) {
m_phy.character_jump(obj);
}
}
m_ctl.create_sensor_manifold(_character, "JUMP", m_ctl.CT_TRIGGER,
[key_space, touch_jump], function(s){return s[0] || s[1]}, jump_cb);
}
function setup_anime() {
var key_up = m_ctl.create_keyboard_sensor(m_ctl.KEY_UP);
var key_down = m_ctl.create_keyboard_sensor(m_ctl.KEY_ENTER);
var move_array = [
key_up,
key_down
];
var forward_logic = function(s){return (s[0] || s[1])};
var backward_logic = function(s){return (s[1] || s[2])};
function move_cb(obj, id, pulse) {
if (pulse == 1) {
switch(id) {
case "WALK":
m_anim.apply(_character_rig, "walk_001");
m_anim.set_behavior(_character_rig, m_anim.AB_CYCLIC)
break;
case "KICK":
m_anim.apply(_character_rig, "kick_001");
m_anim.set_behavior(_character_rig, m_anim.AB_FINISH_STOP);
break;
}
} else {
m_anim.apply(_character_rig, "stand_001");
}
m_anim.play(_character_rig);
m_anim.set_behavior(_character_rig, m_anim.AB_CYCLIC);
};
m_ctl.create_sensor_manifold(_character_rig, "WALK", m_ctl.CT_TRIGGER,
move_array, forward_logic, move_cb);
m_ctl.create_sensor_manifold(_character_rig, "KICK", m_ctl.CT_TRIGGER,
move_array, backward_logic, move_cb);
}
function register_keyboard() {
var key_w = m_ctl.create_keyboard_sensor(m_ctl.KEY_W);
var key_s = m_ctl.create_keyboard_sensor(m_ctl.KEY_S);
var key_a = m_ctl.create_keyboard_sensor(m_ctl.KEY_A);
var key_d = m_ctl.create_keyboard_sensor(m_ctl.KEY_D);
var key_cb = function(obj, id, pulse, param) {
if (pulse == 1) {
var elapsed = m_ctl.get_sensor_value(obj, id, 0);
var velocity = m_cam.get_velocities(obj, _velocity_tmp);
switch (id) {
case "LEFT":
_dest_x_trans -= velocity.trans * COCKPIT_TRANS_FACTOR * elapsed;
break;
case "RIGHT":
_dest_x_trans += velocity.trans * COCKPIT_TRANS_FACTOR * elapsed;
break;
case "UP":
_dest_y_trans += velocity.trans * COCKPIT_TRANS_FACTOR * elapsed;
break;
case "DOWN":
_dest_y_trans -= velocity.trans * COCKPIT_TRANS_FACTOR * elapsed;
break;
}
}
}
var elapsed = m_ctl.create_elapsed_sensor();
var cam_obj = m_scs.get_active_camera();
m_ctl.create_sensor_manifold(cam_obj, "LEFT", m_ctl.CT_CONTINUOUS,
[elapsed, key_a], null, key_cb);
m_ctl.create_sensor_manifold(cam_obj, "RIGHT", m_ctl.CT_CONTINUOUS,
[elapsed, key_d], null, key_cb);
m_ctl.create_sensor_manifold(cam_obj, "UP", m_ctl.CT_CONTINUOUS,
[elapsed, key_w], null, key_cb);
m_ctl.create_sensor_manifold(cam_obj, "DOWN", m_ctl.CT_CONTINUOUS,
[elapsed, key_s], null, key_cb);
}
function setup_rotation() {
var key_a = m_ctl.create_keyboard_sensor(m_ctl.KEY_A);
var key_d = m_ctl.create_keyboard_sensor(m_ctl.KEY_D);
var key_left = m_ctl.create_keyboard_sensor(m_ctl.KEY_LEFT);
var key_right = m_ctl.create_keyboard_sensor(m_ctl.KEY_RIGHT);
var elapsed_sensor = m_ctl.create_elapsed_sensor();
var rotate_array = [
key_a, key_left,
key_d, key_right,
elapsed_sensor
];
var left_logic = function(s){return (s[0] || s[1])};
var right_logic = function(s){return (s[2] || s[3])};
function rotate_cb(obj, id, pulse) {
var elapsed = m_ctl.get_sensor_value(obj, "LEFT", 4);
if (pulse == 1) {
switch(id) {
case "LEFT":
m_phy.character_rotation_inc(obj, elapsed * ROT_SPEED, 0);
break;
case "RIGHT":
m_phy.character_rotation_inc(obj, -elapsed * ROT_SPEED, 0);
break;
}
}
}
m_ctl.create_sensor_manifold(_character, "LEFT", m_ctl.CT_CONTINUOUS,
rotate_array, left_logic, rotate_cb);
m_ctl.create_sensor_manifold(_character, "RIGHT", m_ctl.CT_CONTINUOUS,
rotate_array, right_logic, rotate_cb);
}
function create_sensors(troll_rig, gamepad_id, sensor_cb, anim_sensor_cb) {
var gs_w = m_ctl.create_gamepad_btn_sensor(m_input.GMPD_BUTTON_12, gamepad_id);
var gs_d = m_ctl.create_gamepad_btn_sensor(m_input.GMPD_BUTTON_15, gamepad_id);
var gs_s = m_ctl.create_gamepad_btn_sensor(m_input.GMPD_BUTTON_13, gamepad_id);
var gs_a = m_ctl.create_gamepad_btn_sensor(m_input.GMPD_BUTTON_14, gamepad_id);
var key_a = m_ctl.create_keyboard_sensor(m_ctl.KEY_A);
var key_s = m_ctl.create_keyboard_sensor(m_ctl.KEY_S);
var key_d = m_ctl.create_keyboard_sensor(m_ctl.KEY_D);
var key_w = m_ctl.create_keyboard_sensor(m_ctl.KEY_W);
var key_left = m_ctl.create_keyboard_sensor(m_ctl.KEY_LEFT);
var key_down = m_ctl.create_keyboard_sensor(m_ctl.KEY_DOWN);
var key_right = m_ctl.create_keyboard_sensor(m_ctl.KEY_RIGHT);
var key_up = m_ctl.create_keyboard_sensor(m_ctl.KEY_UP);
var left_vert_axis = m_ctl.create_gamepad_axis_sensor(m_input.GMPD_AXIS_1, gamepad_id);
var left_hor_axis = m_ctl.create_gamepad_axis_sensor(m_input.GMPD_AXIS_0, gamepad_id);
var e_s = m_ctl.create_elapsed_sensor();
var anim_logic_func = function(s) {
return s[0] || s[1] || s[2] || s[3] || s[4] || s[5] || s[6];
}
m_ctl.create_sensor_manifold(troll_rig, "UP", m_ctl.CT_CONTINUOUS,
[gs_w, key_w, key_up, left_vert_axis, left_hor_axis, e_s],
function() {return true}, sensor_cb);
m_ctl.create_sensor_manifold(troll_rig, "DOWN", m_ctl.CT_CONTINUOUS,
[gs_s, key_s, key_down, left_vert_axis, left_hor_axis, e_s],
function() {return true}, sensor_cb);
m_ctl.create_sensor_manifold(troll_rig, "RIGHT", m_ctl.CT_CONTINUOUS,
[gs_d, key_d, key_right, left_vert_axis, left_hor_axis, e_s],
function() {return true}, sensor_cb);
m_ctl.create_sensor_manifold(troll_rig, "LEFT", m_ctl.CT_CONTINUOUS,
[gs_a, key_a, key_left, left_vert_axis, left_hor_axis, e_s],
function() {return true}, sensor_cb);
m_ctl.create_sensor_manifold(troll_rig, "PLAY_ANIM", m_ctl.CT_TRIGGER,
[gs_w, gs_s, left_vert_axis, key_w, key_s, key_up, key_down],
anim_logic_func, anim_sensor_cb);
}
function setup_movement(up_arrow, down_arrow, left_arrow, right_arrow, on_ground_sens) {
var key_w = m_ctl.create_keyboard_sensor(m_ctl.KEY_W);
var key_s = m_ctl.create_keyboard_sensor(m_ctl.KEY_S);
var key_up = m_ctl.create_keyboard_sensor(m_ctl.KEY_UP);
var key_down = m_ctl.create_keyboard_sensor(m_ctl.KEY_DOWN);
var key_a = m_ctl.create_keyboard_sensor(m_ctl.KEY_A);
var key_d = m_ctl.create_keyboard_sensor(m_ctl.KEY_D);
var move_array = [
key_w, key_up, up_arrow,
key_s, key_down, down_arrow,
on_ground_sens,
key_a, left_arrow,
key_d, right_arrow
];
var move_state = _char_wrapper.move_state;
var forward_logic = function(s){return (s[0] || s[1] || s[2])};
var backward_logic = function(s){return (s[3] || s[4] || s[5])};
var left_logic = function(s){return s[7] || s[8]};
var right_logic = function(s){return s[9] || s[10]};
function move_cb(obj, id, pulse) {
if (_char_wrapper.state == m_conf.CH_ATTACK) {
m_phy.set_character_move_dir(obj, 0, 0);
return;
}
var on_ground = m_ctl.get_sensor_value(obj, id, 6);
if (pulse == 1) {
switch(id) {
case "FORWARD":
move_state.forw_back = 1;
break;
case "BACKWARD":
move_state.forw_back = -1;
break;
case "LEFT":
move_state.left_right = 1;
break;
case "RIGHT":
move_state.left_right = -1;
break;
}
if (_char_wrapper.state != m_conf.CH_JUMP)
_char_wrapper.state = m_conf.CH_RUN;
} else {
switch(id) {
case "FORWARD":
case "BACKWARD":
move_state.forw_back = 0;
break;
case "LEFT":
case "RIGHT":
move_state.left_right = 0;
break;
}
if (_char_wrapper.state != m_conf.CH_JUMP)
_char_wrapper.state = m_conf.CH_STILL;
}
if ((move_state.forw_back || move_state.left_right) && on_ground) {
if (!m_sfx.is_play(_char_run_spk))
m_sfx.play_def(_char_run_spk);
} else {
if (m_sfx.is_play(_char_run_spk))
m_sfx.stop(_char_run_spk);
}
m_phy.set_character_move_dir(obj, move_state.forw_back,
move_state.left_right);
};
m_ctl.create_sensor_manifold(_char_wrapper.phys_body, "FORWARD",
m_ctl.CT_CONTINUOUS, move_array, forward_logic, move_cb);
m_ctl.create_sensor_manifold(_char_wrapper.phys_body, "BACKWARD",
m_ctl.CT_CONTINUOUS, move_array, backward_logic, move_cb);
m_ctl.create_sensor_manifold(_char_wrapper.phys_body, "LEFT",
m_ctl.CT_CONTINUOUS, move_array, left_logic, move_cb);
m_ctl.create_sensor_manifold(_char_wrapper.phys_body, "RIGHT",
m_ctl.CT_CONTINUOUS, move_array, right_logic, move_cb);
function anim_cb(obj, id, pulse) {
if (_char_wrapper.state == m_conf.CH_ATTACK)
return;
var on_ground = m_ctl.get_sensor_value(obj, id, 0);
var cur_anim = m_anim.get_current_anim_name(_char_wrapper.rig);
var required_anim = m_conf.CHAR_IDLE_ANIM;
if (_char_wrapper.state == m_conf.CH_JUMP) {
var required_anim = m_conf.CHAR_JUMP_ANIM;
} else if (move_state.forw_back == 1) {
var required_anim = m_conf.CHAR_RUN_ANIM;
} else if (move_state.forw_back == -1) {
var required_anim = m_conf.CHAR_RUN_ANIM;
m_anim.set_speed(_char_wrapper.rig, -1);
} else if (move_state.left_right == 1) {
var required_anim = m_conf.CHAR_STRAFE;
m_anim.set_speed(_char_wrapper.rig, -1);
} else if (move_state.left_right == -1) {
var required_anim = m_conf.CHAR_STRAFE;
}
if (cur_anim != required_anim) {
m_anim.apply(_char_wrapper.rig, required_anim);
m_anim.play(_char_wrapper.rig);
m_anim.set_behavior(_char_wrapper.rig, m_anim.AB_CYCLIC);
}
}
m_ctl.create_sensor_manifold(_char_wrapper.phys_body, "CHAR_ANIM",
m_ctl.CT_CONTINUOUS, [on_ground_sens], function(s){return true}, anim_cb);
// character material animation
if (_char_wrapper.body) {
m_anim.apply(_char_wrapper.body, m_conf.CHAR_HEAL_PICK_ANIM);
m_anim.apply(_char_wrapper.body, m_conf.CHAR_LAVA_PROT_ANIM,
m_anim.SLOT_1);
m_anim.apply(_char_wrapper.body, m_conf.CHAR_SHIELD_PICK_ANIM,
m_anim.SLOT_2);
}
// sound
m_sfx.stop(_char_run_spk);
}
exports.enable_object_controls = function(obj) {
var trans_speed = 1;
var is_vehicle = m_phy.is_vehicle_chassis(obj) ||
m_phy.is_vehicle_hull(obj);
var key_cb = function(obj, id, pulse) {
if (pulse == 1) {
var elapsed = m_ctl.get_sensor_value(obj, id, 0);
switch (id) {
case "FORWARD":
if (is_vehicle)
m_phy.vehicle_throttle(obj, 1);
else
m_trans.move_local(obj, 0, 0, trans_speed * elapsed);
break;
case "BACKWARD":
if (is_vehicle)
m_phy.vehicle_throttle(obj, -1);
else
m_trans.move_local(obj, 0, 0, -trans_speed * elapsed);
break;
case "LEFT":
if (is_vehicle)
m_phy.vehicle_steer(obj, -1);
else
m_trans.move_local(obj, trans_speed * elapsed, 0, 0);
break;
case "RIGHT":
if (is_vehicle)
m_phy.vehicle_steer(obj, 1);
else
m_trans.move_local(obj, -trans_speed * elapsed, 0, 0);
break;
default:
break;
}
} else {
switch (id) {
case "FORWARD":
case "BACKWARD":
if (is_vehicle)
m_phy.vehicle_throttle(obj, 0);
break;
case "LEFT":
case "RIGHT":
if (is_vehicle)
m_phy.vehicle_steer(obj, 0);
break;
default:
break;
}
}
}
var elapsed = m_ctl.create_elapsed_sensor();
var key_w = m_ctl.create_keyboard_sensor(m_ctl.KEY_W);
var key_s = m_ctl.create_keyboard_sensor(m_ctl.KEY_S);
var key_a = m_ctl.create_keyboard_sensor(m_ctl.KEY_A);
var key_d = m_ctl.create_keyboard_sensor(m_ctl.KEY_D);
var key_up = m_ctl.create_keyboard_sensor(m_ctl.KEY_UP);
var key_down = m_ctl.create_keyboard_sensor(m_ctl.KEY_DOWN);
var key_left = m_ctl.create_keyboard_sensor(m_ctl.KEY_LEFT);
var key_right = m_ctl.create_keyboard_sensor(m_ctl.KEY_RIGHT);
var key_logic = function(s) {
return s[0] && (s[1] || s[2]);
}
m_ctl.create_sensor_manifold(obj, "FORWARD", m_ctl.CT_CONTINUOUS,
[elapsed, key_w, key_up], key_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "BACKWARD", m_ctl.CT_CONTINUOUS,
[elapsed, key_s, key_down], key_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "LEFT", m_ctl.CT_CONTINUOUS,
[elapsed, key_a, key_left], key_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "RIGHT", m_ctl.CT_CONTINUOUS,
[elapsed, key_d, key_right], key_logic, key_cb);
}
exports.enable_camera_controls = function(trans_speed, rot_speed, zoom_speed,
disable_default_pivot) {
if (!trans_speed)
var trans_speed = 1;
if (!rot_speed)
var rot_speed = 1;
if (!zoom_speed)
var zoom_speed = 1;
// NOTE: hack to allow fullscreen
document.addEventListener("keydown", on_key_fullscreen, false);
function on_key_fullscreen(e) {
if (e.keyCode == m_ctl.KEY_O)
request_fullscreen(document.body);
else if (e.keyCode == m_ctl.KEY_P) {
if (m_main.is_paused())
m_main.resume();
else
m_main.pause();
}
}
var obj = m_scs.get_active_camera();
switch (m_cam.get_move_style(obj)) {
case m_cam.MS_TARGET_CONTROLS:
var use_pivot = !disable_default_pivot;
break;
case m_cam.MS_EYE_CONTROLS:
var use_pivot = false;
break;
case m_cam.MS_STATIC:
return;
}
var elapsed = m_ctl.create_elapsed_sensor();
var use_physics = m_phy.has_simulated_physics(obj);
var key_cb = function(obj, id, pulse) {
// clear forces
if (use_physics)
m_phy.apply_force(obj, 0, 0, 0);
if (pulse == 1) {
var elapsed = m_ctl.get_sensor_value(obj, id, 0);
var CAM_FORCE_MULT = [1800, 2100, 1800];
var t_mult = m_cam.get_trans_speed(obj);
var r_mult = 2.0;
switch (id) {
case "FORWARD":
if (use_physics)
m_phy.apply_force(obj, 0, -CAM_FORCE_MULT[1], 0);
else
m_trans.move_local(obj, 0, -trans_speed * t_mult * elapsed, 0);
break;
case "BACKWARD":
if (use_physics)
m_phy.apply_force(obj, 0, CAM_FORCE_MULT[1], 0);
else
m_trans.move_local(obj, 0, trans_speed * t_mult * elapsed, 0);
break;
case "UP":
if (use_physics)
m_phy.apply_force(obj, 0, 0, -CAM_FORCE_MULT[2]);
else
m_trans.move_local(obj, 0, 0, -trans_speed * t_mult * elapsed);
break;
case "DOWN":
if (use_physics)
m_phy.apply_force(obj, 0, 0, CAM_FORCE_MULT[2]);
else
m_trans.move_local(obj, 0, 0, trans_speed * t_mult * elapsed);
break;
case "LEFT":
if (use_physics)
m_phy.apply_force(obj, -CAM_FORCE_MULT[0], 0, 0);
else
m_trans.move_local(obj, -trans_speed * t_mult * elapsed, 0, 0);
break;
case "RIGHT":
if (use_physics)
m_phy.apply_force(obj, CAM_FORCE_MULT[0], 0, 0);
else
m_trans.move_local(obj, trans_speed * t_mult * elapsed, 0, 0);
break;
case "ROT_LEFT":
if (use_pivot)
m_cam.rotate_pivot(obj, -rot_speed * r_mult * elapsed, 0);
else
m_cam.rotate(obj, rot_speed * r_mult * elapsed, 0);
break;
case "ROT_RIGHT":
if (use_pivot)
m_cam.rotate_pivot(obj, rot_speed * r_mult * elapsed, 0);
else
m_cam.rotate(obj, -rot_speed * r_mult * elapsed, 0);
break;
case "ROT_UP":
if (use_pivot)
m_cam.rotate_pivot(obj, 0, -rot_speed * r_mult * elapsed);
else
m_cam.rotate(obj, 0, -rot_speed * r_mult * elapsed);
break;
case "ROT_DOWN":
if (use_pivot)
m_cam.rotate_pivot(obj, 0, rot_speed * r_mult * elapsed);
else
m_cam.rotate(obj, 0, rot_speed * r_mult * elapsed);
break;
case "ROT_LEFT":
if (use_pivot)
m_cam.rotate_pivot(obj, -rot_speed * r_mult * elapsed, 0);
else
m_cam.rotate(obj, rot_speed * r_mult * elapsed, 0);
break;
case "ROT_RIGHT":
if (use_pivot)
m_cam.rotate_pivot(obj, rot_speed * r_mult * elapsed, 0);
else
m_cam.rotate(obj, -rot_speed * r_mult * elapsed, 0);
break;
default:
break;
}
}
}
var key_w = m_ctl.create_keyboard_sensor(m_ctl.KEY_W);
var key_s = m_ctl.create_keyboard_sensor(m_ctl.KEY_S);
var key_a = m_ctl.create_keyboard_sensor(m_ctl.KEY_A);
var key_d = m_ctl.create_keyboard_sensor(m_ctl.KEY_D);
var key_r = m_ctl.create_keyboard_sensor(m_ctl.KEY_R);
var key_f = m_ctl.create_keyboard_sensor(m_ctl.KEY_F);
var key_up = m_ctl.create_keyboard_sensor(m_ctl.KEY_UP);
var key_down = m_ctl.create_keyboard_sensor(m_ctl.KEY_DOWN);
var key_left = m_ctl.create_keyboard_sensor(m_ctl.KEY_LEFT);
var key_right = m_ctl.create_keyboard_sensor(m_ctl.KEY_RIGHT);
var key_single_logic = null;
var key_double_logic = function(s) {
return s[0] && (s[1] || s[2]);
}
m_ctl.create_sensor_manifold(obj, "FORWARD", m_ctl.CT_CONTINUOUS,
[elapsed, key_w], key_single_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "BACKWARD", m_ctl.CT_CONTINUOUS,
[elapsed, key_s], key_single_logic, key_cb);
if (use_pivot) {
m_ctl.create_sensor_manifold(obj, "ROT_UP", m_ctl.CT_CONTINUOUS,
[elapsed, key_up, key_r], key_double_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "ROT_DOWN", m_ctl.CT_CONTINUOUS,
[elapsed, key_down, key_f], key_double_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "ROT_LEFT", m_ctl.CT_CONTINUOUS,
[elapsed, key_left, key_a], key_double_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "ROT_RIGHT", m_ctl.CT_CONTINUOUS,
[elapsed, key_right, key_d], key_double_logic, key_cb);
} else {
m_ctl.create_sensor_manifold(obj, "UP", m_ctl.CT_CONTINUOUS,
[elapsed, key_r], key_double_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "DOWN", m_ctl.CT_CONTINUOUS,
[elapsed, key_f], key_double_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "LEFT", m_ctl.CT_CONTINUOUS,
[elapsed, key_a], key_double_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "RIGHT", m_ctl.CT_CONTINUOUS,
[elapsed, key_d], key_double_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "ROT_UP", m_ctl.CT_CONTINUOUS,
[elapsed, key_up], key_double_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "ROT_DOWN", m_ctl.CT_CONTINUOUS,
[elapsed, key_down], key_double_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "ROT_LEFT", m_ctl.CT_CONTINUOUS,
[elapsed, key_left], key_double_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "ROT_RIGHT", m_ctl.CT_CONTINUOUS,
[elapsed, key_right], key_double_logic, key_cb);
}
// mouse wheel: camera zooming and translation speed adjusting
var dest_zoom_mouse = 0;
var mouse_wheel = m_ctl.create_mouse_wheel_sensor();
var mouse_wheel_cb = function(obj, id, pulse) {
if (pulse == 1) {
var value = m_ctl.get_sensor_value(obj, id, 0);
if (use_pivot) {
// camera zooming
var cam_pivot = _vec3_tmp;
var cam_eye = m_cam.get_eye(obj);
m_cam.get_pivot(obj, cam_pivot);
var dist = m_vec3.dist(cam_pivot, cam_eye);
var t_mult = -value * dist * MOUSE_ZOOM_FACTOR * trans_speed;
dest_zoom_mouse += t_mult;
} else {
// translation speed adjusting
var factor = value * zoom_speed;
var camera = m_scs.get_active_camera();
m_cam.change_trans_speed(camera, factor);
}
}
}
m_ctl.create_sensor_manifold(obj, "MOUSE_WHEEL", m_ctl.CT_LEVEL,
[mouse_wheel], null, mouse_wheel_cb);
// camera zooming with touch
var dest_zoom_touch = 0;
var touch_zoom = m_ctl.create_touch_zoom_sensor();
var touch_zoom_cb = function(obj, id, pulse, param) {
if (pulse == 1) {
if (use_pivot) {
var value = m_ctl.get_sensor_value(obj, id, 0);
var cam_pivot = _vec3_tmp;
var cam_eye = m_cam.get_eye(obj);
m_cam.get_pivot(obj, cam_pivot);
var dist = m_vec3.dist(cam_pivot, cam_eye);
var t_mult = -value * dist * TOUCH_ZOOM_FACTOR * trans_speed;
dest_zoom_touch += t_mult;
}
}
}
m_ctl.create_sensor_manifold(obj, "TOUCH_ZOOM", m_ctl.CT_LEVEL,
[touch_zoom], null, touch_zoom_cb);
// camera zoom smoothing
var zoom_interp_cb = function(obj, id, pulse) {
if (pulse == 1 && (Math.abs(dest_zoom_mouse) > 0.001 ||
Math.abs(dest_zoom_touch) > 0.001)
&& use_pivot) {
var value = m_ctl.get_sensor_value(obj, id, 0);
var zoom_mouse = m_util.smooth(dest_zoom_mouse, 0, value, CAM_SMOOTH_ZOOM_MOUSE);
dest_zoom_mouse -= zoom_mouse;
var zoom_touch = m_util.smooth(dest_zoom_touch, 0, value, CAM_SMOOTH_ZOOM_TOUCH);
dest_zoom_touch -= zoom_touch;
m_trans.move_local(obj, 0, zoom_mouse + zoom_touch, 0);
}
}
m_ctl.create_sensor_manifold(obj, "ZOOM_INTERPOL", m_ctl.CT_CONTINUOUS,
[elapsed], null, zoom_interp_cb);
// camera rotation with mouse
var dest_x_mouse = 0;
var dest_y_mouse = 0;
var mouse_move_x = m_ctl.create_mouse_move_sensor("X");
var mouse_move_y = m_ctl.create_mouse_move_sensor("Y");
var mouse_down = m_ctl.create_mouse_click_sensor();
var mouse_cb = function(obj, id, pulse, param) {
if (pulse == 1) {
var value = m_ctl.get_sensor_value(obj, id, 1);
if (use_pivot) {
var r_mult = MOUSE_ROTATION_MULT_PX * rot_speed;
dest_x_mouse += (param == "X") ? -value * r_mult : 0;
dest_y_mouse += (param == "Y") ? -value * r_mult : 0;
}
}
}
m_ctl.create_sensor_manifold(obj, "MOUSE_X", m_ctl.CT_LEVEL,
[mouse_down, mouse_move_x], null, mouse_cb, "X");
m_ctl.create_sensor_manifold(obj, "MOUSE_Y", m_ctl.CT_LEVEL,
[mouse_down, mouse_move_y], null, mouse_cb, "Y");
// camera rotation with touch
var dest_x_touch = 0;
var dest_y_touch = 0;
var touch_move_x = m_ctl.create_touch_move_sensor("X");
var touch_move_y = m_ctl.create_touch_move_sensor("Y");
var touch_cb = function(obj, id, pulse, param) {
if (pulse == 1) {
if (use_pivot) {
var r_mult = TOUCH_ROTATION_MULT_PX * rot_speed;
var value = m_ctl.get_sensor_value(obj, id, 0);
dest_x_touch += (param == "X") ? -value * r_mult : 0;
dest_y_touch += (param == "Y") ? -value * r_mult : 0;
}
}
}
m_ctl.create_sensor_manifold(obj, "TOUCH_X", m_ctl.CT_LEVEL,
[touch_move_x], null, touch_cb, "X");
m_ctl.create_sensor_manifold(obj, "TOUCH_Y", m_ctl.CT_LEVEL,
[touch_move_y], null, touch_cb, "Y");
// camera rotation smoothing
var rot_interp_cb = function(obj, id, pulse) {
if (pulse == 1 && (Math.abs(dest_x_mouse) > 0.001 ||
Math.abs(dest_y_mouse) > 0.001 ||
Math.abs(dest_x_touch) > 0.001 ||
Math.abs(dest_y_touch) > 0.001)
&& use_pivot) {
var value = m_ctl.get_sensor_value(obj, id, 0);
var x_mouse = m_util.smooth(dest_x_mouse, 0, value, CAM_SMOOTH_ROT_MOUSE);
var y_mouse = m_util.smooth(dest_y_mouse, 0, value, CAM_SMOOTH_ROT_MOUSE);
dest_x_mouse -= x_mouse;
dest_y_mouse -= y_mouse;
var x_touch = m_util.smooth(dest_x_touch, 0, value, CAM_SMOOTH_ROT_TOUCH);
var y_touch = m_util.smooth(dest_y_touch, 0, value, CAM_SMOOTH_ROT_TOUCH);
dest_x_touch -= x_touch;
dest_y_touch -= y_touch;
m_cam.rotate_pivot(obj, x_mouse + x_touch, y_mouse + y_touch);
}
}
m_ctl.create_sensor_manifold(obj, "ROT_INTERPOL", m_ctl.CT_CONTINUOUS,
[elapsed], null, rot_interp_cb);
// some additinal controls
m_ctl.create_kb_sensor_manifold(obj, "TOGGLE_CAMERA_COLLISION", m_ctl.CT_SHOT,
m_ctl.KEY_C, function() {toggle_camera_collisions_usage();});
m_ctl.create_kb_sensor_manifold(obj, "DEC_STEREO_DIST", m_ctl.CT_SHOT,
m_ctl.KEY_LEFT_SQ_BRACKET, function(obj, id, pulse) {
var dist = m_cam.get_stereo_distance(obj);
m_cam.set_stereo_distance(obj, 0.9 * dist);
});
m_ctl.create_kb_sensor_manifold(obj, "INC_STEREO_DIST", m_ctl.CT_SHOT,
m_ctl.KEY_RIGHT_SQ_BRACKET, function(obj, id, pulse) {
var dist = m_cam.get_stereo_distance(obj);
m_cam.set_stereo_distance(obj, 1.1 * dist);
});
}
b4w.register("cel_fps_new_year", function(exports, require) {
// import modules used by the app
var m_app = require("app");
var m_cons = require("constraints");
var m_ctl = require("controls");
var m_data = require("data");
var m_main = require("main");
var m_mouse = require("mouse");
var m_phy = require("physics");
var m_scs = require("scenes");
var m_trans = require("transform");
var m_anim = require("animation");
var m_sfx = require("sfx");
/**
* export the method to initialize the app (called at the bottom of this file)
*/
exports.init = function() {
m_app.init({
canvas_container_id: "main_canvas_container",
callback: init_cb,
show_fps: true,
console_verbose: true,
autoresize: true
});
}
/**
* callback executed when the app is initizalized
*/
function init_cb(canvas_elem, success) {
if (!success) {
console.log("b4w init failure");
return;
}
m_app.enable_controls(canvas_elem);
//canvas_elem.addEventListener("click", main_canvas_click);
window.addEventListener("resize", resize);
canvas_elem.addEventListener("mousedown", main_canvas_click, false);
load();
var cross_bar = document.getElementById("crossbar");
cross_bar.style.visibility = "visible";
}
/**
* load the scene data
*/
function load() {
m_data.load("main_scene.json", load_cb);
}
/**
* callback executed when the scene is loaded
*/
function load_cb(data_id) {
//m_app.enable_controls();
//m_app.enable_camera_controls();
// place your code here
// make camera follow the character
var camobj = m_scs.get_active_camera();
var character = m_scs.get_first_character();
m_cons.append_stiff_trans(camobj, character, [0, 0.7, 0]);
// enable rotation with mouse
var canvas_elem = m_main.get_canvas_elem();
canvas_elem.addEventListener("mouseup", function(e) {
m_mouse.request_pointerlock(canvas_elem);
}, false);
setup_movement()
var env_sound;
env_sound = m_scs.get_object_by_name("env_sound")
m_sfx.play_def(env_sound);
}
function main_canvas_click(e) {
if (e.preventDefault)
e.preventDefault();
var canvas = document.getElementById("main_canvas_container");
var x = canvas.clientWidth/2;
var y = canvas.clientHeight/2;
/*var obj = m_scs.pick_object(x, y);
m_anim.apply_def(obj);
m_anim.play(obj);
m_anim.stop(obj);*/
}
function resize() {
m_app.resize_to_container();
}
var key_a = m_ctl.create_keyboard_sensor(m_ctl.KEY_A);
var key_s = m_ctl.create_keyboard_sensor(m_ctl.KEY_S);
var key_d = m_ctl.create_keyboard_sensor(m_ctl.KEY_D);
var key_w = m_ctl.create_keyboard_sensor(m_ctl.KEY_W);
var key_space = m_ctl.create_keyboard_sensor(m_ctl.KEY_SPACE);
var key_shift = m_ctl.create_keyboard_sensor(m_ctl.KEY_SHIFT);
var move_state = {
left_right: 0,
forw_back: 0
}
function setup_movement() {
var steps;
steps = m_scs.get_object_by_name("walk");
var key_a = m_ctl.create_keyboard_sensor(m_ctl.KEY_A);
var key_s = m_ctl.create_keyboard_sensor(m_ctl.KEY_S);
var key_d = m_ctl.create_keyboard_sensor(m_ctl.KEY_D);
var key_w = m_ctl.create_keyboard_sensor(m_ctl.KEY_W);
var key_space = m_ctl.create_keyboard_sensor(m_ctl.KEY_SPACE);
var key_shift = m_ctl.create_keyboard_sensor(m_ctl.KEY_SHIFT);
var move_state = {
left_right: 0,
forw_back: 0
}
var move_array = [key_w, key_s, key_a, key_d, key_shift];
var character = m_scs.get_first_character();
var move_cb = function(obj, id, pulse) {
if (pulse == 1) {
switch (id) {
case "FORWARD":
move_state.forw_back = 1;
break;
case "BACKWARD":
move_state.forw_back = -1;
break;
case "LEFT":
move_state.left_right = 1;
break;
case "RIGHT":
move_state.left_right = -1;
break;
case "RUNNING":
m_phy.set_character_move_type(obj, m_phy.CM_RUN);
break;
}
} else {
switch (id) {
case "FORWARD":
case "BACKWARD":
move_state.forw_back = 0;
break;
case "LEFT":
case "RIGHT":
move_state.left_right = 0;
break;
case "RUNNING":
m_phy.set_character_move_type(obj, m_phy.CM_WALK);
break;
}
}
m_phy.set_character_move_dir(obj, move_state.forw_back,
move_state.left_right);
if (move_state.forw_back) {
if (!m_sfx.is_play(steps))
m_sfx.play_def(steps);
} else {
if (m_sfx.is_play(steps))
m_sfx.stop(steps);
}
};
m_ctl.create_sensor_manifold(character, "FORWARD", m_ctl.CT_TRIGGER,
move_array, function(s) {return s[0]}, move_cb);
m_ctl.create_sensor_manifold(character, "BACKWARD", m_ctl.CT_TRIGGER,
move_array, function(s) {return s[1]}, move_cb);
m_ctl.create_sensor_manifold(character, "LEFT", m_ctl.CT_TRIGGER,
move_array, function(s) {return s[2]}, move_cb);
m_ctl.create_sensor_manifold(character, "RIGHT", m_ctl.CT_TRIGGER,
move_array, function(s) {return s[3]}, move_cb);
var running_logic = function(s) {
return (s[0] || s[1] || s[2] || s[3]) && s[4];
}
m_ctl.create_sensor_manifold(character, "RUNNING", m_ctl.CT_TRIGGER,
move_array, running_logic, move_cb);
var jump_cb = function(obj, id, pulse) {
m_phy.character_jump(obj);
}
m_ctl.create_sensor_manifold(character, "JUMP", m_ctl.CT_SHOT,
[key_space], null, jump_cb);
}
});
function setup_movement() {
var steps;
steps = m_scs.get_object_by_name("walk");
var key_a = m_ctl.create_keyboard_sensor(m_ctl.KEY_A);
var key_s = m_ctl.create_keyboard_sensor(m_ctl.KEY_S);
var key_d = m_ctl.create_keyboard_sensor(m_ctl.KEY_D);
var key_w = m_ctl.create_keyboard_sensor(m_ctl.KEY_W);
var key_space = m_ctl.create_keyboard_sensor(m_ctl.KEY_SPACE);
var key_shift = m_ctl.create_keyboard_sensor(m_ctl.KEY_SHIFT);
var move_state = {
left_right: 0,
forw_back: 0
}
var move_array = [key_w, key_s, key_a, key_d, key_shift];
var character = m_scs.get_first_character();
var move_cb = function(obj, id, pulse) {
if (pulse == 1) {
switch (id) {
case "FORWARD":
move_state.forw_back = 1;
break;
case "BACKWARD":
move_state.forw_back = -1;
break;
case "LEFT":
move_state.left_right = 1;
break;
case "RIGHT":
move_state.left_right = -1;
break;
case "RUNNING":
m_phy.set_character_move_type(obj, m_phy.CM_RUN);
break;
}
} else {
switch (id) {
case "FORWARD":
case "BACKWARD":
move_state.forw_back = 0;
break;
case "LEFT":
case "RIGHT":
move_state.left_right = 0;
break;
case "RUNNING":
m_phy.set_character_move_type(obj, m_phy.CM_WALK);
break;
}
}
m_phy.set_character_move_dir(obj, move_state.forw_back,
move_state.left_right);
if (move_state.forw_back) {
if (!m_sfx.is_play(steps))
m_sfx.play_def(steps);
} else {
if (m_sfx.is_play(steps))
m_sfx.stop(steps);
}
};
m_ctl.create_sensor_manifold(character, "FORWARD", m_ctl.CT_TRIGGER,
move_array, function(s) {return s[0]}, move_cb);
m_ctl.create_sensor_manifold(character, "BACKWARD", m_ctl.CT_TRIGGER,
move_array, function(s) {return s[1]}, move_cb);
m_ctl.create_sensor_manifold(character, "LEFT", m_ctl.CT_TRIGGER,
move_array, function(s) {return s[2]}, move_cb);
m_ctl.create_sensor_manifold(character, "RIGHT", m_ctl.CT_TRIGGER,
move_array, function(s) {return s[3]}, move_cb);
var running_logic = function(s) {
return (s[0] || s[1] || s[2] || s[3]) && s[4];
}
m_ctl.create_sensor_manifold(character, "RUNNING", m_ctl.CT_TRIGGER,
move_array, running_logic, move_cb);
var jump_cb = function(obj, id, pulse) {
m_phy.character_jump(obj);
}
m_ctl.create_sensor_manifold(character, "JUMP", m_ctl.CT_SHOT,
[key_space], null, jump_cb);
}
exports.enable_mixer_controls = function() {
init();
// switch mixer strip / switch mixer param
var key_left_sqbr = m_ctl.create_keyboard_sensor(m_ctl.KEY_LEFT_SQ_BRACKET);
var key_right_sqbr = m_ctl.create_keyboard_sensor(m_ctl.KEY_RIGHT_SQ_BRACKET);
// change mixer param value / mute-solo
var key_semi = m_ctl.create_keyboard_sensor(m_ctl.KEY_SEMI_COLON);
var key_quote = m_ctl.create_keyboard_sensor(m_ctl.KEY_SINGLE_QUOTE);
// modifier key
var key_shift = m_ctl.create_keyboard_sensor(m_ctl.KEY_SHIFT);
var timer_slow = m_ctl.create_timer_sensor(0.15);
var timer_fast = m_ctl.create_timer_sensor(0.05);
var mixer_keys = [key_left_sqbr, key_right_sqbr, key_semi, key_quote,
key_shift, timer_slow, timer_fast];
var switch_strip_logic = function(s) {
return ((s[0] || s[1]) && !s[4]);
}
var switch_strip_logic_hold = function(s) {
return ((s[0] || s[1]) && !s[4] && s[5]);
}
var switch_param_logic = function(s) {
return ((s[0] || s[1]) && s[4]);
}
var switch_spk_cb = function(obj, id, pulse) {
if (pulse == 1) {
var dir = Boolean(m_ctl.get_sensor_value(obj, id, 0)) ? -1 : 1;
switch_strip(dir);
if (id == "SWITCH_STRIP")
m_ctl.reset_timer_sensor(obj, id, 5, 0.3);
else
m_ctl.reset_timer_sensor(obj, id, 5, 0);
} else {
// hold on some time
m_ctl.reset_timer_sensor(obj, id, 5, 10);
}
}
m_ctl.create_sensor_manifold(null, "SWITCH_STRIP", m_ctl.CT_TRIGGER,
mixer_keys, switch_strip_logic, switch_spk_cb);
m_ctl.create_sensor_manifold(null, "SWITCH_STRIP_HOLD", m_ctl.CT_SHOT,
mixer_keys, switch_strip_logic_hold, switch_spk_cb);
var switch_param_cb = function(obj, id, pulse) {
var dir = Boolean(m_ctl.get_sensor_value(obj, id, 0)) ? -1 : 1;
switch_param(dir);
}
m_ctl.create_sensor_manifold(null, "SWITCH_PARAM", m_ctl.CT_SHOT,
mixer_keys, switch_param_logic, switch_param_cb);
var inc_dec_cb = function(obj, id, pulse) {
if (pulse == 1) {
var dir = Boolean(m_ctl.get_sensor_value(obj, id, 2)) ? -1 : 1;
param_inc_dec(dir);
if (id == "INC_DEC")
m_ctl.reset_timer_sensor(obj, id, 6, 0.3);
else
m_ctl.reset_timer_sensor(obj, id, 6, 0);
} else {
// hold on some time
m_ctl.reset_timer_sensor(obj, id, 6, 10);
}
}
var inc_dec_logic = function(s) {
return ((s[2] || s[3]) && !s[4]);
}
var inc_dec_logic_hold = function(s) {
return ((s[2] || s[3]) && !s[4] && s[6]);
}
m_ctl.create_sensor_manifold(null, "INC_DEC", m_ctl.CT_TRIGGER,
mixer_keys, inc_dec_logic, inc_dec_cb);
m_ctl.create_sensor_manifold(null, "INC_DEC_HOLD", m_ctl.CT_SHOT,
mixer_keys, inc_dec_logic_hold, inc_dec_cb);
var mute_solo_cb = function(obj, id, pulse) {
var mute_solo = Boolean(m_ctl.get_sensor_value(obj, id, 2));
if (mute_solo)
switch_mute();
else
switch_solo();
}
var mute_solo_logic = function(s) {
return ((s[2] || s[3]) && s[4]);
}
m_ctl.create_sensor_manifold(null, "MUTE_SOLO", m_ctl.CT_SHOT,
mixer_keys, mute_solo_logic, mute_solo_cb);
var elapsed = m_ctl.create_elapsed_sensor();
m_ctl.create_sensor_manifold(null, "MIXER_DRAW", m_ctl.CT_CONTINUOUS,
[elapsed], null, function() {draw()});
var timer = m_ctl.create_timer_sensor(1);
m_ctl.create_sensor_manifold(null, "MIXER_UPDATE", m_ctl.CT_TRIGGER,
[timer], null, function() {
var strip_range = active_strip_range();
for (var i = strip_range[0]; i <= strip_range[1]; i++)
update_strip_params(_mixer_strips[i]);
});
}
exports.enable_camera_controls = function(trans_speed, rot_speed, zoom_speed,
disable_default_pivot) {
if (!trans_speed)
var trans_speed = 1;
if (!rot_speed)
var rot_speed = 1;
if (!zoom_speed)
var zoom_speed = 1;
var obj = m_scs.get_active_camera();
switch (m_cam.get_move_style(obj)) {
case m_cam.MS_TARGET_CONTROLS:
var use_pivot = !disable_default_pivot;
var character = null;
break;
case m_cam.MS_EYE_CONTROLS:
var use_pivot = false;
var character = m_scs.get_first_character();
break;
case m_cam.MS_STATIC:
return;
}
var elapsed = m_ctl.create_elapsed_sensor();
if (m_phy.has_simulated_physics(obj)) {
var collision = m_ctl.create_collision_sensor(obj, null, true);
var collision_cb = function(obj, id, pulse) {
if (pulse == 1) {
var col_pt = m_ctl.get_sensor_payload(obj, id, 1);
var trans = m_trans.get_translation(obj, _vec3_tmp);
var delta = _vec3_tmp2;
m_vec3.sub(trans, col_pt, delta);
m_vec3.normalize(delta, delta);
m_vec3.scale(delta, COLL_RESPONSE_NORMAL_FACTOR, delta);
m_vec3.add(trans, delta, trans);
m_trans.set_translation_v(obj, trans);
}
}
m_ctl.create_sensor_manifold(obj, "CAMERA_COLLISION", m_ctl.CT_CONTINUOUS,
[elapsed, collision], null, collision_cb);
}
if (character) {
// apply camera transform to character
var trans = m_trans.get_translation(obj);
var quat = m_trans.get_rotation(obj);
var char_quat = m_util.cam_quat_to_mesh_quat(quat);
trans[1] -= CHAR_HEAD_POSITION;
m_phy.set_transform(character, trans, char_quat);
m_cons.append_stiff_trans(obj, character, [0, 0.5, 0]);
var char_dir = new Float32Array(2);
var is_fly = true;
m_phy.set_character_move_type(character, m_phy.CM_FLY);
var move_type_cb = function() {
is_fly = !is_fly;
m_phy.set_character_move_type(character, is_fly ? m_phy.CM_FLY : m_phy.CM_WALK);
}
m_ctl.create_kb_sensor_manifold(obj, "TOGGLE_CHAR_MOVE_TYPE",
m_ctl.CT_SHOT, m_ctl.KEY_C, move_type_cb);
}
var key_cb = function(obj, id, pulse) {
// block movement when in collision with some other object
if (collision && m_ctl.get_sensor_value(obj, "CAMERA_COLLISION", 1))
return;
if (pulse == 1) {
var elapsed = m_ctl.get_sensor_value(obj, id, 0);
var t_mult = m_cam.get_trans_speed(obj);
var r_mult = 2.0;
switch (id) {
case "FORWARD":
if (character)
char_dir[0] = 1;
else
m_trans.move_local(obj, 0, -trans_speed * t_mult * elapsed, 0);
break;
case "BACKWARD":
if (character)
char_dir[0] = -1;
else
m_trans.move_local(obj, 0, trans_speed * t_mult * elapsed, 0);
break;
case "UP":
if (!character)
m_trans.move_local(obj, 0, 0, -trans_speed * t_mult * elapsed);
break;
case "DOWN":
if (!character)
m_trans.move_local(obj, 0, 0, trans_speed * t_mult * elapsed);
break;
case "LEFT":
if (character)
char_dir[1] = 1;
else
m_trans.move_local(obj, -trans_speed * t_mult * elapsed, 0, 0);
break;
case "RIGHT":
if (character)
char_dir[1] = -1;
else
m_trans.move_local(obj, trans_speed * t_mult * elapsed, 0, 0);
break;
case "ROT_LEFT":
if (use_pivot)
m_cam.rotate_pivot(obj, -rot_speed * r_mult * elapsed, 0);
else
m_cam.rotate(obj, rot_speed * r_mult * elapsed, 0);
break;
case "ROT_RIGHT":
if (use_pivot)
m_cam.rotate_pivot(obj, rot_speed * r_mult * elapsed, 0);
else
m_cam.rotate(obj, -rot_speed * r_mult * elapsed, 0);
break;
case "ROT_UP":
if (use_pivot)
m_cam.rotate_pivot(obj, 0, -rot_speed * r_mult * elapsed);
else
m_cam.rotate(obj, 0, -rot_speed * r_mult * elapsed);
break;
case "ROT_DOWN":
if (use_pivot)
m_cam.rotate_pivot(obj, 0, rot_speed * r_mult * elapsed);
else
m_cam.rotate(obj, 0, rot_speed * r_mult * elapsed);
break;
default:
break;
}
} else {
switch (id) {
case "FORWARD":
case "BACKWARD":
if (character)
char_dir[0] = 0;
break;
case "LEFT":
case "RIGHT":
if (character)
char_dir[1] = 0;
break;
}
}
if (character) {
m_phy.set_character_move_dir(character, char_dir[0], char_dir[1]);
var angles = _vec2_tmp;
m_cam.get_angles(obj, angles);
angles[0] += Math.PI;
angles[1] *= -1;
m_phy.set_character_rotation(character, angles[0], angles[1]);
}
}
var key_w = m_ctl.create_keyboard_sensor(m_ctl.KEY_W);
var key_s = m_ctl.create_keyboard_sensor(m_ctl.KEY_S);
var key_a = m_ctl.create_keyboard_sensor(m_ctl.KEY_A);
var key_d = m_ctl.create_keyboard_sensor(m_ctl.KEY_D);
var key_r = m_ctl.create_keyboard_sensor(m_ctl.KEY_R);
var key_f = m_ctl.create_keyboard_sensor(m_ctl.KEY_F);
var key_up = m_ctl.create_keyboard_sensor(m_ctl.KEY_UP);
var key_down = m_ctl.create_keyboard_sensor(m_ctl.KEY_DOWN);
var key_left = m_ctl.create_keyboard_sensor(m_ctl.KEY_LEFT);
var key_right = m_ctl.create_keyboard_sensor(m_ctl.KEY_RIGHT);
var key_single_logic = null;
var key_double_logic = function(s) {
return s[0] && (s[1] || s[2]);
}
m_ctl.create_sensor_manifold(obj, "FORWARD", m_ctl.CT_CONTINUOUS,
[elapsed, key_w], key_single_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "BACKWARD", m_ctl.CT_CONTINUOUS,
[elapsed, key_s], key_single_logic, key_cb);
if (use_pivot) {
m_ctl.create_sensor_manifold(obj, "ROT_UP", m_ctl.CT_CONTINUOUS,
[elapsed, key_up, key_r], key_double_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "ROT_DOWN", m_ctl.CT_CONTINUOUS,
[elapsed, key_down, key_f], key_double_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "ROT_LEFT", m_ctl.CT_CONTINUOUS,
[elapsed, key_left, key_a], key_double_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "ROT_RIGHT", m_ctl.CT_CONTINUOUS,
[elapsed, key_right, key_d], key_double_logic, key_cb);
} else {
m_ctl.create_sensor_manifold(obj, "UP", m_ctl.CT_CONTINUOUS,
[elapsed, key_r], key_double_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "DOWN", m_ctl.CT_CONTINUOUS,
[elapsed, key_f], key_double_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "LEFT", m_ctl.CT_CONTINUOUS,
[elapsed, key_a], key_double_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "RIGHT", m_ctl.CT_CONTINUOUS,
[elapsed, key_d], key_double_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "ROT_UP", m_ctl.CT_CONTINUOUS,
[elapsed, key_up], key_double_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "ROT_DOWN", m_ctl.CT_CONTINUOUS,
[elapsed, key_down], key_double_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "ROT_LEFT", m_ctl.CT_CONTINUOUS,
[elapsed, key_left], key_double_logic, key_cb);
m_ctl.create_sensor_manifold(obj, "ROT_RIGHT", m_ctl.CT_CONTINUOUS,
[elapsed, key_right], key_double_logic, key_cb);
}
// mouse wheel: camera zooming and translation speed adjusting
var dest_zoom_mouse = 0;
var mouse_wheel = m_ctl.create_mouse_wheel_sensor();
var mouse_wheel_cb = function(obj, id, pulse) {
if (pulse == 1) {
var value = m_ctl.get_sensor_value(obj, id, 0);
if (use_pivot) {
// camera zooming
var cam_pivot = _vec3_tmp;
var cam_eye = m_cam.get_eye(obj);
m_cam.get_pivot(obj, cam_pivot);
var dist = m_vec3.dist(cam_pivot, cam_eye);
var t_mult = -value * dist * MOUSE_ZOOM_FACTOR * trans_speed;
dest_zoom_mouse += t_mult;
} else {
// translation speed adjusting
var factor = value * zoom_speed;
var camera = m_scs.get_active_camera();
m_cam.change_trans_speed(camera, factor);
}
}
}
m_ctl.create_sensor_manifold(obj, "MOUSE_WHEEL", m_ctl.CT_LEVEL,
[mouse_wheel], null, mouse_wheel_cb);
// camera zooming with touch
var dest_zoom_touch = 0;
var touch_zoom = m_ctl.create_touch_zoom_sensor();
var touch_zoom_cb = function(obj, id, pulse, param) {
if (pulse == 1) {
if (use_pivot) {
var value = m_ctl.get_sensor_value(obj, id, 0);
var cam_pivot = _vec3_tmp;
var cam_eye = m_cam.get_eye(obj);
m_cam.get_pivot(obj, cam_pivot);
var dist = m_vec3.dist(cam_pivot, cam_eye);
var t_mult = -value * dist * TOUCH_ZOOM_FACTOR * trans_speed;
dest_zoom_touch += t_mult;
}
}
}
m_ctl.create_sensor_manifold(obj, "TOUCH_ZOOM", m_ctl.CT_LEVEL,
[touch_zoom], null, touch_zoom_cb);
// camera zoom smoothing
var zoom_interp_cb = function(obj, id, pulse) {
if (pulse == 1 && (Math.abs(dest_zoom_mouse) > 0.001 ||
Math.abs(dest_zoom_touch) > 0.001)
&& use_pivot) {
var value = m_ctl.get_sensor_value(obj, id, 0);
var zoom_mouse = m_util.smooth(dest_zoom_mouse, 0, value, CAM_SMOOTH_ZOOM_MOUSE);
dest_zoom_mouse -= zoom_mouse;
var zoom_touch = m_util.smooth(dest_zoom_touch, 0, value, CAM_SMOOTH_ZOOM_TOUCH);
dest_zoom_touch -= zoom_touch;
// block movement when in collision with some other object
if (collision && m_ctl.get_sensor_value(obj, "CAMERA_COLLISION", 1))
return;
m_trans.move_local(obj, 0, zoom_mouse + zoom_touch, 0);
}
}
m_ctl.create_sensor_manifold(obj, "ZOOM_INTERPOL", m_ctl.CT_CONTINUOUS,
[elapsed], null, zoom_interp_cb);
// camera rotation with mouse
var dest_x_mouse = 0;
var dest_y_mouse = 0;
var mouse_move_x = m_ctl.create_mouse_move_sensor("X");
var mouse_move_y = m_ctl.create_mouse_move_sensor("Y");
var mouse_down = m_ctl.create_mouse_click_sensor();
var mouse_cb = function(obj, id, pulse, param) {
if (pulse == 1) {
var value = m_ctl.get_sensor_value(obj, id, 1);
var r_mult = MOUSE_ROTATION_MULT_PX * rot_speed;
dest_x_mouse += (param == "X") ? -value * r_mult : 0;
dest_y_mouse += (param == "Y") ? -value * r_mult : 0;
}
}
m_ctl.create_sensor_manifold(obj, "MOUSE_X", m_ctl.CT_LEVEL,
[mouse_down, mouse_move_x], null, mouse_cb, "X");
m_ctl.create_sensor_manifold(obj, "MOUSE_Y", m_ctl.CT_LEVEL,
[mouse_down, mouse_move_y], null, mouse_cb, "Y");
// camera rotation with touch
var dest_x_touch = 0;
var dest_y_touch = 0;
var touch_move_x = m_ctl.create_touch_move_sensor("X");
var touch_move_y = m_ctl.create_touch_move_sensor("Y");
var touch_cb = function(obj, id, pulse, param) {
if (pulse == 1) {
var r_mult = TOUCH_ROTATION_MULT_PX * rot_speed;
var value = m_ctl.get_sensor_value(obj, id, 0);
dest_x_touch += (param == "X") ? -value * r_mult : 0;
dest_y_touch += (param == "Y") ? -value * r_mult : 0;
}
}
m_ctl.create_sensor_manifold(obj, "TOUCH_X", m_ctl.CT_LEVEL,
[touch_move_x], null, touch_cb, "X");
m_ctl.create_sensor_manifold(obj, "TOUCH_Y", m_ctl.CT_LEVEL,
[touch_move_y], null, touch_cb, "Y");
// camera rotation smoothing
var rot_interp_cb = function(obj, id, pulse) {
if (pulse == 1 && (Math.abs(dest_x_mouse) > 0.001 ||
Math.abs(dest_y_mouse) > 0.001 ||
Math.abs(dest_x_touch) > 0.001 ||
Math.abs(dest_y_touch) > 0.001)) {
var value = m_ctl.get_sensor_value(obj, id, 0);
var x_mouse = m_util.smooth(dest_x_mouse, 0, value, CAM_SMOOTH_ROT_MOUSE);
var y_mouse = m_util.smooth(dest_y_mouse, 0, value, CAM_SMOOTH_ROT_MOUSE);
dest_x_mouse -= x_mouse;
dest_y_mouse -= y_mouse;
var x_touch = m_util.smooth(dest_x_touch, 0, value, CAM_SMOOTH_ROT_TOUCH);
var y_touch = m_util.smooth(dest_y_touch, 0, value, CAM_SMOOTH_ROT_TOUCH);
dest_x_touch -= x_touch;
dest_y_touch -= y_touch;
if (use_pivot) {
m_cam.rotate_pivot(obj, x_mouse + x_touch, y_mouse + y_touch);
} else {
m_cam.rotate(obj, (x_mouse + x_touch) * EYE_ROTATION_DECREMENT,
-(y_mouse + y_touch) * EYE_ROTATION_DECREMENT);
if (character) {
var angles = _vec2_tmp;
m_cam.get_angles(obj, angles);
angles[0] += Math.PI;
angles[1] *= -1;
m_phy.set_character_rotation(character, angles[0], angles[1]);
}
}
}
}
m_ctl.create_sensor_manifold(obj, "ROT_INTERPOL", m_ctl.CT_CONTINUOUS,
[elapsed], null, rot_interp_cb);
m_ctl.create_kb_sensor_manifold(obj, "DEC_STEREO_DIST", m_ctl.CT_SHOT,
m_ctl.KEY_LEFT_SQ_BRACKET, function(obj, id, pulse) {
var dist = m_cam.get_stereo_distance(obj);
m_cam.set_stereo_distance(obj, 0.9 * dist);
});
m_ctl.create_kb_sensor_manifold(obj, "INC_STEREO_DIST", m_ctl.CT_SHOT,
m_ctl.KEY_RIGHT_SQ_BRACKET, function(obj, id, pulse) {
var dist = m_cam.get_stereo_distance(obj);
m_cam.set_stereo_distance(obj, 1.1 * dist);
});
}