linear_expression& linear_expression::operator-= (const term& x)
{
auto i (terms_.find(x.first));
if (i == terms_.end() && !near_zero(x.second))
{
terms_[x.first] = -x.second;
}
else if (near_zero(i->second -= x.second))
{
terms_.erase(i);
}
return *this;
}
int xsensDataProcessor(XsensData * pData, void * param) {
if(near_zero(pData->euler_roll) && near_zero(pData->euler_pitch) && near_zero(pData->euler_yaw)) return !done;
debug("[xsensDataProcessor]>> param : %p\n", param);
XsensProcessorData * data = (XsensProcessorData *)param;
debug("quaternion : [%f %f %f %f]\n", pData->quaternion_w, pData->quaternion_x, pData->quaternion_y, pData->quaternion_z);
debug("euler : [%f %f %f]\n", pData->euler_roll, pData->euler_pitch, pData->euler_yaw);
debug("date : %04d-%02d-%02d %02d:%02d:%02d\n", pData->year, pData->month, pData->day, pData->hour, pData->minute, pData->second);
if(pData->year > 0) {
debug("## year > 0 :: is_emmit : %s, second : %d, last_second : %d \n", is_emmit ? "true" : "false", pData->second, last_second);
if(!is_emmit && pData->second != last_second) {//need to emmit;
debug("## NEED TO EMMIT\n");
memset(grmc_buff, '\0', sizeof(char) * 1024);
format_gprmc(grmc_buff, 1024, pData->year, pData->month, pData->day, pData->hour, pData->minute, pData->second);
strncat(grmc_buff, "\n", 1);
is_emmit = 1;
}
last_second = pData->second;
}
debug("## pData : %p\n", pData, sizeof(XsensData));
if(data->fp && pData) {
fwrite((char *)pData, sizeof(XsensData), 1, data->fp);
fflush(data->fp);
}
debug("[xsensDataProcessor]<<\n");
return !done;
}
void
linear_expression::change_subject(const variable& old_subj,
const variable& new_subj)
{
assert(!new_subj.is_nil());
assert(!near_zero(coefficient(new_subj)));
if (old_subj.is(new_subj))
return;
terms_[old_subj] = new_subject(new_subj);
}
linear_expression&
linear_expression::add(const variable& v, double c, const variable& subject,
tableau& solver)
{
auto i (terms_.find(v));
if (i == terms_.end())
{
if(!near_zero(c))
{
terms_[v] = c;
solver.note_added_variable(v, subject);
}
}
else if (near_zero(i->second += c))
{
terms_.erase(i);
solver.note_removed_variable(v, subject);
}
return *this;
}
void
linear_expression::substitute_out(const variable& var,
const linear_expression& expr,
const variable& subj, tableau& solver)
{
auto it (terms_.find(var));
assert(it != terms_.end());
double multiplier (it->second);
terms_.erase(it);
increment_constant(multiplier * expr.constant());
for (auto& p : expr.terms())
{
const variable& v (p.first);
double c (multiplier * p.second);
auto oc (terms_.find(v));
if (oc != terms_.end())
{
double new_coeff (oc->second + c);
if (near_zero(new_coeff))
{
solver.note_removed_variable(oc->first, subj);
terms_.erase(oc);
}
else
{
oc->second = new_coeff;
}
}
else
{
terms_[v] = c;
solver.note_added_variable(v, subj);
}
}
}
int vect2_near_zero ( const float in[2] )
{
//if ( !isfinite(in[0]) || !isfinite(in[1]) )
// return 1;
return near_zero( in[0] ) && near_zero( in[1] );
}
bool nearly_equal(double val, double val2) {
return near_zero(val - val2);
}
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_quickwarp(struct vehicle_info *vehicle_info, struct actor_info *actor_info)
{
if (KEYCOMBO_PRESSED(set.key_quickwarp))
{
CCam *pCam = pGame->GetCamera()->GetCam(pGame->GetCamera()->GetActiveCam());
CVector camsrc(*pCam->GetSource()), src, target, tppos;
CColPoint *pCollision = nullptr;
CEntitySAInterface *pEntity = nullptr;
if (pCam->GetMode() == MODE_AIMWEAPON || pCam->GetMode() == MODE_AIMWEAPON_ATTACHED || pCam->GetMode() == MODE_AIMWEAPON_FROMCAR)
{
// calculate target position by aim vector
pGame->GetCamera()->Find3rdPersonCamTargetVector(700.0f, &camsrc, &src, &target);
}
else
{
// else by camera vector
target = camsrc + *pCam->GetFront() * 700.0f;
}
// ignore self vehicle
if (vehicle_info != nullptr)
{
*(::vehicle_info **)VAR_IgnoredEntity = vehicle_info;
}
if (GTAfunc_ProcessLineOfSight(&camsrc, &target, &pCollision, &pEntity, true, true, false, true, true, false, false, false))
{
tppos = *pCollision->GetPosition();
tppos -= (*pCollision->GetNormal()) * 0.5f;
if (pCollision->GetNormal()->fZ >= 0.5f || pPedSelf->GetAreaCode() != 0)
{
tppos.fZ += 1.0f;
tppos.fZ = pGameInterface->GetWorld()->FindGroundZFor3DPosition(&tppos);
}
else
{
tppos.fZ = pGameInterface->GetWorld()->FindGroundZForPosition(tppos.fX, tppos.fY);
}
if (vehicle_info != nullptr)
{
// check for collision
CVehicle *vehSelf = pPedSelf->GetVehicle();
if (vehSelf)
{
pCollision->Destroy();
// check for collision
CVector vecVehicleGravity;
vehSelf->GetGravity(&vecVehicleGravity);
CVector vecVehicleAbove = (-vecVehicleGravity * 5.0f) + tppos;
CVector vecVehicleBelow = (vecVehicleGravity * 5.0f) + tppos;
bool bCollision = GTAfunc_ProcessLineOfSight(&vecVehicleAbove, &vecVehicleBelow, &pCollision, &pEntity,
true, false, false, true, true, false, false, false); // not checking for vehicle collisions
if (bCollision && pCollision)
{
// set vehicle to same Up position has surface normal
CMatrix matVehicleSelf;
vehSelf->GetMatrix(&matVehicleSelf);
CVector vecCollisionNormal = *pCollision->GetNormal();
// get "down" from vehicle model
CVector rotationAxis = matVehicleSelf.vUp;
// normalize our vectors
vecCollisionNormal.Normalize();
rotationAxis.Normalize();
// axis and rotation for gravity
float theta = acos(rotationAxis.DotProduct(&vecCollisionNormal));
if (!near_zero(theta))
{
rotationAxis.CrossProduct(&vecCollisionNormal);
rotationAxis.Normalize();
rotationAxis.ZeroNearZero();
matVehicleSelf = matVehicleSelf.Rotate(&rotationAxis, -theta);
}
// set the new matrix
vehSelf->SetMatrix(&matVehicleSelf);
// set pos floats for actual teleporting
tppos.fX = pCollision->GetPosition()->fX;
tppos.fY = pCollision->GetPosition()->fY;
tppos.fZ = pCollision->GetPosition()->fZ + 1.0f; // should be enough to stay above the ground properly
}
else
{
tppos.fZ += 0.5f;
}
cheat_vehicle_teleport(vehicle_info, &tppos.fX, gta_interior_id_get(), true);
}
}
else if (actor_info != nullptr)
{
tppos.fZ += 1.0f;
cheat_actor_teleport(actor_info, &tppos.fX, gta_interior_id_get());
}
GTAfunc_TogglePlayerControllable(0);
GTAfunc_LockActor(0);
}
if (pCollision != nullptr)
{
pCollision->Destroy();
}
}
}
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;
}
}
void cheat_handle_actor_air_brake ( struct actor_info *info, double time_diff )
{
traceLastFunc( "cheat_handle_actor_air_brake()" );
static float orig_pos[3];
static float fall_speed_mult;
static int was_enabled;
if ( set.air_brake_toggle )
{
if ( KEY_PRESSED(set.key_air_brake_foot_mod) )
{
if(cheat_state->actor.air_brake)
{
cheat_state->actor.air_brake = 0;
}
else
{
cheat_state->actor.air_brake = 1;
}
}
if ( KEY_PRESSED(set.key_air_brake_mod2) && cheat_state->actor.air_brake )
{
if(cheat_state->actor.air_brake_slowmo)
{
cheat_state->actor.air_brake_slowmo = 0;
}
else
{
cheat_state->actor.air_brake_slowmo = 1;
}
}
}
else
{
if ( KEY_PRESSED(set.key_air_brake_foot_mod) )
cheat_state->actor.air_brake = 1;
else if ( KEY_RELEASED(set.key_air_brake_foot_mod) )
cheat_state->actor.air_brake = 0;
if ( KEY_PRESSED(set.key_air_brake_mod2) && cheat_state->actor.air_brake )
cheat_state->actor.air_brake_slowmo = 1;
else if ( KEY_RELEASED(set.key_air_brake_mod2) && cheat_state->actor.air_brake )
cheat_state->actor.air_brake_slowmo = 0;
}
if ( !was_enabled && cheat_state->actor.air_brake )
{
vect3_copy( &info->base.matrix[4 * 3], orig_pos );
fall_speed_mult = 1.0f;
was_enabled = 1;
}
if ( !cheat_state->actor.air_brake )
{
was_enabled = 0;
cheat_state->actor.air_brake_slowmo = 0;
}
else
{
float *matrix = info->base.matrix;
// if there's no parachute
if ( !(info->weapon_slot == 11 && info->weapon[11].id == 46) )
{
vect3_copy( orig_pos, &info->base.matrix[4 * 3] );
vect3_zero( info->speed );
// new pedFlags
info->pedFlags.bIsStanding = true;
info->pedFlags.bWasStanding = true;
info->pedFlags.bStayInSamePlace = true;
static uint32_t time_start;
float d[4] = { 0.0f, 0.0f, 0.0f, time_diff * set.air_brake_speed };
if ( cheat_state->actor.air_brake_slowmo )
d[3] /= 10.0f;
if ( KEY_DOWN(set.key_air_brake_forward) )
d[0] += 1.0f;
if ( KEY_DOWN(set.key_air_brake_backward) )
d[0] -= 1.0f;
if ( KEY_DOWN(set.key_air_brake_left) )
d[1] += 1.0f;
if ( KEY_DOWN(set.key_air_brake_right) )
d[1] -= 1.0f;
if ( KEY_DOWN(set.key_air_brake_up) )
d[2] += 1.0f;
if ( KEY_DOWN(set.key_air_brake_down) )
d[2] -= 1.0f;
if ( !near_zero(set.air_brake_accel_time) )
{
if ( !vect3_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.air_brake_accel_time )
d[3] *= t / set.air_brake_accel_time;
}
}
if ( !vect3_near_zero(d) )
{
float vect[4] = { -d[1], d[0], d[2], 0.0f };
float out[4];
/* out = matrix * norm(d) */
vect3_normalize( vect, vect );
matrix_vect4_mult( matrix, vect, out );
matrix[4 * 3 + 0] += out[0] * d[3];
matrix[4 * 3 + 1] += out[1] * d[3];
matrix[4 * 3 + 2] += out[2] * d[3];
}
}
// parachute
else
{
if ( KEY_DOWN(set.key_air_brake_up) )
fall_speed_mult += time_diff / 2.0f;
if ( KEY_DOWN(set.key_air_brake_down) )
fall_speed_mult -= time_diff / 2.0f;
if ( fall_speed_mult < 0.0f )
fall_speed_mult = 0.0f;
else if ( fall_speed_mult > 2.0f )
fall_speed_mult = 2.0f;
matrix[4 * 3 + 0] += info->speed[0] * time_diff * set.air_brake_speed;
matrix[4 * 3 + 1] += info->speed[1] * time_diff * set.air_brake_speed;
matrix[4 * 3 + 2] -= ( matrix[4 * 3 + 2] - orig_pos[2] ) * fall_speed_mult;
}
vect3_copy( &matrix[4 * 3], orig_pos );
// heh
int gonadsMult = 1000;
float strifeMult = 0.00001f;
int gonads = rand() % gonadsMult;
float strife = (double)gonads * strifeMult;
if ( strife < strifeMult * gonadsMult / 2 )
strife -= strifeMult * gonadsMult;
info->m_SpeedVec.fX = strife;
gonads = rand() % gonadsMult;
strife = (double)gonads * strifeMult;
if ( strife < strifeMult * gonadsMult / 2 )
strife -= strifeMult * gonadsMult;
info->m_SpeedVec.fY = strife;
}
}