void buyhouse(void *)
{
static struct patch_set sampPatchDialog =
{
"Data", 0, 0,
{
{ 1, (void *)((uint8_t *)g_dwSAMP_Addr + 0xBC70), NULL, hex_to_bin("C390"), NULL }
}
};
patcher_install(&sampPatchDialog);
Sleep(1000);
say("/buyhouse");
Sleep(1000);
patcher_remove(&sampPatchDialog);
}
void cheat_handle_hp ( struct vehicle_info *vehicle_info, struct actor_info *actor_info, float time_diff )
{
traceLastFunc( "cheat_handle_hp()" );
static float prev_pos[3];
if ( KEY_PRESSED(set.key_hp_cheat) )
cheat_state->_generic.hp_cheat ^= 1; /* toggle hp cheat */
// this will make SP enemies invulnerable
// now checking for a valid SAMP game
if (g_SAMP)
{
if ( cheat_state->_generic.hp_cheat && cheat_state->actor.invulnerable && !set.hp_disable_inv_sp_enemies )
patcher_install( &patch_actor_hp_extraInv );
else
patcher_remove( &patch_actor_hp_extraInv );
}
if ( cheat_state->_generic.hp_cheat && cheat_state->actor.invulnerable )
{
patcher_install( &patch_actor_hp );
//patcher_install( &patch_actor_hp2 );
//patcher_install( &patch_actor_hp3 );
}
else
{
patcher_remove( &patch_actor_hp );
//patcher_remove( &patch_actor_hp2 );
//patcher_remove( &patch_actor_hp3 );
}
if ( cheat_state->_generic.hp_cheat && cheat_state->vehicle.invulnerable )
patcher_install( &patch_vehicle_hp );
else
patcher_remove( &patch_vehicle_hp );
if ( vehicle_info != NULL )
{
struct vehicle_info *info = vehicle_info;
struct vehicle_info *temp;
// actor_info is NULL, if vehicle_info is not ( we need the actor though )
actor_info = actor_info_get( ACTOR_SELF, 0 );
if ( cheat_state->_generic.hp_cheat )
{
for ( temp = info; temp != NULL; temp = temp->trailer )
{
if(temp == NULL) return;
/* minimum hp */
if ( cheat_state->vehicle.hp_minimum_on && temp->hitpoints < set.hp_minimum )
temp->hitpoints = set.hp_minimum;
if ( set.hp_keep_vehicleHPsane )
{
// actor_info was NULL duh
if ( temp->passengers[0] == actor_info && temp->hitpoints > 1000.0f )
{
if ( set.hp_minimum <= 1000.0f )
temp->hitpoints = 1000.0f;
else if ( temp->hitpoints > set.hp_minimum )
temp->hitpoints = set.hp_minimum;
}
}
/* regen */
if ( temp->hitpoints < 1000.0f )
temp->hitpoints += time_diff * set.hp_regen;
if ( cheat_state->vehicle.invulnerable )
{
temp->m_nVehicleFlags.bCanBeDamaged = false;
//temp->flags |= VEHICLE_FLAGS_INVULNERABLE; /* invulnerable to most things */
temp->flags &= ~2; /* make sure we're not frozen :p */
//if ( temp->pulling_truck != NULL )
// temp->hitpoints = 1000.0f;
}
else
{
temp->m_nVehicleFlags.bCanBeDamaged = true;
//temp->flags &= ~VEHICLE_FLAGS_INVULNERABLE;
}
if ( cheat_state->vehicle.hp_tire_support )
cheat_vehicle_tires_set( temp, 0 );
/*
if(cheat_state->vehicle.is_engine_on == 1)
temp->m_nVehicleFlags.bEngineOn = 1;
else if((cheat_state->vehicle.is_engine_on == 0))
temp->m_nVehicleFlags.bEngineOn = 0;
*/
// temp->engine_state |= 16; // protect against engine stalls
if ( !set.trailer_support )
break;
}
}
else
{
for ( temp = info; temp != NULL; temp = temp->trailer )
{
if(temp == NULL) return;
// HP cheat disabled - keep HP value sane
if ( set.hp_keep_vehicleHPsane )
{
if ( temp->hitpoints > 1000.0f )
temp->hitpoints = 1000.0f;
}
temp->m_nVehicleFlags.bCanBeDamaged = true;
//temp->flags &= ~VEHICLE_FLAGS_INVULNERABLE;
if ( !set.trailer_support )
break;
}
}
}
if ( actor_info != NULL )
{
struct actor_info *info = actor_info;
if ( cheat_state->_generic.hp_cheat )
{
if ( info->hitpoints < 100.0f )
info->hitpoints += time_diff * set.hp_regen_onfoot;
}
if ( cheat_state->_generic.hp_cheat && cheat_state->actor.invulnerable )
{
// invulnerability is on - at least be
// invulnerable against non explosive projectiles
info->flags |= 4;
if ( set.hp_actor_explosion_inv )
info->flags |= 8;
if ( set.hp_actor_fall_inv )
info->flags |= 64;
if ( set.hp_actor_fire_inv )
info->flags |= 128;
//info->flags |= ACTOR_FLAGS_INVULNERABLE;
}
else
info->flags &= ~ACTOR_FLAGS_INVULNERABLE;
}
}
int cheat_panic ( void )
{
traceLastFunc( "cheat_panic()" );
static int pstate_map = 0, // m0d's map
pstate_d3dtext_hud = 0, // hud bar
pstate_actor_hp_nSP = 0, // "Extra actor invincibility" patch (invulnerable single player enemies)
pstate_actor_hp_SP = 0, // "Extra actor invincibility2" patch (no problems in SP)
pstate_vehicle_hp = 0, // vehicle hp patch
pstate_generic_menu = 0, // m0d's menu
pstate_infnos = 0, // infinite NOS
pstate_ini[INI_PATCHES_MAX],
pstate_dummy_aligner; // this should all be a structure, static = DOING IT WRONG
int i;
// sa-mp related
static int pstate_chat = 0, // chat
pstate_deathlist = 0; // deathlist
if ( KEY_PRESSED(set.key_panic) )
{
// toggle panic
cheat_state->_generic.cheat_panic_enabled ^= 1;
if ( cheat_state->_generic.cheat_panic_enabled )
{
struct actor_info *actor_info = actor_info_get( ACTOR_SELF, ACTOR_ALIVE );
if ( actor_info )
{
actor_info->flags &= ~ACTOR_FLAGS_INVULNERABLE;
actor_info->weapon_slot = 0;
}
// remove infinite NOS
pstate_infnos = cheat_state->vehicle.infNOS_toggle_on;
cheat_state->vehicle.infNOS_toggle_on = false;
patcher_remove( &patch_vehicle_inf_NOS );
if ( pPedSelf->GetVehicle() )
{
CVehicle *pVehicleSelf = pPedSelf->GetVehicle();
CVehicle *pVehicleTemp = NULL;
for ( pVehicleTemp = pVehicleSelf; pVehicleTemp != NULL; pVehicleTemp = pVehicleTemp->GetTowedVehicle() )
{
pVehicleTemp->SetGravity( &CVector(0.0, 0.0, -1.0) );
pVehicleTemp->SetCanBeDamaged( true );
if ( !set.trailer_support )
break;
}
// remove inf NOS
if ( pstate_infnos )
{
pVehicleSelf->RemoveVehicleUpgrade( 1010 );
//pVehicleSelf->AddVehicleUpgrade( 1010 );
}
// reset overrideLights, pstate not needed, will be reactivated on demand
if ( set.enable_car_lights_at_day_time )
pVehicleSelf->SetOverrideLights( 0 );
}
// hud bar, this should probably become a cheat_state
pstate_d3dtext_hud = set.d3dtext_hud;
set.d3dtext_hud = 0;
// m0d's map
pstate_map = cheat_state->_generic.map;
cheat_state->_generic.map = 0;
// m0d's menu
pstate_generic_menu = cheat_state->_generic.menu;
cheat_state->_generic.menu = 0;
// remove "Extra actor invincibility" patch
pstate_actor_hp_nSP = patch_actor_hp_extraInv.installed;
patcher_remove( &patch_actor_hp_extraInv );
pstate_actor_hp_SP = patch_actor_hp.installed;
patcher_remove( &patch_actor_hp );
// remove vehicle hp patch
pstate_vehicle_hp = patch_vehicle_hp.installed;
patcher_remove( &patch_vehicle_hp );
// just call with null vehicle info to disable
cheat_handle_vehicle_fly( NULL, 0.0f );
for ( i = 0; i < INI_PATCHES_MAX; i++ )
{
// added to not remove volatile patches
if ( !set.patch[i].has_volatile )
{
pstate_ini[i] = set.patch[i].installed;
patcher_remove( &set.patch[i] );
}
}
// turn off kill & chat
if ( g_DeathList != NULL )
{
pstate_deathlist = g_DeathList->iEnabled;
g_DeathList->iEnabled = 1;
}
if ( g_Chat != NULL )
{
pstate_chat = g_Chat->iChatWindowMode;
g_Chat->iChatWindowMode = 2;
}
}
else
{
// restore infinite NOS
if ( pstate_infnos )
{
cheat_state->vehicle.infNOS_toggle_on = true;
patcher_install( &patch_vehicle_inf_NOS );
}
// vehicle stuff
CPed *pPedSelf = pPools->GetPedFromRef( CPOOLS_PED_SELF_REF );
if ( pPedSelf->GetVehicle() )
{
CVehicle *pVehicleSelf = pPedSelf->GetVehicle();
// restore inf NOS
if ( pstate_infnos )
{
pVehicleSelf->AddVehicleUpgrade( 1010 );
}
}
// restore "Extra actor invincibility" patch
if ( pstate_actor_hp_nSP )
patcher_install( &patch_actor_hp_extraInv );
if ( pstate_actor_hp_SP )
patcher_install( &patch_actor_hp );
// restore vehicle hp patch
if ( pstate_vehicle_hp )
patcher_install( &patch_vehicle_hp );
// restore some cheat_states
set.d3dtext_hud = pstate_d3dtext_hud;
cheat_state->_generic.map = pstate_map;
cheat_state->_generic.menu = pstate_generic_menu;
// restore patches
for ( i = 0; i < INI_PATCHES_MAX; i++ )
{
if ( pstate_ini[i] )
patcher_install( &set.patch[i] );
}
// restore kill & chat
if ( g_DeathList != NULL )
{
g_DeathList->iEnabled = pstate_deathlist;
}
if ( g_Chat != NULL )
{
g_Chat->iChatWindowMode = pstate_chat;
}
// clear cheat state text
cheat_state_text( NULL );
}
}
return cheat_state->_generic.cheat_panic_enabled;
}
void cheat_hook ( HWND wnd )
{
traceLastFunc( "cheat_hook()" );
// get the time
static uint64_t time_last;
__time_current = __time_get();
g_timeDiff = TIME_TO_DOUBLE(time_get() - time_last);
// for looping
int i;
// install keyhook
keyhook_maybe_install( wnd );
// setup menu
menu_maybe_init();
traceLastFunc( "cheat_hook()" );
/* initialize state */
if ( cheat_state == NULL )
{
// set default cheat_state variables
cheat_state = &__cheat_state;
cheat_state->_generic.spoof_weapon = -1;
cheat_state->_generic.money = set.money_enabled;
cheat_state->_generic.weapon = set.weapon_enabled;
cheat_state->_generic.vehicles_unlock = false;
cheat_state->_generic.vehicles_warp_invert = true;
cheat_state->actor.invulnerable = true;
cheat_state->vehicle.invulnerable = true;
cheat_state->vehicle.hp_tire_support = true;
cheat_state->vehicle.hp_minimum_on = 1;
cheat_state->vehicle.hp_regen_on = 1;
cheat_state->actor.hp_regen_on = 1;
cheat_state->vehicle.brkdance = 0;
cheat_state->game_speed = 1.0f;
cheat_state->vehicle.is_engine_on = 1;
cheat_state->_generic.interior_patch_enabled = 0;
// refreshes any cheat_state stuff set from the INI
ini_load_setSettings();
/* install patches from the .ini file */
for ( i = 0; i < INI_PATCHES_MAX; i++ )
{
if ( set.patch[i].name != NULL && set.patch[i].ini_auto )
patcher_install( &set.patch[i] );
}
if ( g_dwSAMP_Addr != NULL )
{
for ( i = 0; i < INI_SAMPPATCHES_MAX; i++ )
{
if ( set.sampPatch[i].name != NULL && set.sampPatch[i].ini_auto )
patcher_install( &set.sampPatch[i] );
}
}
} /* end initialize state */
// set cheat state to "off"
cheat_state->state = CHEAT_STATE_NONE;
/* setup & refresh actor pool */
pool_actor = *(struct pool **)ACTOR_POOL_POINTER;
if ( pool_actor == NULL || pool_actor->start == NULL || pool_actor->size <= 0 )
return;
/* setup & refresh vehicle pool */
pool_vehicle = *(struct pool **)VEHICLE_POOL_POINTER;
if ( pool_vehicle == NULL || pool_vehicle->start == NULL || pool_vehicle->size <= 0 )
return;
//////////////////////////////////////////
// looks like we have pools so continue //
struct actor_info *actor_info;
struct vehicle_info *vehicle_info;
actor_info = actor_info_get( ACTOR_SELF, ACTOR_ALIVE );
vehicle_info = vehicle_info_get( VEHICLE_SELF, 0 );
/* no vehicle, and no actor. exit. */
if ( vehicle_info == NULL && actor_info == NULL )
{
if ( cheat_state->actor.air_brake
|| cheat_state->actor.stick
|| cheat_state->vehicle.air_brake
|| cheat_state->vehicle.stick )
{
cheat_state->actor.air_brake = 0;
cheat_vehicle_air_brake_set( 0 );
cheat_state->actor.stick = 0;
cheat_state->vehicle.stick = 0;
cheat_state_text( "Air brake / stick disabled" );
}
}
else
{
if ( vehicle_info == NULL )
{
if ( cheat_state->vehicle.air_brake || cheat_state->vehicle.stick )
{
cheat_vehicle_air_brake_set( 0 );
cheat_state->vehicle.stick = 0;
cheat_state_text( "Air brake / stick disabled" );
}
cheat_state->state = CHEAT_STATE_ACTOR;
// reset infinite NOS toggle state
if ( cheat_state->vehicle.infNOS_toggle_on )
{
cheat_state->vehicle.infNOS_toggle_on = false;
patcher_remove( &patch_vehicle_inf_NOS );
}
}
else
{
if ( cheat_state->actor.air_brake || cheat_state->actor.stick )
{
cheat_state->actor.air_brake = 0;
cheat_state->actor.stick = 0;
cheat_state_text( "Air brake / stick disabled" );
}
cheat_state->state = CHEAT_STATE_VEHICLE;
}
// post GTA initialization initizalization routines
if ( m_InitStages == 0 )
{
// setup CGame & friends
pGameInterface = new CGameSA();
pPools = pGameInterface->GetPools();
//pGameInterface->Initialize(); // all this does so far is disable modshops and pay&sprays
// this seems to fix SAMP's load hang bug
//pGameInterface->StartGame();
// we have to add ourself to the pool first so that we are always the 1st ref
// NEW --> use the global external: pPedSelf
pPedSelf = pGameInterface->GetPools()->AddPed( (DWORD *)actor_info );
pPedSelfSA = pPedSelf->GetPedInterface();
// install all startup hooks
cheat_hookers_installhooks();
// increment stage
m_InitStages++;
}
else if ( m_InitStages == 1 )
{
// load all the weapon models
loadAllWeaponModels();
// get funky
//pGameInterface->GetAudio()->PlayBeatTrack(2);
// increment stage
m_InitStages++;
}
}
if ( cheat_state->state != CHEAT_STATE_NONE )
{
// keep this updated, cos something is switching it now
pPedSelf = pPools->GetPedFromRef( CPOOLS_PED_SELF_REF );
pPedSelfSA = pPedSelf->GetPedInterface();
}
static bool chat_set_once = false;
if ( !chat_set_once && set.d3dtext_chat )
{
if ( g_Chat != NULL && g_Chat->iChatWindowMode )
{
//Log("Disabling SA:MP chat text.");
g_Chat->iChatWindowMode = 0;
chat_set_once = true;
}
}
// sets kill text to s0beit mode if enabled from INI
static bool kill_set_once = false;
if ( !kill_set_once && set.d3dtext_kill )
{
if ( g_DeathList != NULL && g_DeathList->iEnabled )
{
g_DeathList->iEnabled = 0;
kill_set_once = true;
}
}
// more random than random
if ( rand() % 5000 == 0 )
srand( rand() + time_get() );
// OMGWTFBBQ?!?
if ( cheat_panic() )
{
cheat_state->state = CHEAT_STATE_NONE;
goto out;
}
// menus are good
menu_run();
// install volatile patches from the .ini file
for ( i = 0; i < INI_PATCHES_MAX; i++ )
{
if ( set.patch[i].name != NULL && set.patch[i].has_volatile && set.patch[i].installed )
patcher_install( &set.patch[i] );
}
// generic stuff - these want to run even though we're dead
cheat_handle_debug( wnd );
cheat_handle_misc();
cheat_handle_spoof_weapon();
cheat_handle_weapon();
gta_game_speed_set( cheat_state->game_speed );
cheat_main_display_debug_stuff(g_timeDiff);
if ( cheat_state->state != CHEAT_STATE_NONE )
{
// generic stuff
cheat_handle_weapon_disable();
cheat_handle_money();
//////////////////////////////////////////////////////////////////
// this should be removed after reworking weapon cheat function //
//if ( set.restore_weapons_after_death )
// * (uint8_t *)0x5E6320 = 0xC3;
cheat_handle_unlock();
cheat_handle_checkpoint();
// do stuff :p
if ( cheat_state->state == CHEAT_STATE_VEHICLE )
{
cheat_main_vehicle( g_timeDiff );
}
else if ( cheat_state->state == CHEAT_STATE_ACTOR )
{
cheat_main_actor( g_timeDiff );
}
if ( KEY_PRESSED(set.key_disable_Wall_Collisions) )
{
cheat_state->_generic.nocols_walls_enabled ^= 1;
if ( cheat_state->_generic.nocols_walls_enabled )
patcher_install( &patch_NoColsWalls );
else
patcher_remove( &patch_NoColsWalls );
}
for ( i = 0; i < INI_PATCHES_MAX; i++ )
{
if ( set.patch[i].name != NULL && KEY_PRESSED(set.patch[i].ini_hotkey) )
{
if ( set.patch[i].installed || set.patch[i].failed )
patcher_remove( &set.patch[i] );
else
patcher_install( &set.patch[i] );
}
}
for ( i = 0; i < INI_SAMPPATCHES_MAX; i++ )
{
if ( set.sampPatch[i].name != NULL && KEY_PRESSED(set.sampPatch[i].ini_hotkey) )
{
if ( set.sampPatch[i].installed || set.sampPatch[i].failed )
patcher_remove( &set.sampPatch[i] );
else
patcher_install( &set.sampPatch[i] );
}
}
if ( KEY_PRESSED(set.key_vehicle_jumper) )
{
int iVehicleID = vehicle_find_nearest( VEHICLE_ALIVE + VEHICLE_NOTBURNING );
vehicleJumper( iVehicleID );
}
if ( KEY_PRESSED(set.key_vehicle_occupied_jumper) )
{
int iVehicleID = vehicle_find_nearest( VEHICLE_ALIVE + VEHICLE_NOTBURNING + VEHICLE_OCCUPIED );
vehicleJumper( iVehicleID );
}
} // cheat_state->state != CHEAT_STATE_NONE
// hack some SA:MP, shall we?
if ( g_SAMP && g_renderSAMP_initSAMPstructs )
sampMainCheat();
out: ;
if (gta_menu_active()) {
keyhook_clear_states();
*(BYTE *)0xB7CB49 = 0; // game not paused even if we are in the menu.
}
else
keyhook_run();
time_last = time_get();
}
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;
}
}
