void cheat_handle_vehicle_recording ( struct vehicle_info *info, float time_diff )
{
char buffer[512];
float set_speed[3];
float set_spin[3];
if ( info == NULL || !set.recording_activated )
return;
traceLastFunc( "cheat_handle_vehicle_recording()" );
// recording key
if ( KEY_PRESSED(set.key_recording_record) )
{
if ( rec_state == RECORDING_RECORD )
{
rec_maxNum = rec_index;
rec_state = RECORDING_OFF;
return;
}
else if ( rec_state == RECORDING_OFF )
{
rec_state = RECORDING_RECORD;
rec_maxNum = 0;
rec_index = 0;
rec_playNext = 0.0f;
}
}
if ( KEY_PRESSED(set.key_recording_continueAfterFinish) )
rec_continueAfterFin ^= 1;
// play keys
if ( (KEY_PRESSED(set.key_recording_play) || KEY_PRESSED(set.key_recording_customSpeed)
|| KEY_PRESSED(set.key_recording_rev) || KEY_PRESSED(set.key_recording_rev_customSpeed)) )
{
// if record playing
if ( rec_state >= RECORDING_PLAY )
{
rec_state = RECORDING_OFF;
return;
}
else if ( rec_state == RECORDING_OFF )
{
// something to play?
if ( rec_maxNum <= 0 )
{
rec_state = RECORDING_OFF;
return;
}
rec_index = 0;
rec_playNext = 0.0f;
if ( KEY_PRESSED(set.key_recording_play) )
rec_state = RECORDING_PLAY;
else if ( KEY_PRESSED(set.key_recording_customSpeed) )
rec_state = RECORDING_PLAY_CUSTOMSPEED;
else if ( KEY_PRESSED(set.key_recording_rev) )
{
rec_index = (rec_maxNum-1);
rec_state = RECORDING_PLAY_REV;
}
else if ( KEY_PRESSED(set.key_recording_rev_customSpeed) )
{
rec_index = (rec_maxNum-1);
rec_state = RECORDING_PLAY_REV_CUSTOMSPEED;
}
// user set a maximum distance to entry point?
if ( set.recording_maxDistToEntryPoint > 0.0f )
{
// check if current selected index is in maxRange, else look for a point closest
// to the selected beginning, which is in the maxRange
if ( vect3_dist(rec_pos[rec_index], &info->base.matrix[4*3]) > set.recording_maxDistToEntryPoint )
{
int i = rec_index;
int rec_index_new = -1;
// not a entry point we want (too far), lets find a better one
while ( i >= 0 && i < rec_maxNum )
{
if ( vect3_dist(rec_pos[i], &info->base.matrix[4*3]) <= set.recording_maxDistToEntryPoint )
{
rec_index_new = i;
break;
}
if ( rec_state == RECORDING_PLAY_REV || rec_state == RECORDING_PLAY_REV_CUSTOMSPEED )
i--;
else
i++;
}
// nothing close enough found
if ( rec_index_new == -1 )
{
rec_state = RECORDING_OFF;
cheat_state_text( "Too far from route - maxDist: %0.2f", set.recording_maxDistToEntryPoint );
}
else
rec_index = rec_index_new;
}
}
}
}
if ( rec_state == RECORDING_RECORD )
{
pD3DFont->PrintShadow( 99, 250, D3DCOLOR_ARGB(255, 255, 0, 0), "Vehicle Recording" );
if ( (TIME_TO_FLOAT(time_get()) - rec_playNext) < 0.0f )
return;
vect3_copy( &info->base.matrix[4*3+0], rec_pos[rec_index] );
vect3_copy( &info->base.matrix[4*0+0], &rec_angle[rec_index][0] );
vect3_copy( &info->base.matrix[4*1+0], &rec_angle[rec_index][3] );
vect3_copy( info->spin, rec_spin[rec_index] );
vect3_copy( info->speed, rec_speed[rec_index] );
rec_index++;
rec_playNext = TIME_TO_FLOAT(time_get()) + TIME_TO_FLOAT((float)MSEC_TO_TIME(REC_DEFAULT_WAITTIME));
if ( rec_index == (REC_ARRAYSIZE-1) )
{
rec_maxNum = rec_index;
rec_state = RECORDING_OFF;
}
}
// >= because only play states should follow after RECORDING_PLAY
else if ( rec_state >= RECORDING_PLAY )
{
// deactivate playing records while air brakeing/sticking
if ( cheat_state->vehicle.air_brake || cheat_state->vehicle.stick )
{
rec_state = RECORDING_OFF;
return;
}
// move into some better place (maybe hud?)
_snprintf_s( buffer, sizeof(buffer)-1, "Vehicle Play Record%s%s", (rec_state == RECORDING_PLAY_REV
|| rec_state == RECORDING_PLAY_REV_CUSTOMSPEED) ? " (Rev)" : "",
rec_continueAfterFin ? " (Continuously)" : "" );
_snprintf_s( buffer, sizeof(buffer)-1, "%s%s", buffer, (rec_state == RECORDING_PLAY_REV_CUSTOMSPEED
|| rec_state == RECORDING_PLAY_CUSTOMSPEED) ? " (Custom Speed)" : "" );
pD3DFont->PrintShadow( 99, 250, D3DCOLOR_ARGB(255, 0, 255, 0), buffer );
// will need overtime variable for data row skipping
float overtime = (TIME_TO_FLOAT(time_get()) - rec_playNext);
// do nothing, if the planned next-frame time wasn't reached yet
if ( overtime < 0.0f )
return;
vect3_copy( rec_pos[rec_index], &info->base.matrix[4*3+0] );
vect3_copy( &rec_angle[rec_index][0], &info->base.matrix[4*0+0] );
vect3_copy( &rec_angle[rec_index][3], &info->base.matrix[4*1+0] );
vect3_copy( rec_spin[rec_index], set_spin );
vect3_copy( rec_speed[rec_index], set_speed );
// multiply speed/spin (for ff mode) and set the playNextTick
if ( rec_state == RECORDING_PLAY_CUSTOMSPEED || rec_state == RECORDING_PLAY_REV_CUSTOMSPEED )
{
vect3_mult( set_spin, set.recording_play_customSpeed, set_spin );
vect3_mult( set_speed, set.recording_play_customSpeed, set_speed );
// custom speed multiplier faster/higher than possible to play one by one?
// if its not the first point (rec_playNext still default) skip a few
if ( overtime > 0.0f && rec_playNext != 0.0f )
{
// (now-plannedArrival) = overtime -> plannedArrival is way back in the past [so we gotta skip
// some of the rows to keep up with the recording/show it 'fluent' (or at least somehow timed correct)]
// determine how many data rows we gotta skip ((now-plannedArrival)/timePerRow)
float skipAble = overtime / (float)(TIME_TO_FLOAT((float)MSEC_TO_TIME(REC_DEFAULT_WAITTIME))/set.recording_play_customSpeed);
if ( skipAble > 1.0f )
{
int skipAFew = ceil(skipAble);
if ( skipAFew > 0 && rec_state >= RECORDING_PLAY_REV )
rec_index -= skipAFew;
else if ( skipAFew > 0 )
rec_index += skipAFew;
}
}
// calculate the time for the next data row
rec_playNext = TIME_TO_FLOAT(time_get())
+ (TIME_TO_FLOAT((float)MSEC_TO_TIME(REC_DEFAULT_WAITTIME))/set.recording_play_customSpeed );
}
else
{
// in case REC_DEFAULT_WAITTIME is too low, or this code is running on a slow computer
// (or player tabbed/paused the game and refocuses the gta window)
if ( overtime > 0.0f && rec_playNext != 0.0f )
{
// determine how many data rows we gotta skip
float skipAble = overtime / (float)(TIME_TO_FLOAT(MSEC_TO_TIME(REC_DEFAULT_WAITTIME)));
if ( skipAble > 1.0f )
{
int skipAFew = ceil(skipAble);
if ( skipAFew > 0 && rec_state >= RECORDING_PLAY_REV )
rec_index -= skipAFew;
else if ( skipAFew > 0 )
rec_index += skipAFew;
}
}
rec_playNext = TIME_TO_FLOAT(time_get()) + TIME_TO_FLOAT(MSEC_TO_TIME(REC_DEFAULT_WAITTIME));
}
// inverse speed/spin (for rev mode) and set rec_index
if ( rec_state >= RECORDING_PLAY_REV )
{
vect3_mult( set_spin, -1.0f, set_spin );
vect3_mult( set_speed, -1.0f, set_speed );
rec_index--;
// reached end of recording
if ( rec_index <= 0 )
{
if ( !rec_continueAfterFin )
rec_state = RECORDING_OFF;
else
{
if ( set.recording_maxDistToEntryPoint > 0.0f )
{
// deactivate, if new starting position is too far from this point
if ( vect3_dist(rec_pos[rec_index], rec_pos[(rec_maxNum-1)]) > set.recording_maxDistToEntryPoint )
rec_state = RECORDING_OFF;
}
rec_index = (rec_maxNum-1);
}
}
}
else
{
rec_index++;
// reached end of recording
if ( (rec_index >= (REC_ARRAYSIZE-1) || rec_index >= rec_maxNum) )
{
if ( !rec_continueAfterFin )
rec_state = RECORDING_OFF;
else
{
if ( set.recording_maxDistToEntryPoint > 0.0f )
{
// deactivate, if new starting position is too far from this point
if ( vect3_dist(rec_pos[rec_index], rec_pos[0]) > set.recording_maxDistToEntryPoint )
rec_state = RECORDING_OFF;
}
rec_index = 0;
}
}
}
// copy new speed/spin after it has been adjusted for ff/rev mode
vect3_copy( set_spin, info->spin );
vect3_copy( set_speed, info->speed );
}
else
{
rec_state = RECORDING_OFF;
}
}
void cheat_handle_freeze_vehicles ( struct vehicle_info *vehicle_info, struct actor_info *actor_info )
{
traceLastFunc( "cheat_handle_freeze_vehicles()" );
static struct freeze_info *freeze;
struct vehicle_info *info;
float *pos;
int i;
if ( KEY_PRESSED(set.key_vehicles_freeze) )
{
cheat_state->_generic.vehicles_freeze ^= 1;
if ( !cheat_state->_generic.vehicles_freeze && freeze != NULL )
memset( freeze, 0, pool_vehicle->size * sizeof(struct freeze_info) );
}
if ( vehicle_info != NULL )
pos = &vehicle_info->base.matrix[4 * 3];
else if ( actor_info != NULL )
pos = &actor_info->base.matrix[4 * 3];
else
return;
if ( freeze == NULL ) /* XXX free on exit */
{
freeze = (struct freeze_info *)malloc( pool_vehicle->size * sizeof(struct freeze_info) );
if ( freeze == NULL )
return;
memset( freeze, 0, pool_vehicle->size * sizeof(struct freeze_info) );
}
if ( cheat_state->_generic.vehicles_freeze )
{
for ( i = 0; i < pool_vehicle->size; i++ )
{
if ( (info = vehicle_info_get(i, VEHICLE_ALIVE)) == NULL || info == vehicle_info )
{
if ( info == vehicle_info && freeze[i].set )
cheat_vehicle_air_brake_set( 1 ); /* entered a frozen vehicle */
freeze[i].set = 0;
continue;
}
if ( freeze[i].set )
{
matrix_copy( freeze[i].matrix, info->base.matrix );
vect3_mult( info->speed, 0.0f, info->speed );
vect3_mult( info->spin, 0.0f, info->spin );
}
if ( vehicle_contains_trailer(vehicle_info, info) )
{
freeze[i].set = 0;
continue;
}
if ( vect3_dist(pos, &info->base.matrix[4 * 3]) >= 80.0f )
{
freeze[i].set = 0;
continue;
}
if ( freeze[i].set )
{
continue;
}
matrix_copy( info->base.matrix, freeze[i].matrix );
freeze[i].set = 1;
}
}
}
void cheat_handle_stick ( struct vehicle_info *vehicle_info, struct actor_info *actor_info, float time_diff )
{
traceLastFunc( "cheat_handle_stick()" );
struct object_base *base_stick, *base_self;
struct actor_info *actor_stick;
struct vehicle_info *vehicle_stick;
float *speed_stick, *speed_self;
float *spin_stick, *spin_self;
static int id = -1;
int i;
if ( KEY_PRESSED(set.key_stick) )
{
if ( vehicle_info != NULL )
cheat_state->vehicle.stick ^= 1;
else
cheat_state->actor.stick ^= 1;
id = actor_find( id - 1, 1, ACTOR_ALIVE | ACTOR_NOT_SAME_VEHICLE );
}
if ( KEY_PRESSED(set.key_stick_nearest) )
{
if ( vehicle_info != NULL )
cheat_state->vehicle.stick ^= 1;
else
cheat_state->actor.stick ^= 1;
id = actor_find_nearest( ACTOR_ALIVE | ACTOR_NOT_SAME_VEHICLE );
}
if ( (vehicle_info != NULL && cheat_state->vehicle.stick) || (actor_info != NULL && cheat_state->actor.stick) )
{
// remove any bad vehicle or actor stuffs
if ( isBadPtr_GTA_pVehicle(vehicle_info) )
vehicle_info = NULL;
if ( isBadPtr_GTA_pPed(actor_info) )
actor_info = NULL;
/* check if actor has disappeared.. and if it has, switch to teh nearest */
if ( id != -1 && actor_info_get(id, ACTOR_ALIVE) == NULL )
id = actor_find_nearest( ACTOR_ALIVE | ACTOR_NOT_SAME_VEHICLE );
if ( KEY_PRESSED(set.key_stick_prev) )
id = actor_find( id, -1, ACTOR_ALIVE | ACTOR_NOT_SAME_VEHICLE );
if ( KEY_PRESSED(set.key_stick_next) )
id = actor_find( id, 1, ACTOR_ALIVE | ACTOR_NOT_SAME_VEHICLE );
/* no actors to stick to */
if ( id == -1 )
{
cheat_state_text( "No players found; stick disabled." );
cheat_state->vehicle.stick = 0;
cheat_state->actor.stick = 0;
return;
}
/* get actor struct for the actor we're sticking to */
actor_stick = actor_info_get( id, ACTOR_ALIVE | ACTOR_NOT_SAME_VEHICLE );
if ( actor_stick == NULL )
return;
/* is this actor in a vehicle? */
vehicle_stick = actor_vehicle_get( actor_stick );
base_stick = vehicle_stick ? &vehicle_stick->base : &actor_stick->base;
base_self = vehicle_info ? &vehicle_info->base : &actor_info->base;
speed_stick = vehicle_stick ? vehicle_stick->speed : actor_stick->speed;
speed_self = vehicle_info ? vehicle_info->speed : actor_info->speed;
spin_stick = vehicle_stick ? vehicle_stick->spin : actor_stick->spin;
spin_self = vehicle_info ? vehicle_info->spin : actor_info->spin;
/* allow warping to work + always warp towards whatever we're sticking to...
but only when we're in a vehicle */
if ( KEY_PRESSED(set.key_warp_mod) && vehicle_info != NULL )
{
float out[4];
/* multiply the matrix of whatever we're sticking to with the user supplied vector */
matrix_vect4_mult( base_stick->matrix, set.stick_vect, out );
/* multiply the result with the negative warp-speed value, and put it in the speed vector
(negative because we want to warp towards teh target, not away from it */
vect3_mult( out, -set.warp_speed, speed_self );
}
if ( !KEY_DOWN(set.key_warp_mod) )
{
float d[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
float accel_mult = 1.0f;
float out[4];
/* handle stick movement keys */
if ( KEY_DOWN(set.key_stick_forward) )
d[1] += 1.0f;
if ( KEY_DOWN(set.key_stick_backward) )
d[1] -= 1.0f;
if ( KEY_DOWN(set.key_stick_left) )
d[0] -= 1.0f;
if ( KEY_DOWN(set.key_stick_right) )
d[0] += 1.0f;
if ( KEY_DOWN(set.key_stick_up) )
d[2] += 1.0f;
if ( KEY_DOWN(set.key_stick_down) )
d[2] -= 1.0f;
if ( KEY_DOWN(set.key_stick_in) )
d[3] -= 1.0f;
if ( KEY_DOWN(set.key_stick_out) )
d[3] += 1.0f;
if ( !near_zero(set.stick_accel_time) )
{
static uint32_t time_start;
if ( !vect4_near_zero(d) )
time_start = ( time_start == 0 ) ? time_get() : time_start;
else
time_start = 0; /* no keys pressed */
/* acceleration */
if ( time_start != 0 )
{
float t = TIME_TO_FLOAT( time_get() - time_start );
if ( t < set.stick_accel_time )
accel_mult *= t / set.stick_accel_time;
}
}
/* calculate new vector + dist */
if ( !vect3_near_zero(d) && !vect3_near_zero(set.stick_vect) )
{
for ( i = 0; i < 3; i++ )
{
d[i] = set.stick_vect[i] * set.stick_vect_dist + d[i] * time_diff * 8.0f * accel_mult;
}
set.stick_vect_dist = vect3_length( d );
vect3_normalize( d, set.stick_vect );
}
/* move towards/away from the center */
if ( !near_zero(d[3]) )
set.stick_vect_dist += d[3] * time_diff * 40.0f * accel_mult;
/* Teleport vehicle detachables */
if ( vehicle_info != NULL )
vehicle_detachables_teleport( vehicle_info, &base_self->matrix[4 * 3], &base_stick->matrix[4 * 3] );
matrix_copy( base_stick->matrix, base_self->matrix );
vect3_copy( speed_stick, speed_self );
vect3_copy( spin_stick, spin_self );
/*base_self->interior_id = base_stick->interior_id;
gta_interior_id_set(base_stick->interior_id);*/
/* multiply the matrix of the target with the user supplied vector */
matrix_vect4_mult( base_stick->matrix, set.stick_vect, out );
/* multiply the result with the user supplied vector distance */
vect3_mult( out, set.stick_vect_dist, out );
/* and add it to our position */
vect3_vect3_add( &base_self->matrix[4 * 3], out, &base_self->matrix[4 * 3] );
if ( vehicle_info != NULL )
{
/* Teleport detachables again :p */
vehicle_detachables_teleport( vehicle_info, &base_stick->matrix[4 * 3], &base_self->matrix[4 * 3] );
vehicle_prevent_below_height( vehicle_info, set.stick_min_height );
}
else if ( actor_info != NULL )
{
// new pedFlags
actor_info->pedFlags.bIsStanding = true;
actor_info->pedFlags.bWasStanding = true;
actor_info->pedFlags.bStayInSamePlace = true;
}
}
}
}
void cheat_handle_actor_fly ( struct actor_info *ainfo, double time_diff )
{
traceLastFunc( "cheat_handle_actor_fly()" );
// toggle
if ( KEY_PRESSED(set.key_fly_player) )
{
if ( !cheat_state->actor.fly_on )
{
cheat_state->actor.fly_on = 1;
}
else
{
cheat_state->actor.fly_on = 0;
}
}
if ( cheat_state->actor.fly_on )
{
// set fly status
cheat_state->actor.fly_enabled = true;
// get ground Z height
float groundZHeight = pGame->GetWorld()->FindGroundZFor3DPosition(pPedSelf->GetPosition());
float playerZHeight = pPedSelf->GetPosition()->fZ;
float playerFrontZOffset = abs(pPedSelfSA->Placeable.matrix->vFront.fZ);
float playerRightZOffset = abs(pPedSelfSA->Placeable.matrix->vRight.fZ);
// standing detection
if ( cheat_state->actor.fly_active
&& ainfo->pedFlags.bIsStanding
|| !KEY_DOWN(set.key_fly_player_strafeUp)
&& cheat_state->actor.fly_active
&& groundZHeight + 1.4f > playerZHeight
&& groundZHeight - 1.4f < playerZHeight)
{
cheat_state->actor.fly_active = false;
playerFly_lastKeySpeedState = speed_none;
// remove up speed hard limiter patch
if (patch_RemoveFlyUpSpeedLimit.installed)
{
patcher_remove(&patch_RemoveFlyUpSpeedLimit);
}
// remove fly soft limiters patch
if (patch_RemoveFlyWindSpeedLimit.installed)
{
patcher_remove(&patch_RemoveFlyWindSpeedLimit);
}
// set gravity down
pPedSelf->SetGravity( &-g_vecUpNormal );
// copy camera rotation to player
ainfo->fCurrentRotation = -pGame->GetCamera()->GetCameraRotation();
ainfo->fTargetRotation = ainfo->fCurrentRotation;
// play landing animation
playerFly_lastAnimationStates = SHP_Jump_Land;
GTAfunc_PerformAnimation("SHOP", "SHP_Jump_Land ", -1, 0, 1, 0, 0, 0, 0, 0);
// correct for angle after landing if needed
if (playerFrontZOffset > 0.4f
|| playerRightZOffset > 0.3f)
{
// get player matrix
CMatrix matPed;
pPedSelf->GetMatrix(&matPed);
// tilt player upright
CVector rotationAxis = g_vecUpNormal;
rotationAxis.CrossProduct( &matPed.vUp );
float theta = ( matPed.vUp.DotProduct( &g_vecUpNormal ) );
if ( !near_zero(theta) )
{
matPed = matPed.Rotate( &rotationAxis, cos(theta) );
// normalize everything
matPed.vFront.Normalize();
matPed.vRight.Normalize();
matPed.vUp.Normalize();
// zero near zero
matPed.vFront.ZeroNearZero();
matPed.vRight.ZeroNearZero();
matPed.vUp.ZeroNearZero();
// set player matrix
pPedSelf->SetMatrix(&matPed);
}
}
}
else if ( ainfo->pedFlags.bIsStanding
|| !KEY_DOWN(set.key_fly_player_strafeUp)
&& groundZHeight + 1.6f > playerZHeight
&& groundZHeight - 1.6f < playerZHeight )
{
// still standing
// update the last matrix
pPedSelf->GetMatrix(&playerFly_lastPedRotation);
}
else if ( time_diff < 1.0f ) // I believe I can fly...
{
// keys/buttons input
playerFly_keySpeedStates keySpeedState;
if ( KEY_DOWN(set.key_fly_player_accelerate) )
{
keySpeedState = speed_accelerate;
}
else if ( KEY_DOWN(set.key_fly_player_decelerate) )
{
keySpeedState = speed_decelerate;
}
else
{
keySpeedState = speed_none;
}
playerFly_keyStrafeStates keyStrafeState;
if ( KEY_DOWN(set.key_fly_player_strafeLeft) && !KEY_DOWN(set.key_fly_player_strafeRight) )
{
keyStrafeState = strafe_left;
playerFly_animationStrafeStateTimer = GetTickCount();
}
else if ( KEY_DOWN(set.key_fly_player_strafeRight) && !KEY_DOWN(set.key_fly_player_strafeLeft) )
{
keyStrafeState = strafe_right;
playerFly_animationStrafeStateTimer = GetTickCount();
}
else if ( KEY_DOWN(set.key_fly_player_strafeUp) )
{
keyStrafeState = strafe_up;
playerFly_animationStrafeStateTimer = GetTickCount();
}
else
{
keyStrafeState = strafe_none;
}
// activate fly mode
if ( !cheat_state->actor.fly_active )
{
cheat_state->actor.fly_active = true;
// install up speed hard limiter patch
if (!patch_RemoveFlyUpSpeedLimit.installed)
{
patcher_install(&patch_RemoveFlyUpSpeedLimit);
}
// install fly soft limiters patch
if (!patch_RemoveFlyWindSpeedLimit.installed)
{
patcher_install(&patch_RemoveFlyWindSpeedLimit);
}
if ( keySpeedState == speed_none )
{
// start fly animation
GTAfunc_PerformAnimation("SWIM", "Swim_Tread", -1, 1, 1, 0, 0, 0, 1, 0);
playerFly_lastAnimationStates = anim_Swim_Tread;
}
}
// init variables
// setup variables used through this function
CVector vecSpeed, rotationAxis;
float theta, thetaBase, rotationMultiplier;
pPedSelf->GetMoveSpeed(&vecSpeed);
float speed = vecSpeed.Length();
// copy camera rotation to player
// this doesn't seem to be needed anymore
//ainfo->fCurrentRotation = -pGame->GetCamera()->GetCameraRotation();
// get camera matrix
CMatrix matCamera;
pGame->GetCamera()->GetMatrix(&matCamera);
matCamera.vRight = -matCamera.vRight; // for some reason this is inverted
// normalize camera
matCamera.vFront.Normalize();
matCamera.vRight.Normalize();
matCamera.vUp.Normalize();
// change animation
if ( playerFly_lastKeyStrafeStates != keyStrafeState
|| playerFly_lastKeySpeedState != keySpeedState )
{
playerFly_lastKeyStrafeStates = keyStrafeState;
playerFly_lastKeySpeedState = keySpeedState;
playerFly_animationDeceleration = false;
switch ( keySpeedState )
{
case speed_none:
{
if (playerFly_lastAnimationStates != anim_Swim_Breast)
{
playerFly_lastAnimationStates = anim_Swim_Breast;
GTAfunc_PerformAnimation("SWIM", "Swim_Breast", -1, 1, 1, 0, 0, 0, 1, 0);
}
break;
}
case speed_accelerate:
{
if (playerFly_lastAnimationStates != anim_FALL_skyDive_accel)
{
playerFly_lastAnimationStates = anim_FALL_skyDive_accel;
GTAfunc_PerformAnimation("PARACHUTE", "FALL_skyDive_accel", -1, 1, 1, 0, 0, 0, 1, 0);
}
break;
}
case speed_decelerate:
{
switch ( keyStrafeState )
{
case strafe_none:
case strafe_up:
case strafe_left:
case strafe_right:
{
if ( speed > 0.45f )
{
if (playerFly_lastAnimationStates != anim_FALL_skyDive)
{
playerFly_lastAnimationStates = anim_FALL_skyDive;
GTAfunc_PerformAnimation("PARACHUTE", "FALL_skyDive", -1, 1, 1, 0, 0, 0, 1, 0);
}
playerFly_animationDeceleration = true;
}
else if (playerFly_lastAnimationStates != anim_Swim_Tread)
{
playerFly_lastAnimationStates = anim_Swim_Tread;
GTAfunc_PerformAnimation("SWIM", "Swim_Tread", -1, 1, 1, 0, 0, 0, 1, 0);
}
}
break;
default:
{
if (playerFly_lastAnimationStates != anim_Swim_Tread)
{
playerFly_lastAnimationStates = anim_Swim_Tread;
GTAfunc_PerformAnimation("SWIM", "Swim_Tread", -1, 1, 1, 0, 0, 0, 1, 0);
}
break;
}
}
break;
}
}
playerFly_animationKeyStateSpeedDownChanged = false;
}
else if (!playerFly_animationKeyStateSpeedDownChanged)
{
switch ( keySpeedState )
{
case speed_decelerate:
{
if ( speed < 0.45f )
{
if (playerFly_lastAnimationStates != anim_Swim_Tread)
{
playerFly_lastAnimationStates = anim_Swim_Tread;
GTAfunc_PerformAnimation("SWIM", "Swim_Tread", -1, 1, 1, 0, 0, 0, 1, 0);
}
playerFly_animationDeceleration = false;
playerFly_animationKeyStateSpeedDownChanged = true;
}
break;
}
default:
break;
}
}
// acceleration/deceleration
// acceleration
float fly_speed_max;
float fly_acceleration;
float fly_speed = set.fly_player_speed;
float fly_acceleration_multiplier = set.fly_player_accel_multiplier;
float fly_deceleration_multiplier = set.fly_player_decel_multiplier;
switch ( keySpeedState )
{
case speed_accelerate:
{
if (fly_speed >= 1.0f)
{
fly_speed_max = 1.333f * (1.0f + (0.5f / fly_speed)) * fly_speed;
fly_acceleration = time_diff * ((0.5f + (0.25f / (fly_speed / 4.0f))) * fly_speed) * fly_acceleration_multiplier;
}
else
{
fly_speed_max = 1.333f * (1.0f + (0.5f * fly_speed)) * fly_speed;
fly_acceleration = time_diff * ((0.5f + fly_speed) * fly_speed) * fly_acceleration_multiplier;
}
if ( vecSpeed.Length() < fly_speed_max )
{
vecSpeed += matCamera.vFront * fly_acceleration;
}
// don't have NearZero speeds
if ( !vecSpeed.IsNearZero() )
{
// set speed vector
ainfo->m_SpeedVec = vecSpeed;
}
}
break;
case speed_none:
{
if (fly_speed >= 1.0f)
{
fly_speed_max = 0.1f;
fly_acceleration = time_diff * 0.3f;
}
else
{
fly_speed_max = 0.1f * fly_speed;
fly_acceleration = time_diff * (0.3f * fly_speed);
}
if ( vecSpeed.Length() < fly_speed_max )
{
vecSpeed += matCamera.vFront * fly_acceleration;
}
// calculate wind resistance
float windResistance;
float windSpeedDivisor = 1.5f;
if (fly_speed >= windSpeedDivisor)
{
windResistance = time_diff * ( ( (fly_speed * 0.023f) + (speed * (fly_speed / (fly_speed / windSpeedDivisor)) * 0.38f) ) / (fly_speed / windSpeedDivisor) );
}
else if (fly_speed >= 1.0f)
{
windResistance = time_diff * ( ( (fly_speed * 0.023f) + (speed * (fly_speed / (fly_speed / windSpeedDivisor)) * 0.38f) ) * (fly_speed / windSpeedDivisor) );
}
else
{
windResistance = time_diff * ( ( (fly_speed * 0.023f) + (speed * 0.38f) ) * fly_speed );
}
vecSpeed -= vecSpeed * windResistance;
// don't have NearZero speeds
if ( !vecSpeed.IsNearZero() )
{
// set speed vector
ainfo->m_SpeedVec = vecSpeed;
}
}
break;
case speed_decelerate:
{
// this bit should be converted to mta-style code
vect3_normalize( ainfo->speed, ainfo->speed );
speed -= time_diff * ((0.1f + speed) * (0.45f / (fly_speed / 2.0f)) * fly_speed) * fly_deceleration_multiplier;
if ( speed < 0.0f )
speed = 0.0f;
if ( vect3_near_zero(ainfo->speed) )
{
vect3_zero( ainfo->speed );
}
else
{
vect3_mult( ainfo->speed, speed, ainfo->speed );
}
}
break;
}
// set speed target
// calculate the desired speed target
CVector vecSpeedRotate = matCamera.vFront;
switch ( keyStrafeState )
{
case strafe_up:
{
vecSpeedRotate = matCamera.vUp;
}
break;
case strafe_left:
{
CMatrix matTargetRotate;
// rotate sideways
matTargetRotate.vFront = vecSpeedRotate;
rotationAxis = matCamera.vUp;
theta = -1.57;
matTargetRotate = matTargetRotate.Rotate( &rotationAxis, theta );
// rotate upward
rotationAxis = matCamera.vFront;
if (KEY_DOWN(set.key_fly_player_strafeUp))
{
theta = -0.785;
}
else
{
theta = -0.05;
}
matTargetRotate = matTargetRotate.Rotate( &rotationAxis, theta );
// set the rotation target
vecSpeedRotate = matTargetRotate.vFront;
vecSpeedRotate.Normalize();
}
break;
case strafe_right:
{
CMatrix matTargetRotate;
// rotate sideways
matTargetRotate.vFront = vecSpeedRotate;
rotationAxis = matCamera.vUp;
theta = 1.57;
matTargetRotate = matTargetRotate.Rotate( &rotationAxis, theta );
// rotate upward
rotationAxis = matCamera.vFront;
if (KEY_DOWN(set.key_fly_player_strafeUp))
{
theta = 0.785;
}
else
{
theta = 0.05;
}
matTargetRotate = matTargetRotate.Rotate( &rotationAxis, theta );
// set the rotation target
vecSpeedRotate = matTargetRotate.vFront;
vecSpeedRotate.Normalize();
}
break;
case strafe_none:
break;
}
// rotate the speed
CVector frontCamOffsetTarget;
// rotate the speed vector slowly to face the desired target
CMatrix matSpeedVecRotate;
matSpeedVecRotate.vFront = vecSpeed;
matSpeedVecRotate.vFront.Normalize();
// calculate rotation multiplier, time_diff * 69.0 is ideal for calculations, always time for 69
rotationMultiplier = (time_diff * 69.0f) / ( 32.0f + (vecSpeed.Length() * 5.0f) );
// calculate rotation
rotationAxis = vecSpeedRotate;// + gravCamPed_vecCameraPanOffset;
rotationAxis.Normalize();
// magic
rotationAxis.CrossProduct( &matSpeedVecRotate.vFront );
// control
thetaBase = abs(sinh(vecSpeedRotate.DotProduct(&matSpeedVecRotate.vFront)) - 1.175f) / 2.35f + 1.0f;
theta = thetaBase * rotationMultiplier;
if ( !near_zero(theta) )
{
// rotate
matSpeedVecRotate = matSpeedVecRotate.Rotate( &rotationAxis, theta );
// calculate new speed
float speedReduction = time_diff * (vecSpeed.Length() * (thetaBase - 1.0f));
// set new speed vector
matSpeedVecRotate.vFront.Normalize();
ainfo->m_SpeedVec = matSpeedVecRotate.vFront * ( ainfo->m_SpeedVec.Length() - speedReduction );
}
// change animation when we're turning hard & not accelerating
if (speed > 0.45f
&& keySpeedState == speed_none
&& !playerFly_animationDeceleration
&& ( keyStrafeState == strafe_none || keyStrafeState == strafe_up )
)
{
if ( (GetTickCount() - 500) > playerFly_animationStrafeStateTimer )
{
if (playerFly_lastAnimationStates != anim_FALL_skyDive)
{
playerFly_lastAnimationStates = anim_FALL_skyDive;
GTAfunc_PerformAnimation("PARACHUTE", "FALL_skyDive", -1, 1, 1, 0, 0, 0, 1, 0);
}
playerFly_animationDeceleration = true;
playerFly_animationDirectionSpeedDownChanged = false;
}
else if ( keyStrafeState == strafe_up )
{
if (playerFly_lastAnimationStates != anim_FALL_skyDive)
{
playerFly_lastAnimationStates = anim_FALL_skyDive;
GTAfunc_PerformAnimation("PARACHUTE", "FALL_skyDive", -1, 1, 1, 0, 0, 0, 1, 0);
}
playerFly_animationDeceleration = true;
playerFly_animationDirectionSpeedDownChanged = false;
}
}
else if ( !playerFly_animationDirectionSpeedDownChanged
&& ( speed < 0.45f )
)
{
if ( keySpeedState == speed_none )
{
if (playerFly_lastAnimationStates != anim_Swim_Tread)
{
playerFly_lastAnimationStates = anim_Swim_Tread;
GTAfunc_PerformAnimation("SWIM", "Swim_Tread", -1, 1, 1, 0, 0, 0, 1, 0);
}
playerFly_animationDeceleration = false;
}
playerFly_animationDirectionSpeedDownChanged = true;
}
// set the ped rotation target
// copy speed and normalize, for initial direction
CVector vecPedRotate = matSpeedVecRotate.vFront; // should use the rotated speed, not original speed
vecPedRotate.Normalize();
CMatrix matPedTarget;
matPedTarget.vFront = matCamera.vFront;
matPedTarget.vRight = matCamera.vRight + (playerFly_lastPedRotation.vRight * 0.2f);
matPedTarget.vRight.Normalize();
matPedTarget.vUp = matCamera.vUp;
// rotate the ped rotation target to direction of speed
if (!near_zero(vecSpeed.Length()))
{
// rotate target
rotationAxis = g_vecUpNormal;
rotationAxis.CrossProduct( &vecPedRotate );
thetaBase = vecSpeedRotate.DotProduct(&vecPedRotate);
// drifting
rotationMultiplier = (time_diff * 69.0f) / ( 18.0f + (vecSpeed.Length() * 1.75f) );
theta = cos(thetaBase * rotationMultiplier);
if ( !near_zero(theta) )
{
matPedTarget = matPedTarget.Rotate( &rotationAxis, theta );
}
// recopy original front
matPedTarget.vFront = vecPedRotate;
// rotate the ped rotation target upward during deceleration
// animation so that the animation is at the correct angle
if (playerFly_animationDeceleration)
{
CVector upStrafeAxis = vecPedRotate;
upStrafeAxis.CrossProduct(&matPedTarget.vUp);
rotationMultiplier = (time_diff * 69.0f) / ( 1.0f + (vecSpeed.Length() * 0.25f) );
thetaBase = -1.5;// * rotationMultiplier; // 1.57 = 90 degrees
theta = cos(thetaBase * rotationMultiplier);
// rotate the ped rotation target to direction of speed
if (!near_zero(vecSpeed.Length()))
{
matPedTarget = matPedTarget.Rotate( &upStrafeAxis, theta );
}
//upStrafeAxis = upStrafeAxisBuffer;
}
}
// invert right z during strafing
if ( keyStrafeState == strafe_left
|| keyStrafeState == strafe_right )
{
matPedTarget.vRight.fZ = -matPedTarget.vRight.fZ / 2.0f;
}
// normalize everything
matPedTarget.Normalize(false); // sure, why not
// rotate the ped
// actual rotation of the ped to smooth movements
rotationMultiplier = (time_diff * 69.0f) / ( 12.0f + (vecSpeed.Length() * 1.5f) );
// front camera offset
rotationAxis = playerFly_lastPedRotation.vFront;
frontCamOffsetTarget = playerFly_lastPedRotation.vFront;
frontCamOffsetTarget.Normalize();
rotationAxis.CrossProduct( &frontCamOffsetTarget );
thetaBase = playerFly_lastPedRotation.vFront.DotProduct(&frontCamOffsetTarget);
theta = -cos(thetaBase) * ((time_diff * 69.0f) / 4.5f);
if ( !near_zero(theta) )
{
playerFly_lastPedRotation = playerFly_lastPedRotation.Rotate( &rotationAxis, theta );
matPedTarget = matPedTarget.Rotate( &rotationAxis, -theta );
}
// front
rotationAxis = playerFly_lastPedRotation.vFront;
rotationAxis.CrossProduct( &matPedTarget.vFront );
thetaBase = playerFly_lastPedRotation.vFront.DotProduct(&matPedTarget.vFront);
theta = -cos(thetaBase) * rotationMultiplier;
if ( !near_zero(theta) )
{
playerFly_lastPedRotation = playerFly_lastPedRotation.Rotate( &rotationAxis, theta );
matPedTarget = matPedTarget.Rotate( &rotationAxis, theta );
}
// right
rotationAxis = playerFly_lastPedRotation.vRight;
rotationAxis.CrossProduct( &matPedTarget.vRight );
thetaBase = playerFly_lastPedRotation.vRight.DotProduct(&matPedTarget.vRight);
theta = -cos(thetaBase) * (rotationMultiplier * 0.825f);
if ( !near_zero(theta) )
{
playerFly_lastPedRotation = playerFly_lastPedRotation.Rotate( &rotationAxis, theta );
matPedTarget = matPedTarget.Rotate( &rotationAxis, theta );
}
// up
rotationAxis = playerFly_lastPedRotation.vUp + (g_vecUpNormal / 1.4f);
rotationAxis.Normalize();
rotationAxis.CrossProduct( &matPedTarget.vUp );
thetaBase = playerFly_lastPedRotation.vUp.DotProduct(&matPedTarget.vUp);
theta = -cos(thetaBase) * (rotationMultiplier / 8.0f);
if ( !near_zero(theta) )
{
playerFly_lastPedRotation = playerFly_lastPedRotation.Rotate( &rotationAxis, theta );
//matPedTarget = matPedTarget.Rotate( &rotationAxis, theta );
}
// normalize everything
playerFly_lastPedRotation.vFront.Normalize();
playerFly_lastPedRotation.vRight.Normalize();
playerFly_lastPedRotation.vUp.Normalize();
// zero near zero
playerFly_lastPedRotation.vFront.ZeroNearZero();
playerFly_lastPedRotation.vRight.ZeroNearZero();
playerFly_lastPedRotation.vUp.ZeroNearZero();
// set the position
playerFly_lastPedRotation.vPos = pPedSelfSA->Placeable.matrix->vPos;
// set player matrix
pPedSelf->SetMatrix(&playerFly_lastPedRotation);
// set the camera (our CPed gravity gets ignored while flying)
// we should be setting it like this
//CVector smoothedGrav = -playerFly_lastPedRotation.vUp + (g_vecUpNormal * 2.0f);
//smoothedGrav.Normalize();
//pPedSelf->SetGravity( &smoothedGrav );
// -nf
// but the function is hacked to hell to make it work, so since we're the only
// thing using it so far, we'll just do this, and fudge the camera in the hook
// -nf
pPedSelf->SetGravity( &-playerFly_lastPedRotation.vUp );
// actually... the camera is doing quite a lot now which is flying specific, with some
// logic to run when actually flying, so... just doing literal set gravity is appropriate for now.
// -nf
}
}
else if ( cheat_state->actor.fly_enabled )
{
// set fly disabled
cheat_state->actor.fly_enabled = false;
if (cheat_state->actor.fly_active)
{
cheat_state->actor.fly_active = false;
// set gravity down
pPedSelf->SetGravity( &-g_vecUpNormal );
// remove up speed hard limiter patch
if (patch_RemoveFlyUpSpeedLimit.installed)
{
patcher_remove(&patch_RemoveFlyUpSpeedLimit);
}
// remove fly soft limiters patch
if (patch_RemoveFlyWindSpeedLimit.installed)
{
patcher_remove(&patch_RemoveFlyWindSpeedLimit);
}
// copy camera rotation to player
ainfo->fCurrentRotation = -pGame->GetCamera()->GetCameraRotation();
ainfo->fTargetRotation = ainfo->fCurrentRotation;
// stop animation
playerFly_lastAnimationStates = SHP_Jump_Land;
GTAfunc_PerformAnimation("SHOP", "SHP_Jump_Land ", -1, 0, 1, 0, 0, 0, 0, 0);
}
playerFly_lastKeySpeedState = speed_none;
}
}
