*UPDATED* Zelda code, ladder, ledge & basic combat

Below is updated Zelda code including:

- ladder climbing
- ledge grabbing
- very very basic combat
- FSW camera

---------------
Ladder climbing
---------------

If the player approaches a surface with flag 1 set to "on" the player will climb the wall like a ladder. The idea is to make a really thin tall block with

one of the surfaces flag 1 set to "on", then to make the block invisible and place a ladder model or sprite there. This doesn't work though as the trace

instruction which looks for a surface with flag 1 as "on" misses invisible blocks. The trace instruction wont detect invisible blocks.

---------------
Ledge grabbing
---------------

When falling, the player will grab onto a ledge, whilst on the ledge you can move left and right, drop down or climb up. The player will grab onto all

ledges even if they have a tilted surface. To stop the player grabbing onto tilted surfaces I suggest programming code to only grab onto walls with a

particular texture or flag set.

---------------
Combat
---------------

Place one or several entities into your level and give them the action lock_on_object. When you press and hold right click or x and are in range of one of

these entites you will lock on. Press ctrl or left click to do a basic attack. To get the attack working, merge a weapon in MED to the guard, get the

verticy numbers of the tip of the sword and the bottom of the sword. Change the values in the function basic_attack().

The combat code has not been improved from this because of my lack of animation skills (plus the amount of work it would take to get it working good).

--------------
Improved camera
--------------

The camera uses a basic FSW system. It doesn't stop clipping, but avoids it and makes the camera move better. The camera code can be tweaked to stop alot

of the clipping, but all the camera will do is stay soo close to the player that it has no chance of clipping.

--------------
Other
--------------

Holding shift will allow the player to walk, holding shift and jumping will cause the player to do a shorter jump.

Whilst holding right click or x use the mouse to pan the player (as long as you haven't locked on).

Copy the jump 2 animation of the guard and paste it into jump 3 (this will allow better looking jumps).

Press space to jump. I have changed the code to jump on space instead of approaching an edge, it seems a better way to play.

Please post any problems or suggestions.

Enjoy!



-------------------------------------------------------------------------------
DEFINE animdist,skill20;

var dist_planar = 200;
var dist_total = 200;
var dist_traced = 0;
var cam_xyangle = player_pan;
var cam_zangle = -15;
var zoffset = 7;
var panoffset = 0;
var viewvec[3];
var slowdown;
var cter = 0;
var player_diff[3];
var player_moveto[3];
var centerstop = 0;
var cam_radius = 400;
var cam_height = 270;
var cam_rotate_speed = 5; //rotation speed of camera when moving
var enable_mouse_move = 0;

var player_head_height = 42; //the distance from the origin to the head of the player
var player_feet_height = 32; //the distance from the origin to the feet of the player
var locked_on = 0;
var lockon_max = 400; //this is how far the player needs to be from the lock on, while locked on, in order to break the lock
var lockon_min = 300; //this is how close the player needs to be to a lock on target in order to iniate lock on when pressing right click
var locked_target[3];

var rotate_speed = 0;
var rotate_to = 0;
var are_we_strafing = 0;
var store_strafe_mode = 0;

var attack_state = 0;
var movement_mode = 0; //for various stages of moving
var temp2[6];
var ledge_climb_z; //this is set to 1 once the player is at a high enough point from climbing a ledge it is hanging onto, used to fix bug when player falls and grabs onto a thin ledge

var jump_z; //temporary variable, is copied into player_diff.z before the move instruction
var jump_force = 18; //change this variable to affect how high the player jumps
var jumping_mode = 0; //0 for not jumping, 1 if jumping
var z_force = 0;
var center[3];
var result = 0;

var global_cam_effect = 0; //the global radius change in rays hitting walls
var walk_speed = 1.5; //the number which running speed is divided by to get walking speed
var ledge_grab_test;

/////////////////////////////////////
entity* player;

/////////////////////////////////////////////

var camera_move_to = 200;
var cradius_speed = 20;

FUNCTION pan_back(){
/* dist_planar = dist_total; //old jump code

temp.x = player.x - dist_total * cos(cam_xyangle);
temp.y = player.y - dist_total * sin(cam_xyangle);
temp.z = player.z - sin(cam_zangle) * 200;

trace_mode = ignore_me + ignore_passable + ignore_models;
trace (player.x, temp.x);
dist_traced = vec_dist(target.x,player.x);
IF (dist_traced < dist_total) {
dist_traced -= 10; // Move it out of the wall
dist_planar = dist_traced;
} ELSE {
dist_planar = dist_total;
}
cam_xyangle = cter;
viewvec.x = player.x - dist_planar * cos(cam_xyangle);
viewvec.y = player.y - dist_planar * sin(cam_xyangle);
viewvec.z = player.z - sin(cam_zangle) * cam_height; */

temp.y = player.y - dist_total * sin(cam_xyangle);
temp.x = player.x - dist_total * cos(cam_xyangle);
temp.z = camera.z;

trace_mode = ignore_me + ignore_passable + ignore_models;
trace (player.x, temp.x);
dist_traced = vec_dist(target.x,player.x);
IF (dist_traced < dist_total) {
dist_traced -= 15; // Move it out of the wall
camera_move_to = dist_traced;
} ELSE {
camera_move_to = dist_total;
}


temp.x = player.x - dist_total * cos(cam_xyangle + 5);
temp.y = player.y - dist_total * sin(cam_xyangle + 5);
temp.z = camera.z;

trace_mode = ignore_me + ignore_passable + ignore_models;
trace (player.x, temp.x);
dist_traced = vec_dist(target.x,player.x);
IF (dist_traced < dist_total) {
camera_move_to -= (dist_total - dist_traced) / 1.3;
}


temp.x = player.x - dist_total * cos(cam_xyangle - 5);
temp.y = player.y - dist_total * sin(cam_xyangle - 5);
temp.z = camera.z;

trace_mode = ignore_me + ignore_passable + ignore_models;
trace (player.x, temp.x);
result = vec_dist(target.x,player.x);
IF (result < dist_traced) {
dist_traced = result;
IF (dist_traced < dist_total) {
camera_move_to -= (dist_total - dist_traced) / 1.3;
}
}


temp.x = player.x - dist_total * cos(cam_xyangle + 10);
temp.y = player.y - dist_total * sin(cam_xyangle + 10);
temp.z = camera.z;

trace_mode = ignore_me + ignore_passable + ignore_models;
trace (player.x, temp.x);
dist_traced = vec_dist(target.x,player.x);
IF (dist_traced < dist_total) {
camera_move_to -= (dist_total - dist_traced) / 3;
}


temp.x = player.x - dist_total * cos(cam_xyangle - 10);
temp.y = player.y - dist_total * sin(cam_xyangle - 10);
temp.z = camera.z;

trace_mode = ignore_me + ignore_passable + ignore_models;
trace (player.x, temp.x);
result = vec_dist(target.x,player.x);
IF (result < dist_traced) {
dist_traced = result;
IF (dist_traced < dist_total) {
camera_move_to -= (dist_total - dist_traced) / 3;
}
}

temp.x = player.x - dist_total * cos(cam_xyangle + 22.5);
temp.y = player.y - dist_total * sin(cam_xyangle + 22.5);
temp.z = camera.z;

trace_mode = ignore_me + ignore_passable + ignore_models;
trace (player.x, temp.x);
dist_traced = vec_dist(target.x,player.x);
IF (dist_traced < dist_total) {
camera_move_to -= (dist_total - dist_traced) / 5;
}


temp.x = player.x - dist_total * cos(cam_xyangle - 22.5);
temp.y = player.y - dist_total * sin(cam_xyangle - 22.5);
temp.z = camera.z;

trace_mode = ignore_me + ignore_passable + ignore_models;
trace (player.x, temp.x);
result = vec_dist(target.x,player.x);
IF (result < dist_traced) {
dist_traced = result;
IF (dist_traced < dist_total) {
camera_move_to -= (dist_total - dist_traced) / 5;
}
}



temp.x = player.x - dist_total * cos(cam_xyangle + 35);
temp.y = player.y - dist_total * sin(cam_xyangle + 35);
temp.z = camera.z;

trace_mode = ignore_me + ignore_passable + ignore_models;
trace (player.x, temp.x);
dist_traced = vec_dist(target.x,player.x);
IF (dist_traced < dist_total) {
camera_move_to -= (dist_total - dist_traced) / 10;
}

temp.x = player.x - dist_total * cos(cam_xyangle - 35);
temp.y = player.y - dist_total * sin(cam_xyangle - 35);
temp.z = camera.z;

trace_mode = ignore_me + ignore_passable + ignore_models;
trace (player.x, temp.x);
result = vec_dist(target.x,player.x);
IF (result < dist_traced) {
dist_traced = result;
camera_move_to -= (dist_total - dist_traced) / 10;
}




temp.x = player.x - dist_total * cos(cam_xyangle + 50);
temp.y = player.y - dist_total * sin(cam_xyangle + 50);
temp.z = camera.z;

trace_mode = ignore_me + ignore_passable + ignore_models;
trace (player.x, temp.x);
dist_traced = vec_dist(target.x,player.x);
IF (dist_traced < dist_total) {
camera_move_to -= (dist_total - dist_traced) / 15;
}

temp.x = player.x - dist_total * cos(cam_xyangle - 50);
temp.y = player.y - dist_total * sin(cam_xyangle - 50);
temp.z = camera.z;

trace_mode = ignore_me + ignore_passable + ignore_models;
trace (player.x, temp.x);
result = vec_dist(target.x,player.x);
IF (result < dist_traced) {
dist_traced = result;
camera_move_to -= (dist_total - dist_traced) / 15;
}

IF (camera_move_to < 15) { camera_move_to = 15; }
IF(abs(dist_planar - camera_move_to) < 20) {
cradius_speed = -0.25 * (dist_planar - camera_move_to);
} ELSE {
IF (dist_planar > camera_move_to) { cradius_speed = -25; }
IF (dist_planar < camera_move_to) { cradius_speed = 25; }
}
IF(abs(dist_planar - camera_move_to) < 50) { //deaccelerate camera before it reaches player
cradius_speed /= 1.3;
}
IF(abs(dist_planar - camera_move_to) < 40) { //deaccelerate camera before it reaches player
cradius_speed /= 1.3;
}
IF(abs(dist_planar - camera_move_to) < 30) {
cradius_speed /= 1.3;
}

var temp2[3];
vec_set(temp2,camera.x);

vec_set(temp,my.x);
vec_sub(temp,temp2.x);
vec_to_angle(temp.pan,temp);
camera.tilt = temp.tilt + zoffset; //this causes the camera to tile towards the player


MY.skill15 += (TIME * cradius_speed) - (min(TIME*0.7,1) * my.skill15);
dist_planar += MY.skill15 * TIME;

cam_xyangle = cter;
viewvec.x = player.x - dist_planar * cos(cam_xyangle);
viewvec.y = player.y - dist_planar * sin(cam_xyangle);
viewvec.z = player.z - sin(cam_zangle) * cam_height;


}


FUNCTION update_views(){
pan_back();
vec_set(camera.x, viewvec.x);
camera.pan = cam_xyangle - panoffset;
// camera.tilt = cam_zangle + zoffset;
camera.roll = 0;
}

////////////////////////////////////////////


FUNCTION init_cameras() {
beep;
camera.size_x = screen_size.x;
camera.size_y = screen_size.y;
camera.visible = on;
}


//////////////////////////////////////////////////

FUNCTION rotate_player(){
IF (jumping_mode == 0) { //so that player cannot control rotation in air
if(key_a == 1) {
rotate_to = cter + 90;
}
if(key_d == 1) {
rotate_to = cter + 270;
}
if(key_w == 1){
rotate_to = cter;
}
if(key_s == 1){
rotate_to = cter + 180;
}

if(key_w == 1 && key_d == 1){
rotate_to = cter + 315;
}

if(key_s == 1 && key_d){
rotate_to = cter + 225;
}

if(key_s == 1 && key_a == 1){
rotate_to = cter + 135;
}

if(key_w == 1 && key_a == 1){
rotate_to = cter + 45;
}

if((key_d == 1 && key_a == 1) || (key_w== 1 && key_s == 1)){
my.pan = my.pan;
rotate_to = my.pan;
}
}

IF (key_d == 1 || key_a == 1 || key_s == 1 || key_w == 1 || jumping_mode != 0) && (store_strafe_mode == 0) {
temp = ang(rotate_to - MY.PAN);
IF(temp > 5) {
rotate_speed = 20;
} ELSE {
IF (temp < -5) {
rotate_speed = -20;
} ELSE {
if(temp > -2) && (temp < 2) { my.skill14 = 0; }
rotate_speed = 3 * ang(rotate_to - MY.PAN);
}
}

MY.skill14 += (TIME * rotate_speed) - (min(TIME*0.7,1) * my.skill14);
MY.PAN += MY.skill14 * TIME;
}

if(cter > 359){ cter -= 360; }
}

//////////////////////////////////////////////////

FUNCTION movement(){
IF (key_a == 1) {
IF (key_shift == 0) {
cter += cam_rotate_speed * time;
} ELSE {
cter += cam_rotate_speed * time * 0.8;
}
player_moveto.x = (center.x + (cam_radius * cos(cter)));
player_moveto.y = (center.y + (cam_radius * sin(cter)));
player_moveto.z = player.z;
vec_diff(player_diff, player_moveto, player.x);
}
IF (key_d == 1) {
IF (key_shift == 0) {
cter -= cam_rotate_speed * time;
} ELSE {
cter -= cam_rotate_speed * time * 0.8;
}
player_moveto.x = (center.x + (cam_radius * cos(cter)));
player_moveto.y = (center.y + (cam_radius * sin(cter)));
vec_diff(player_diff, player_moveto, player.x);
player_moveto.z = player.z;
}

IF (cter > 359){ cter -= 360; }
IF (cter < 0){ cter += 360; }

IF (key_w == 1){
center.x += 10 * cos(cter);
center.y += 10 * sin(cter);
player_moveto.x = (center.x + cam_radius * cos(cter));
player_moveto.y = (center.y + cam_radius * sin(cter));
vec_diff(player_diff, player_moveto, player.x);
player_moveto.z = player.z;
}
IF (key_s == 1){
center.x -= 10 * cos(cter);
center.y -= 10 * sin(cter);
player_moveto.x = (center.x + cam_radius * cos(cter));
player_moveto.y = (center.y + cam_radius * sin(cter));
vec_diff(player_diff, player_moveto, player.x);
player_moveto.z = player.z;
}
IF(key_w == 0) && (key_s == 0) && (key_a == 0) && (key_d == 0) {
vec_set(player_diff, nullvector);
player_moveto.z = player.z;
}
}

FUNCTION strafe_movement(){

IF (key_a == 1) {
player_diff.y = 45 * time;
}
IF (key_d == 1) {
player_diff.y = -45 * time;
}
IF (key_w == 1) {
player_diff.x = 45 * time;
}
IF (key_s == 1) {
player_diff.x = -45 * time;
}
IF(key_w == 0) && (key_s == 0) && (key_a == 0) && (key_d == 0) {
vec_set(player_diff, nullvector);
}
}

//////////////

FUNCTION center_check(){
IF (player.x != (center.x + cam_radius * cos(cter))){
center.x = (player.x - cam_radius * cos(cter));
}
IF (player.y != (center.y + cam_radius * sin(cter))){
center.y = (player.y - cam_radius * sin(cter));
}
}

/////////////////////////////////////////////////////

var ladder_x[3];

ACTION player_action{
player = me;
vec_set(temp,player.x);
// create(<dummy.mdl>,temp,range200_action);
my.fat = off;
my.narrow = on;
my.animdist = 0;

my.enable_detect = on;
my.event = scan_event;

vec_set(temp,my.x);
temp.z -= 4000; // calculate a position 4000 quants below the player
trace_mode = ignore_me+ignore_sprites+ignore_passable+ignore_models+use_box;
result = trace(my.x,temp);// subtract vertical distance to ground
my.z -= result;

ledge_grab_test = 0;

locked_on = 0;
my.skill24 = 0;
are_we_strafing = 0;

WHILE (1){

IF (movement_mode == 0) {
IF (z_force < -2) { //are we falling?
vec_set(temp,my.x); //scan in front of player to see if he has hit a wall
temp.x += 30 * cos(my.pan);
temp.y += 30 * sin(my.pan);
temp.z = my.z + player_head_height; //scan at head height
trace_mode = ignore_me+ignore_sprites+ignore_models;
result = trace(my.x,temp);
IF(result == 0) {
ledge_grab_test = 0;
} ELSE {
IF (result > 0) && (ledge_grab_test == 0) {
vec_to_angle(temp,normal.x);
IF (abs(ang(my.pan - (temp.pan - 180))) < 30) {
temp2.pan = (temp.pan - 180); //make player face towards ladder
vec_set(temp,target.x); //scan to see if there is space up above player for it to grab onto ledge
temp.x += 10 * cos(temp2.pan);
temp.y += 10 * sin(temp2.pan);
temp.z += player_head_height - 2; //scan at head height
target.z += 10;
trace_mode = ignore_me+ignore_sprites+ignore_models;
result = trace(temp.x,target.x);
// vec_to_angle(temp,target.x);
IF (result > 0) { //if we have a wall in the way, and the surface above is less than a 10 degree slant
vec_set(temp,my.x); //scan to see if there is space up above player for it to grab onto ledge
temp.z += player_head_height - 2; //scan at head height
trace_mode = ignore_me+ignore_sprites+ignore_models;
result = trace(temp.x,target.x);
IF (result == 0) { //scan above head to make sure we didn't hit a roof
ledge_grab_test = 1;
movement_mode = 10;
my.pan = temp2.pan; //make player face towards ladder
}
}
}
}
}
}
}


IF (movement_mode == 1) { //ladder climbing
IF(key_w == 1) && (key_s == 0) {
temp.x = 0;
temp.y = 0;
temp.z = 5 * time;
ent_move(temp.x,nullvector);
vec_set(temp,my.x); //scan in front of player to see if there is a climbable wall
temp.x += 30 * cos(my.pan);
temp.y += 30 * sin(my.pan);
temp.z = my.z - 10;
trace_mode = ignore_me+ignore_sprites+ignore_models;
IF(trace(my.x,temp) == 0) {
movement_mode = 2;
}
ent_cycle("walk",my.animdist);
my.animdist += 9 * time;
}
IF(key_s == 1) && (key_w == 0) {
temp.x = 0;
temp.y = 0;
temp.z = -5 * time;
ent_move(temp.x,nullvector);
vec_set(temp,my.x);
temp.z -= 4000;
trace_mode = ignore_me+ignore_sprites+ignore_models+use_box;
result = trace(my.x,temp);
IF (result < 10) && (key_s == 1) { movement_mode = 0; }
ent_cycle("walk",my.animdist);
my.animdist += 9 * time;
}
IF (my.animdist > 100) { my.animdist -= 100; }
IF (ang(cter) < ang(player.pan)) {
IF (ang(player.pan) - ang(cter) <= 180) {
IF (ang(player.pan) - ang(cter) <= 5) {
cter += 0.25 * (ang(player.pan) - ang(cter));
} ELSE {
cter += cam_rotate_speed * 2 * time;
}
} ELSE {
cter -= cam_rotate_speed * 2 * time;
}
}
IF (ang(cter) > ang(player.pan)) {
IF (ang(cter) - ang(player.pan) <= 180) {
IF (ang(cter) - ang(player.pan) <= 5) {
cter += 0.25 * (ang(player.pan) - ang(cter));
} ELSE {
cter -= cam_rotate_speed * 2 * time;
}
} ELSE {
cter += cam_rotate_speed * 2 * time;
}
}
IF (cter > 359) { cter -= 360; }
IF (cter < 0) { cter += 360; }
// camera.z = player.z - sin(cam_zangle) * cam_height;
center_check();
update_views();
}

IF (movement_mode == 2) { //pulling yourself up onto a ledge
my.z += 5 * time;
player_diff.x = 1;
player_diff.y = 0;
player_diff.z = 0;
ent_move(player_diff.x,nullvector);
vec_set(temp,my.x); //scan in front of player to see if there is a climbable wall
temp.x += 30 * cos(my.pan);
temp.y += 30 * sin(my.pan);
temp.z = my.z - player_feet_height; //set the value 32 to the distance to the models feet
trace_mode = ignore_me+ignore_sprites+ignore_models;
IF(trace(my.x,temp) == 0) {
movement_mode = 3;
vec_set(ladder_x.x,my.x);
}
// camera.z = player.z - sin(cam_zangle) * cam_height;
ent_cycle("walk",my.animdist);
my.animdist += 9 * time;
IF (my.animdist > 100) { my.animdist -= 100; }
center_check();
update_views();
}

IF (movement_mode == 3) { //moving a little bit forward so that player doesn't fall down
player_diff.x = 3 * time;
player_diff.y = 0;
vec_set(temp,my.x);
temp.z -= 4000; // calculate a position 4000 quants below the player
// set a trace mode for using the player's hull, and detecting map entities and level surfaces only
trace_mode = ignore_me+ignore_sprites+ignore_models+use_box;
result = trace(my.x,temp);// subtract vertical distance to ground
player_diff.z = 0;
IF (result < 4) { player_diff.z = -0.2 * result; }

IF(vec_dist(my.x,ladder_x.x) > 7) {
vec_set(temp,my.x);
temp.z -= 4000; // calculate a position 4000 quants below the player
// set a trace mode for using the player's hull, and detecting map entities and level surfaces only
trace_mode = ignore_me+ignore_sprites+ignore_models+use_box;
result = trace(my.x,temp);// subtract vertical distance to ground
IF (result < 4) { player_diff.z = -1 * result; }
} ELSE {
player_diff.z = 0;
}
ent_move(player_diff, nullvector);

IF(vec_dist(my.x,ladder_x.x) > 15) {
movement_mode = 0;
player_diff.z = 0;
z_force = 0;
jumping_mode = 0;
my.skill13 = 0;
}
ent_cycle("walk",my.animdist);
my.animdist += 9 * time;
IF (my.animdist > 100) { my.animdist -= 100; }
center_check();
update_views();
}

IF (movement_mode == 10) {
IF (ang(cter) < ang(player.pan)) {
IF (ang(player.pan) - ang(cter) <= 180) {
IF (ang(player.pan) - ang(cter) <= 5) {
cter += 0.25 * (ang(player.pan) - ang(cter));
} ELSE {
cter += cam_rotate_speed * 1 * time;
}
} ELSE {
cter -= cam_rotate_speed * 1 * time;
}
}
IF (ang(cter) > ang(player.pan)) {
IF (ang(cter) - ang(player.pan) <= 180) {
IF (ang(cter) - ang(player.pan) <= 5) {
cter += 0.25 * (ang(player.pan) - ang(cter));
} ELSE {
cter -= cam_rotate_speed * 1 * time;
}
} ELSE {
cter += cam_rotate_speed * 1 * time;
}
}
IF (cter > 359) { cter -= 360; }
IF (cter < 0) { cter += 360; }


jumping_mode = 0;
player_diff.x = 0;
player_diff.z = 0;
z_force = 0;
IF (key_a != 0) && (key_d == 0) && (key_s == 0) && (key_w == 0) {
player_diff.y = 5 * time;
ent_cycle("walk",my.animdist);
my.animdist += 9 * time;
} ELSE {
player_diff.y = 0;
}
IF (key_d != 0) && (key_a == 0) && (key_s == 0) && (key_w == 0) {
player_diff.y = -5 * time;
ent_cycle("walk",my.animdist);
my.animdist += 9 * time;
} ELSE {
IF (key_a == 0) {
player_diff.y = 0;
}
}
IF (key_w == 1) && (key_s == 0) && (key_a == 0) && (key_d == 0) {
movement_mode = 11;
ledge_climb_z = my.z + player_head_height - 2; //this needs to be set to the height of the players head, ie my.z + # = players head
}
IF (key_s == 1) && (key_w == 0) && (key_a == 0) && (key_d == 0) {
movement_mode = 0;
jumping_mode = 0;
}
ent_move(player_diff, nullvector);
vec_set(temp,my.x); //scan in front of player to see if there is a climbable wall
temp.x += 30 * cos(my.pan);
temp.y += 30 * sin(my.pan);
temp.z = my.z + 40; //scan at head height
trace_mode = ignore_me+ignore_sprites+ignore_models;
result = trace(my.x,temp);
IF(result == 0) {
ledge_grab_test = 0;
movement_mode = 0;
jumping_mode = 0;
}

vec_set(temp,my.x); //scan a little above head height, we don't want a wall to be this high
temp.x += 30 * cos(my.pan);
temp.y += 30 * sin(my.pan);
temp.z += 45;
vec_set(temp2,my.x);
temp.z += 45;
trace_mode = ignore_me+ignore_sprites+ignore_models;
result = trace(temp2,temp);
IF(result > 0) {
ledge_grab_test = 0;
movement_mode = 0;
jumping_mode = 0;
}

center_check();
update_views();
IF (my.animdist > 100) { my.animdist -= 100; }
}


IF (movement_mode == 11) { //pulling yourself up onto a ledge
IF (my.z < ledge_climb_z) {
my.z += 5 * time;
} ELSE {
movement_mode = 12;
}
ent_cycle("walk",my.animdist);
my.animdist += 9 * time;
IF (my.animdist > 100) { my.animdist -= 100; }
center_check();
update_views();
}

IF (movement_mode == 12) { //pulling yourself up onto a ledge
my.z += 5 * time;
player_diff.x = 1;
player_diff.y = 0;
player_diff.z = 0;
ent_move(player_diff.x,nullvector);
vec_set(temp,my.x); //scan in front of player to see if there is a climbable wall
temp.x += 30 * cos(my.pan);
temp.y += 30 * sin(my.pan);
temp.z = my.z - player_feet_height; //set the value player_feet_height to the distance to the models feet
trace_mode = ignore_me+ignore_sprites+ignore_models;
IF(trace(my.x,temp) == 0) {
movement_mode = 3;
vec_set(ladder_x.x,my.x);
}
// camera.z = player.z - sin(cam_zangle) * cam_height;
ent_cycle("walk",my.animdist);
my.animdist += 9 * time;
IF (my.animdist > 100) { my.animdist -= 100; }
center_check();
update_views();
}



IF (movement_mode == 0) {
vec_set(temp,my.x); //scan in front of player to see if there is a climbable wall
temp.x += 30 * cos(my.pan);
temp.y += 30 * sin(my.pan);
temp.z = my.z;
trace_mode = ignore_me+ignore_sprites+ignore_models+scan_texture;
result = trace(my.x,temp);
// IF(str_cmpi(tex_name,"glas1") == 1) && (movement_mode == 0) { //change the texture here of the texture required to be tracing in order to climb wall
IF (tex_flag1 == on) && (movement_mode == 0) {
vec_to_angle(temp,normal.x);
IF (abs(ang(my.pan - (temp.pan - 180))) < 20) { movement_mode = 1; jumping_mode = 0; }
// my.pan = normal.pan - 180; //make player face towards ladder
}

vec_set(temp,my.x);
temp.z -= 4000; // calculate a position 4000 quants below the player
// set a trace mode for using the player's hull, and detecting map entities and level surfaces only
trace_mode = ignore_me+ignore_sprites+ignore_models+use_box;
result = trace(my.x,temp);// subtract vertical distance to ground
IF (key_space == 1) {
IF (jumping_mode == 0) { //if we are not already jumping
jumping_mode = 1;
z_force = jump_force;
my.animdist = 0;
IF (mouse_right == 1) || (key_x == 1) { store_strafe_mode = 1; } ELSE { store_strafe_mode = 0; }
}
}


IF (result <= 3) && (jumping_mode == 0) { // in the air?
IF (result < 1.3) && (result > -1.3) && (result > 0.5) && (result < -0.5) { my.skill13 = 0; } //change the value 1.5 to change how high steps he can climb, make it no higher than 3
vec_set(temp,my.x);
temp.z -= 4000; // calculate a position 4000 quants below the player
trace_mode = ignore_me+ignore_sprites+ignore_passable+ignore_models+use_box;
result = trace(my.x,temp);// subtract vertical distance to ground
z_force = -1 * result;
IF (mouse_right == 1) || (key_x == 1) { store_strafe_mode = 1; } ELSE { store_strafe_mode = 0; }
} ELSE {
IF (result <= 3) && (my.animdist > 20) {
IF (jumping_mode == 2) {
player_diff.x = 0;
player_diff.y = 0;
IF (my.animdist <= 40) { jumping_mode = 0; }
IF (my.animdist < 100) {
// ent_frame("jump",my.animdist);
// my.animdist += 7 * time;
} ELSE {
jumping_mode = 0;
}
}
IF (jumping_mode == 1) { my.skill13 = 0; jumping_mode = 0; }
IF (result < 1.3) && (result > -1.3) && (result > 0.5) && (result < -0.5) { my.skill13 = 0; } //change the value 1.5 to change how high steps he can climb, make it no higher than 3
vec_set(temp,my.x);
temp.z -= 4000; // calculate a position 4000 quants below the player
trace_mode = ignore_me+ignore_sprites+ignore_passable+ignore_models+use_box;
result = trace(my.x,temp);// subtract vertical distance to ground
z_force = -1 * result;
IF (mouse_right == 1) || (key_x == 1) { store_strafe_mode = 1; } ELSE { store_strafe_mode = 0; }
}
IF (jumping_mode == 1) {
IF (result > 30) { jumping_mode = 2; }
IF (my.animdist < 40) {
ent_frame("jump",my.animdist);
my.animdist += 5 * time;
} ELSE {
my.animdist = 40;
ent_frame("jump",my.animdist);
jumping_mode = 2;
}
IF (z_force > -20) { z_force -= 3 * time; } ELSE { z_force = -20; }
IF (jumping_mode == 0) {
IF (z_force > -20) { z_force -= 3 * time; } ELSE { z_force = -20; }
}
} ELSE {
IF (result < 30) {
IF (my.animdist < 80) {
ent_frame("jump",my.animdist);
my.animdist += 12 * time;
} ELSE {
ent_frame("jump",my.animdist);
my.animdist += 4 * time;
}
} ELSE {
IF (my.animdist < 40) {
ent_frame("jump",my.animdist);
my.animdist += 5 * time;
} ELSE {
my.animdist = 40;
ent_frame("jump",my.animdist);
jumping_mode = 2;
}
}
IF (z_force > -20) { z_force -= 3 * time; } ELSE { z_force = -20; }
}
}

IF (jumping_mode == 0) {
IF (key_x == 0) && (mouse_right == 0) {
rotate_player();
movement();
} ELSE {
strafe_movement();
}
move_mode = ignore_passable + glide;
player_diff.x /= 3;
player_diff.y /= 3;
IF (key_w == 1) && (key_d == 1) {
player_diff.x /= 1.5;
player_diff.y /= 1.5;
}
IF (key_w == 1) && (key_a == 1) {
player_diff.x /= 1.5;
player_diff.y /= 1.5;
}
IF (key_s == 1) && (key_d == 1) {
player_diff.x /= 1.5;
player_diff.y /= 1.5;
}
IF (key_s == 1) && (key_a == 1) {
player_diff.x /= 1.5;
player_diff.y /= 1.5;
}

IF (key_shift == 1) {
player_diff.x /= walk_speed;
player_diff.y /= walk_speed;
}

IF (key_w == 1) || (key_s == 1) || (key_d == 1) || (key_a == 1) {
IF (key_shift == 0) {
ent_cycle("run",my.animdist);
my.animdist += 10 * time;
} ELSE {
ent_cycle("walk",my.animdist);
my.animdist += 9 * time;
}
} ELSE {
ent_cycle("stand",my.animdist);
my.animdist += 3 * time;
}
IF (my.animdist > 100) { my.animdist -= 100; }
} ELSE {
IF (locked_on != 1) && (locked_on != 1.5) {
rotate_player();
}
} //so player rotates towards moving direction in air, if they are not locked on

my.SKILL13 = 0.5*z_force + max(1-0.5*0.7,0)*my.SKILL13; // calculate vertical speed, replace 0.3 with time to convert to the old equation
jump_z = TIME * my.SKILL13; // distance down
player_diff.z = jump_z;

IF (jumping_mode != 0) { //stops changing of movement modes while jumping
key_x = 0;
mouse_right = store_strafe_mode;
}

IF (key_x == 0) && (mouse_right == 0) {
ent_move(nullvector, player_diff);
} ELSE {
ent_move(player_diff, nullvector);
}
center_check();
update_views();

//the following code moves the camera directly behind the player when holding the x key

IF (jumping_mode != 0) && (locked_on == 1.5) { //allow player to rotate around target while jumping
vec_set(temp.x,locked_target.x);
vec_sub(temp.x,my.x);
vec_to_angle(rotate_to,temp.x); // now MY looks at locked_target
IF (ang(rotate_to - my.pan) < -2) {
my.pan -= 12 * time;
}
IF (ang(rotate_to - my.pan) > 2) {
my.pan += 12 * time;
}
IF (abs(ang(rotate_to - my.pan)) > 5) { locked_on = 1; }
cter = my.pan;
}
IF (jumping_mode != 0) && (locked_on == 1) { //allow player to rotate around target while jumping
vec_set(temp.x,locked_target.x);
vec_sub(temp.x,my.x);
vec_to_angle(my.pan,temp.x); // now MY looks at locked_target
my.tilt = 0;
my.roll = 0;
cter = my.pan;
IF (vec_dist(my.x,locked_target.x) > lockon_max) { locked_on = 0; my.skill24 = 0; } //release lock if distance is greater than 320 & jumping
}

IF (jumping_mode == 0) {
IF (vec_dist(my.x,locked_target.x) > lockon_max) && (locked_on > 0) && (locked_on < 2) { locked_on = 0; my.skill24 = 0; } //release lock if distance is greater than 320 & walking
IF (key_x == 1 || mouse_right == 1) && (are_we_strafing != 2) {
are_we_strafing = 1;
IF (locked_on == 0) {
temp.pan = 360;
temp.tilt = 50;
temp.z = lockon_min;
scan_entity (my.x, temp);
locked_on = 2;
IF (my.skill24 == 1) { //if we scanned a lock on target
locked_on = 1.5;
} ELSE {
locked_on = 2;
}
}
IF (locked_on == 1.5) { //program smooth turning here
vec_set(temp.x,locked_target.x);
vec_sub(temp.x,my.x);
vec_to_angle(rotate_to,temp.x); // now MY looks at locked_target
IF (ang(rotate_to - my.pan) < -2) {
my.pan -= 12 * time;
}
IF (ang(rotate_to - my.pan) > 2) {
my.pan += 12 * time;
}
IF (abs(ang(rotate_to - my.pan)) < 5) { locked_on = 1; }
// cter = my.pan;
IF (ang(cter) < ang(player.pan)) {
IF (ang(player.pan) - ang(cter) <= 180) {
IF (ang(player.pan) - ang(cter) <= 5) {
cter += 0.25 * (ang(player.pan) - ang(cter));
cter = player.pan;
} ELSE {
cter += cam_rotate_speed * 5 * time;
}
} ELSE {
cter -= cam_rotate_speed * 5 * time;
}
}
IF (ang(cter) > ang(player.pan)) {
IF (ang(cter) - ang(player.pan) <= 180) {
IF (ang(cter) - ang(player.pan) <= 5) {
cter += 0.25 * (ang(player.pan) - ang(cter));
cter = player.pan;
} ELSE {
cter -= cam_rotate_speed * 5 * time;
}
} ELSE {
cter += cam_rotate_speed * 5 * time;
}
}
IF (cter > 359) { cter -= 360; }
IF (cter < 0) { cter += 360; }
}

IF (locked_on == 1) { //program smooth turning here
vec_set(temp.x,locked_target.x);
vec_sub(temp.x,my.x);
vec_to_angle(my.pan,temp.x); // now MY looks at locked_target
my.tilt = 0;
my.roll = 0;
cter = my.pan;
}
IF (locked_on == 2) {
IF (mouse_force.x > 0) { my.pan -= 20 * mouse_force.x * time; cter = my.pan; }
IF (mouse_force.x < 0) { my.pan -= 20 * mouse_force.x * time; cter = my.pan; }
IF (ang(cter) < ang(player.pan)) {
IF (ang(player.pan) - ang(cter) <= 180) {
IF (ang(player.pan) - ang(cter) <= 5) {
cter += 0.25 * (ang(player.pan) - ang(cter));
} ELSE {
cter += cam_rotate_speed * 5 * time;
}
} ELSE {
cter -= cam_rotate_speed * 5 * time;
}
}
IF (ang(cter) > ang(player.pan)) {
IF (ang(cter) - ang(player.pan) <= 180) {
IF (ang(cter) - ang(player.pan) <= 5) {
cter += 0.25 * (ang(player.pan) - ang(cter));
} ELSE {
cter -= cam_rotate_speed * 5 * time;
}
} ELSE {
cter += cam_rotate_speed * 5 * time;
}
}
IF (cter > 359) { cter -= 360; }
IF (cter < 0) { cter += 360; }
}
}

IF (are_we_strafing == 1) && (mouse_right == 0) && (key_x == 0) { are_we_strafing = 2; locked_on = 0; my.skill24 = 0; } //2; }
IF (are_we_strafing == 2) {
IF (panoffset < 0) { panoffset += 3 * time; }
IF (panoffset > 0) { panoffset -= 3 * time; }
IF (zoffset < 6) { zoffset += 2 * time; }
IF (zoffset > 8) { zoffset -= 2 * time; }
IF (panoffset < 1 && panoffset > -1 && zoffset < 8 && zoffset > 6) { panoffset = 0; zoffset = 7; are_we_strafing = 0; }
}
}

//allows movement of camera with mouse when player is stationary
IF (mouse_force.x != 0) && (are_we_strafing == 0) {
IF (mouse_force.x > 0) && (panoffset < 23) { panoffset += abs(mouse_force.x * 10 * time); }
IF (mouse_force.x < 0) && (panoffset > -23) { panoffset -= abs(mouse_force.x * 10 * time); }
IF (panoffset > 23) { panoffset = 23; }
IF (panoffset < -23) { panoffset = -23; }
}
IF (mouse_force.y != 0) {
IF (mouse_force.y > 0) && (zoffset > -8) { zoffset -= mouse_force.y * 10 * time; }
IF (mouse_force.y < 0) && (zoffset < 17) { zoffset -= mouse_force.y * 10 * time; }
IF (zoffset < -8) { zoffset = -8; }
IF (zoffset > 17) { zoffset = 17; }
}
IF (mouse_left == 1) || (key_ctrl == 1) { //you can set various keys here to for various combos, then set different movement_modes for the different animations and actions
vec_set(temp,my.x);
temp.z -= 400;
trace_mode = ignore_me+ignore_sprites+ignore_passable+ignore_models+use_box;
result = trace(my.x,temp);
IF (result < 3) { //if we are on ground, not in the air
movement_mode = 100; //attacking
my.animdist = 100;
attack_state = 0;
}
}
}
IF (movement_mode == 100) {
basic_attack();
}
wait(1);
}
}

FUNCTION basic_attack() {
IF (my.animdist > 0) && (attack_state == 0) {
my.animdist -= 20 * time;
IF (my.animdist < 30) { //if we are far enough into attack animation
ent_vertex(temp,630); //sword tip
ent_vertex(temp2,601); //sword base
trace_mode = ignore_me + ignore_passable;
result = trace(temp2,temp);
IF (result != 0) {
IF (you != null) { //make sure we hit an entity and not a wall
beep;
//put affecting variables in here, ie take damage off enemy, change enemy skill number so that enemy plays taking damage animation
} ELSE { //if we hit a wall, rebound sword early
attack_state = 1;
}
}
}
IF (my.animdist <= 0) { my.animdist = 0; attack_state = 1; }
ent_frame("attack",my.animdist);
ground_player_elasticity();
}
IF (my.animdist < 100) && (attack_state == 1) {
my.animdist += 20 * time;
IF (my.animdist >= 100) { my.animdist = 100; attack_state = 0; movement_mode = 0; }
ent_frame("attack",my.animdist);
ground_player_elasticity();
}
}

FUNCTION ground_player_elasticity() {
vec_set(temp,my.x);
temp.z -= 4000; // calculate a position 4000 quants below the player
trace_mode = ignore_me+ignore_sprites+ignore_passable+ignore_models+use_box;
result = trace(my.x,temp);// subtract vertical distance to ground
z_force = -1 * result;
my.SKILL13 = 0.5*z_force + max(1-0.5*0.7,0)*my.SKILL13; // calculate vertical speed, replace 0.3 with time to convert to the old equation
jump_z = TIME * my.SKILL13; // distance down
player_diff.z = jump_z;
player_diff.x = 0;
player_diff.y = 0;

ent_move(player_diff, nullvector);
center_check();
update_views();
}

ACTION lock_on_object() {
my.skill25 = 1; //1 for lock on objects
my.shadow = on;
my.enable_scan = on;
my.skill26 = 0;
WHILE(1) {
IF (my.skill26 == 1) { //this allows the locked_target vector to change whilst the enemy is moving
vec_set(locked_target.x,my.x);
}
//put ai code here
wait(1);
}
}

FUNCTION scan_event {
IF (event_type == event_detect) {
you.skill26 = 0;
IF (you.skill25 == 1) {
IF (my.skill24 == 1) {
IF (vec_dist(my.x,you.x) <= vec_dist(my.x,locked_target.x)) { //if the next target is closer than previous
vec_set(locked_target.x,you.x);
you.skill26 = 1;
my.skill24 = 1;
}
}
IF (my.skill24 == 0) {
vec_set(locked_target.x,you.x);
you.skill26 = 1;
my.skill24 = 1;
}
}
}
}

This script is now proffesional because ithas fighting!!!

[edited, see code above]

Cool can't wait for the combat!!!

[removed for clarity]

Finally found some time to test this out. Nice work. Everyone's after a demo...here the script applied in my old new templates tester level:

http://www.geocities.com/hainesrs/tester2.zip

Cool demo thanks for posting it. I managed to get ladder climbing working. I have also better animated the guard model ie when he hits the floor from a jump he kneels and gets up.

For some reason with your demo though, the guard model looked more blurier and smoother than the one I'm using

I will post the code once I further progress things, combat and ledge grabbing etc.

Also, how do you put downloads onto your website ie what is the HTML code, i've never been able to figure out how to put a download link on a web page to download a file. Thanks.

Maybe I messed with his skin or something somewhere along the line. I also chopped off his feather, although I wouldn't think that would have much to do with it.

In the particular example above, I used SmartFTP to upload to my account. Then, I typed the URL in the post and that's all there was to it.

You might want to animate a walk to run, run to walk transition for your test model. You'd have to add some more code to use it, but that always looks better. Another animation state would be for turning. When Guard Link turns in place, that would look better than just panning him without movement. You could also have him crawl, duck, and roll like in Zelda. Another one would be an idle animation that triggered after being inactive for awhile.

One weak spot in this setup is that the camera will clip into the wall when it first hits it. This is pretty much the norm with all the scripts around here. Although with this kind of camera it is more rare to get right up on the wall, it's still a problem. Here's a link with info that explains one way to get eliminate it. I've never been able to implement it, but maybe you or someone else can someday:

http://www.gamasutra.com/gdc2004/features/20040325/giors_02.shtml

if you end up getting the combat and climbing scripts working; you will be the hero of gamestudio.

Yes I agree with you Josh666.

btw: Nice code for jumping.

I am a horrible animator/modeller and will not be animating the guard model for climbing, moving between stand, walk and run positions etc, but it is a good idea.

The camera collision idea looks good, but I am not planning to work on the camera further in this script.

I don't plan to do very much with combat, just the basics, as follows:

1. Allow the player to lock on to stationary objects (which you would
need to program as enemies and give them ai)
2. Have the only attack as the Guard's default attack animation, with
weapon and allow the weapon to interact with objects (ie it rebounds
off of walls). I'm not planning to put in combos and rolls and jumps
because I am a bad animator and I don't plan to go that far with this
script.

Thanks for ideas.

cool beans!

I took another look at that idea for improved camera movement and I understand it now. I implemented it and it's worked so far, i'm gonna continue working on it. So the camera will actually move to the position it needs to be in (to avoid walls) instead of just appearing there and clipping into walls.

Do you mean from the Gamasutra article? From my understanding of it, you'd have to code an "arc" of traces from the player to the camera. One trace would go right at the camera and the others on either side of it and starting at the initial trace and spreading out from there and stopping at about the 45 degree mark(give or take 5 or 10 degrees). Each of the traces has a "weight" associated with it and the farther away the trace is from the player, the less influence it will have on the camera's forward movement. The way Doug's new template 3rd person camera handles wall collision is somewhat similar(minus the weighting), but he still hasn't been able to completely eliminate the clipping. He's come the closest, though.

That's exactly what I did!! It doesn't eliminate clipping but reduces it and makes the camera look and work so much better. It really only clips if you turn too fast and move the camera into a wall, though if you change the speed at which the camera moves back and forth along the raduis line, you can make it fast enough so clipping stops but the camera looks dodgy because it moves too fast.

I used six traces, two at +-10 degrees, two at +-25 and two at +-50. I haven't used a central trace and it seems to work ok as long as you give the 10 degree trace 100% weight control. If you've done this type of camera before orange bat can you recommend how many traces I need, the degrees they are apart and the weight they should have (if you've done it before). Otherwise I'll try trial and error of various traces to see which layout works best. Thanks for the idea!! It makes this script rock!!

I've never successfully implemented it, but I understand the theory behind it. The elimination of the wall clipping is my Holy Grail and it looks like you may have finally licked it or are on the verge of it. You'll have to play with the weights until you get the right magic numbers. Also make sure that the clipping is eliminated when the camera is tilted up or down as well. The ultimate test would be successfully ridding the clipping with a more traditional 3rd person chase cam like a Max Payne or new template 3rd person style. Good luck.

I've tried with the magic numbers but can't get rid of clipping. It seems that when I play with the numbers I am faced with two options, have no clipping but have the camera move too fast and too close to the player when it approaches the wall. Have some clipping but have the camera move at a nice speed and stays at a nice distance from the player. It's keeping a balance. I've tried making the camera move out from a wall when it is next to it but it is hard to do with this sciprt and type of movement.

What do you mean by that I should try and eliminate clipping when the camera tilts? Do you mean that if the camera height changes during gameplay to stop the camera passing through a roof etc?

Here's the code I used to calculate the radius at which it needs to move to from the player, in case you ever plan to implement it

"cam_xyangle" is the camera's pan
"dist_total" is the maximum distance the camera can move from the player
"dist_traced" is a temporary variable used to calculate
"camera_move_to" is the radius at which the camera needs to move to from it's current distance from the player

The code will give you the variable "camera_move_to", which is the distance/radius the camera needs to be from the player in order to avoid collision.

[see first post above]

I'll try to crack this code today or over the next couple. I'm in the middle of learning Wintermute Engine and reorganizing my own game, so my time has been stolen from me at knife point.

Quote:

---

What do you mean by that I should try and eliminate clipping when the camera tilts? Do you mean that if the camera height changes during gameplay to stop the camera passing through a roof etc?

---

Well, whenever I was playing around with Doug's new template chase cam, it would work out pretty well, but then when I tilted the camera up or down(looking up/down...mouse_force.y != 0) the thing would always clip like crazy. It's esp. bad when you're looking up into the sky. If you hit the wall when the camera is around eye level it's pretty darn good, however that only occurs when the "smoothing" variable is set to default or right around there. You can still break it but it's good most of the time(which of course is unacceptable ). If you set the smoothing to 0(which I prefer) it'll kind of snap to the trace target(or perhaps this is the vec_normalize part) and then clip(but just barely and at eye level..also clips bad when looking up).

Here's my new template test level. If your "template_6" folder is in the default folder(C:\\Program Files\\GStudio6\\template_6), it shouldn't give you any trouble. I think the ones provided are the newest, but I'm not 100% sure.

http://www.geocities.com/hainesrs/tester.zip

Stand next to a wall and try different camera heights. You'll notice tilting up is worse than eye level or looking down.