mirrors/re3
1
0
Fork 0
mirror of https://github.com/halpz/re3.git synced 2025-08-04 04:31:21 +00:00
Code Issues Projects Releases Wiki Activity

Add files via upload

Browse source
This commit is contained in:
MaZaHa-Ka 2024-09-27 13:12:14 +03:00 committed by GitHub
parent 17872b8fc9
commit 61771d1c2c
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
18 changed files with 10279 additions and 12289 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

82
src/collision/ColStore.cpp
View file

@ -30,6 +30,9 @@ bool bDispColInMem;
// CColStore::LoadAllBoundingBoxes(void)
// CColStore::Write(base::cRelocatableChunkWriter &)
//#ifdef MAZAHAKA_MAPZONE_VC
//#else
#ifndef MAZAHAKA_MAPZONE_VC
const CVector&
LevelPos(eLevelName level)
{
@ -61,6 +64,7 @@ PosLevel(const CVector &pos)
return lastOtherLevel;
}
}
#endif
void
CColStore::Initialise(void)
@ -251,6 +255,7 @@ CColStore::AddCollisionNeededAtPosn(const CVector &pos)
secondPosition = pos;
}
#ifndef MAZAHAKA_MAPZONE_VC
void
CColStore::LoadCollision(const CVector &pos, eLevelName level)
{
@ -326,7 +331,56 @@ CColStore::LoadCollision(const CVector &pos, eLevelName level)
}
bLoadAtSecondPosition = false;
}
#else
void
CColStore::LoadCollision(const CVector2D &pos)
{
int i;
if(CStreaming::ms_disableStreaming)
return;
for(i = 1; i < COLSTORESIZE; i++){
if(GetSlot(i) == nil)
continue;
bool wantThisOne = false;
if(GetBoundingBox(i).IsPointInside(pos) ||
bLoadAtSecondPosition && GetBoundingBox(i).IsPointInside(secondPosition, -119.0f) ||
strcmp(GetColName(i), "yacht") == 0){
wantThisOne = true;
}else{
for (int j = 0; j < MAX_CLEANUP; j++) {
CPhysical* pEntity = nil;
cleanup_entity_struct* pCleanup = &CTheScripts::MissionCleanUp.m_sEntities[j];
if (pCleanup->type == CLEANUP_CAR) {
pEntity = CPools::GetVehiclePool()->GetAt(pCleanup->id);
if (!pEntity || pEntity->GetStatus() == STATUS_WRECKED)
continue;
}
else if (pCleanup->type == CLEANUP_CHAR) {
pEntity = CPools::GetPedPool()->GetAt(pCleanup->id);
if (!pEntity || ((CPed*)pEntity)->DyingOrDead())
continue;
}
if (pEntity && !pEntity->bDontLoadCollision && !pEntity->bIsFrozen) {
if (GetBoundingBox(i).IsPointInside(pEntity->GetPosition(), -80.0f))
wantThisOne = true;
}
}
}
if(wantThisOne)
CStreaming::RequestCol(i, STREAMFLAGS_PRIORITY);
else
CStreaming::RemoveCol(i);
}
bLoadAtSecondPosition = false;
}
#endif
#ifndef MAZAHAKA_MAPZONE_VC
void
CColStore::RequestCollision(const CVector &pos)
{
@ -336,6 +390,17 @@ CColStore::RequestCollision(const CVector &pos)
if(GetSlot(i) && DoScriptsWantThisIn(i) && GetBoundingBox(i).IsPointInside(LevelPos(PosLevel(pos)), -115.0f))
CStreaming::RequestCol(i, STREAMFLAGS_PRIORITY);
}
#else
void
CColStore::RequestCollision(const CVector/*2D*/ &pos)
{
int i;
for(i = 1; i < COLSTORESIZE; i++)
if(GetSlot(i) && GetBoundingBox(i).IsPointInside(pos, -115.0f))
CStreaming::RequestCol(i, STREAMFLAGS_PRIORITY);
}
#endif
void
CColStore::EnsureCollisionIsInMemory(const CVector &pos)
@ -374,6 +439,7 @@ CColStore::DoScriptsWantThisIn(int32 slot)
return true;
}
#ifndef MAZAHAKA_MAPZONE_VC
bool
CColStore::HasCollisionLoaded(eLevelName level)
{
@ -388,12 +454,28 @@ CColStore::HasCollisionLoaded(eLevelName level)
return false;
return true;
}
#else
bool
CColStore::HasCollisionLoaded(const CVector2D &pos)
{
int i;
for(i = 1; i < COLSTORESIZE; i++)
if(GetSlot(i) && GetBoundingBox(i).IsPointInside(pos, -115.0f) &&
!GetSlot(i)->isLoaded)
return false;
return true;
}
#endif
//lcs
#ifndef MAZAHAKA_MAPZONE_VC
bool
CColStore::HasCollisionLoaded(const CVector &pos)
{
return HasCollisionLoaded(PosLevel(pos));
}
#endif
void
CColStore::Load(bool onlyBB, CPool<ColDef> *pool)

14
src/collision/ColStore.h
View file

@ -32,12 +32,24 @@ public:
static void AddCollisionNeededAtPosn(const CVector &pos);
static void LoadAllCollision(void);
static void RemoveAllCollision(void);
#ifndef MAZAHAKA_MAPZONE_VC
//lcs
static void LoadCollision(const CVector &pos, eLevelName level = LEVEL_GENERIC);
#else
static void LoadCollision(const CVector2D &pos);
#endif
static void RequestCollision(const CVector &pos);
static void EnsureCollisionIsInMemory(const CVector &pos);
static bool DoScriptsWantThisIn(int32 slot);
#ifndef MAZAHAKA_MAPZONE_VC
//lcs
static bool HasCollisionLoaded(eLevelName level);
static bool HasCollisionLoaded(const CVector &pos);
#else
static bool HasCollisionLoaded(const CVector2D &pos);
#endif
static void Load(bool, CPool<ColDef> *pool);
static ColDef *GetSlot(int slot) {
@ -48,4 +60,6 @@ public:
}
};
#ifndef MAZAHAKA_MAPZONE_VC
const CVector& LevelPos(eLevelName level);
#endif

25
src/control/FerrisWheel.cpp Normal file
View file

@ -0,0 +1,25 @@
#pragma once
#include "FerrisWheel.h"
void CFerrisWheel::Init()
{
//debug("CFerrisWheel::Init()\n");
}
void
CFerrisWheel::Update()
{
//debug("CFerrisWheel::Update()\n");
}
void
CFerrisWheel::Shutdown()
{
//debug("CFerrisWheel::Shutdown()\n");
}

12
src/control/FerrisWheel.h Normal file
View file

@ -0,0 +1,12 @@
#pragma once
#include "common.h"
class CFerrisWheel // todo maybe CFerrisWheels.process -> CFerrisWheel.Update
{
//static uint32 keyTable[256];
public:
static void Init(); // 1755E0 delegate check todo if need
static void Update();
static void Shutdown();
// ops 1223 1224 1225 1226
};

1
src/control/PathFind.cpp
View file

@ -437,6 +437,7 @@ CPathFind::LoadPathFindData(void)
return false;
}
//__declspec(noinline)
void
CPathFind::PreparePathData(void)
{

3067
src/control/Script.cpp
View file

File diff suppressed because it is too large Load diff

61
src/control/Script.h
View file

@ -58,7 +58,7 @@ void FlushLog();
#define SET_FLOAT_PARAM(i, x) *(float*)&ScriptParams[i] = x
#define SET_VECTOR_PARAM(i, v) { *(float*)&ScriptParams[i] = (v).x; *(float*)&ScriptParams[i+1] = (v).y; *(float*)&ScriptParams[i+2] = (v).z; }
#define GTA_SCRIPT_COLLECTIVE
//#define GTA_SCRIPT_COLLECTIVE // vcs tmp disabled ------------
struct intro_script_rectangle
{
@ -229,9 +229,10 @@ enum {
MAX_STACK_DEPTH = 16,
NUM_LOCAL_VARS = 96,
NUM_TIMERS = 2,
NUM_GLOBAL_SLOTS = 26
NUM_GLOBAL_SLOTS = 25,//string \/
};
//https://gtamods.com/wiki/SCM_Instruction#Concrete_data_types
enum {
ARGUMENT_END = 0,
ARGUMENT_INT_ZERO,
@ -243,7 +244,8 @@ enum {
ARGUMENT_INT8,
ARGUMENT_INT16,
ARGUMENT_FLOAT,
ARGUMENT_TIMER,
ARGUMENT_STRING, // 0xF653F
ARGUMENT_TIMER, // 0xE5412 -=@, 0x4D6F9 -=@val
ARGUMENT_LOCAL = ARGUMENT_TIMER + NUM_TIMERS,
ARGUMENT_LOCAL_ARRAY = ARGUMENT_LOCAL + NUM_LOCAL_VARS,
ARGUMENT_GLOBAL = ARGUMENT_LOCAL_ARRAY + NUM_LOCAL_VARS,
@ -253,6 +255,7 @@ enum {
static_assert(MAX_ARGUMENT <= 256, "MAX_ARGUMENT must be less or equal to 256");
struct tCollectiveData
{
int32 colIndex;
@ -290,6 +293,8 @@ struct script_corona
int flareType;
};
//class CTheScripts; // ahahahh
class CRunningScript
{
enum {
@ -325,21 +330,22 @@ public:
CRunningScript* next;
CRunningScript* prev;
int32 m_nId;
char m_abScriptName[8];
//uint32 pad4; // mazahaka vcs
uint32 m_nIp;
uint32 m_anStack[MAX_STACK_DEPTH];
uint16 m_nStackPointer;
int32 m_anLocalVariables[NUM_LOCAL_VARS + 8 + NUM_TIMERS]; // TODO(LCS): figure out why 106
int32 m_anLocalVariables[NUM_LOCAL_VARS + 8 + NUM_TIMERS]; // TODO(VCS): figure out why 106
int32 m_nLocalsPointer;
uint32 m_nWakeTime;
uint16 m_nStackPointer;
uint16 m_nAndOrState;
bool m_bIsActive;
bool m_bCondResult;
bool m_bIsMissionScript;
bool m_bSkipWakeTime;
uint32 m_nWakeTime;
uint16 m_nAndOrState;
bool m_bNotFlag;
bool m_bDeatharrestEnabled;
bool m_bDeatharrestExecuted;
char m_abScriptName[8];
bool m_bMissionFlag;
public:
@ -364,9 +370,14 @@ public:
void CollectParameters(uint32*, int16, int* pParams = (int*)&ScriptParams);
int32 CollectNextParameterWithoutIncreasingPC(uint32);
int32* GetPointerToScriptVariable(uint32*, int16);
int32* GetPointerToScriptVariable(uint32*);
void StoreParameters(uint32*, int16);
// vcs todo inline. scriptspace static err
/*inline*/ const char *GetKeyFromScript(uint32 *pIp);
wchar *GetTextByKeyFromScript(uint32 *pIp);
int8 ProcessOneCommand();
void DoDeatharrestCheck();
void UpdateCompareFlag(bool flag)
@ -409,9 +420,6 @@ public:
int8 ProcessCommands1100To1199(int32);
int8 ProcessCommands1200To1299(int32);
int8 ProcessCommands1300To1399(int32);
int8 ProcessCommands1400To1499(int32);
int8 ProcessCommands1500To1599(int32);
int8 ProcessCommands1600To1699(int32);
uint32 CollectLocateParameters(uint32*, bool);
void LocatePlayerCommand(int32, uint32*);
@ -465,10 +473,6 @@ public:
};
enum {
VAR_LOCAL = 1,
VAR_GLOBAL = 2,
};
enum {
MAX_NUM_SCRIPTS = 128,
@ -585,13 +589,18 @@ public:
return Read2BytesFromScript(pIp) / 16.0f;
}
static void ReadTextLabelFromScript(uint32* pIp, char* buf) {
strncpy(buf, (const char*)&CTheScripts::ScriptSpace[*pIp], KEY_LENGTH_IN_SCRIPT);
}
static wchar* GetTextByKeyFromScript(uint32* pIp) {
wchar* text = TheText.Get((const char*)&CTheScripts::ScriptSpace[*pIp]);
*pIp += KEY_LENGTH_IN_SCRIPT;
return text;
//script_assert(false && "LABEL RECHECK TO MY FUNCS!!");
script_assert(false && "REMOVE ME!!!!!!");
return; // âîçìîæíî íå íóæíà ôóíêöèÿ, usege GetTextByKeyFromScript GetKeyFromScript
//strncpy(buf, (const char*)&CTheScripts::ScriptSpace[*pIp], KEY_LENGTH_IN_SCRIPT);
}
//--------------VCS TODO PROBABLY REMOVED BY COLLECT
//static wchar* GetTextByKeyFromScript(uint32* pIp) {
// wchar* text = TheText.Get((const char*)&CTheScripts::ScriptSpace[*pIp]);
// *pIp += KEY_LENGTH_IN_SCRIPT;
// return text;
//}
static int32 GetSizeOfVariableSpace()
{
uint32 tmp = 3;
@ -725,3 +734,11 @@ enum {
extern int gScriptsFile;
extern CVector gVectorSetInLua;
#define GetPlayerInfoByPoolHandler(pPlayerInfo, han)\
CPed *gpi_ped = CPools::GetPedPool()->GetAt(han);\
script_assert(gpi_ped);\
CPlayerInfo *pPlayerInfo = ((CPlayerPed *)gpi_ped)->GetPlayerInfoForThisPlayerPed();\
script_assert(pPlayerInfo);
// CPlayerPed *pPlayer = FindPlayerPed();
// CPlayerInfo *pPlayerInfo = &CWorld::Players[CWorld::PlayerInFocus];

400
src/control/Script10.cpp
View file

@ -23,404 +23,4 @@
#include "Weather.h"
#include "World.h"
bool gDeveloperFlag;
int8 CRunningScript::ProcessCommands1600To1699(int32 command)
{
switch (command) {
case COMMAND_ADD_NOODLES_DELIVERED:
CollectParameters(&m_nIp, 1);
// CStats::NoodlesDelievered += GET_INTEGER_PARAM(0);
return 0;
case COMMAND_REGISTER_SCRAPYARD_CHALLENGE_SCORE:
CollectParameters(&m_nIp, 1);
//CStats::TopScrapyardChallengeScore = Max(CStats::TopScrapyardChallengeScore, GET_INTEGER_PARAM(0));
return 0;
case COMMAND_REGISTER_9MM_MAYHEM_SCORE:
CollectParameters(&m_nIp, 1);
//CStats::Top9mmMayhemScore = Max(CStats::Top9mmMayhemScore, GET_INTEGER_PARAM(0));
return 0;
case COMMAND_REGISTER_SCOOTER_SHOOTER_SCORE:
CollectParameters(&m_nIp, 1);
//CStats::TopScooterShooterScore = Max(CStats::TopScooterShooterScore, GET_INTEGER_PARAM(0));
return 0;
case COMMAND_ADD_MONEY_MADE_FROM_TOURIST:
CollectParameters(&m_nIp, 1);
// CStats::MoneyMadeFromTourist += GET_INTEGER_PARAM(0);
return 0;
case COMMAND_ADD_TOURISTS_TAKEN_TO_SPOTS:
CollectParameters(&m_nIp, 1);
// CStats::TouristsTakenToSpots += GET_INTEGER_PARAM(0);
return 0;
case COMMAND_ADD_EXPORTED_CARS:
CollectParameters(&m_nIp, 1);
// CStats::NumberOfExportedCars += GET_INTEGER_PARAM(0);
return 0;
case COMMAND_SET_TOTAL_EXPORT_CARS:
CollectParameters(&m_nIp, 1);
// CStats::TotalNumberOfCarExport = GET_INTEGER_PARAM(0);
return 0;
case COMMAND_REGISTER_DIRT_BIKE_FASTEST_LAP:
CollectParameters(&m_nIp, 2);
// CStats::RegisterDirtBikeFastestLap(GET_INTEGER_PARAM(0), GET_INTEGER_PARAM(1));
return 0;
case COMMAND_REGISTER_DIRT_BIKE_FASTEST_TIME:
CollectParameters(&m_nIp, 2);
// CStats::RegisterDirtBikeFastestTime(GET_INTEGER_PARAM(0), GET_INTEGER_PARAM(1));
return 0;
case COMMAND_REGISTER_DIRT_BIKE_AIR_TIME:
CollectParameters(&m_nIp, 1);
//CStats::DirtBikeMostAir = Max(CStats::DirtBikeMostAir, GET_INTEGER_PARAM(0));
return 0;
case COMMAND_ADD_ARROW_3D_MARKER:
{
uint32 ip = m_nIp;
uint32 id = (uint32)(uintptr)GetPointerToScriptVariable(&ip, 0);
CollectParameters(&m_nIp, 10);
CVector pos = GET_VECTOR_PARAM(0);
CVector dir = GET_VECTOR_PARAM(3);
pos.z += GET_FLOAT_PARAM(9) + 7.0f;
//C3dMarkers::PlaceMarker(id, MARKERTYPE_ARROW, pos, GET_INTEGER_PARAM(6), GET_INTEGER_PARAM(7), GET_INTEGER_PARAM(8), 200, 1, 3.2f, 1, dir, 1.0f, 0, 0); - TODO
return 0;
}
case COMMAND_PRINT_NOW_OVERRIDE_FADE:
{
wchar* key = CTheScripts::GetTextByKeyFromScript(&m_nIp);
CollectParameters(&m_nIp, 2);
CMessages::AddMessageJumpQ(key, GET_INTEGER_PARAM(0), GET_INTEGER_PARAM(1)); // true, true
return 0;
}
case COMMAND_GET_PICKUP_VALUE:
{
CollectParameters(&m_nIp, 1);
SET_INTEGER_PARAM(0, CPickups::GetValue(GET_INTEGER_PARAM(0)));
StoreParameters(&m_nIp, 1);
return 0;
}
case COMMAND_SET_PICKUP_VALUE:
{
CollectParameters(&m_nIp, 2);
CPickups::SetValue(GET_INTEGER_PARAM(0), GET_INTEGER_PARAM(1));
return 0;
}
case COMMAND_IS_DEVELOPER:
#ifdef GTA_NETWORK
UpdateCompareFlag(gDeveloperFlag || gIsMultiplayerGame);
#else
UpdateCompareFlag(gDeveloperFlag);
#endif
return 0;
case COMMAND_SET_DEVELOPER_FLAG:
CollectParameters(&m_nIp, 1);
gDeveloperFlag = GET_INTEGER_PARAM(0);
return 0;
case COMMAND_REGISTER_WICHITA_WIPEOUT_SCORE:
CollectParameters(&m_nIp, 1);
//CStats::TopWichitaWipeoutScore = Max(CStats::TopWichitaWipeoutScore, GET_INTEGER_PARAM(0));
return 0;
case COMMAND_ATTACH_OBJECT_TO_CAR:
{
CollectParameters(&m_nIp, 5);
CObject* pObject = CPools::GetObjectPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pObject);
CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(GET_INTEGER_PARAM(1));
script_assert(pVehicle);
CVector offset = GET_VECTOR_PARAM(2);
// pObject->AttachObjectToEntity(pVehicle, offset);
return 0;
}
case COMMAND_DETACH_OBJECT_FROM_CAR:
{
CollectParameters(&m_nIp, 1);
CObject* pObject = CPools::GetObjectPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pObject);
// if (pObject && pObject->m_pAttachedTo)
// pObject->DettachObjectFromEntity();
return 0;
}
case COMMAND_SET_PAD_STICKS_MULTIPLIER:
{
CollectParameters(&m_nIp, 2);
CPad::GetPad(0)->unk_B4 = GET_FLOAT_PARAM(0);
CPad::GetPad(0)->unk_B8 = GET_FLOAT_PARAM(1);
return 0;
}
case COMMAND_PRINT_SUBTITLE_NOW:
{
wchar* key = CTheScripts::GetTextByKeyFromScript(&m_nIp);
CollectParameters(&m_nIp, 2);
if (FrontEndMenuManager.m_PrefsShowSubtitles)
CMessages::AddMessageJumpQ(key, GET_INTEGER_PARAM(0), GET_INTEGER_PARAM(1)); // false, true
else
CMessages::AddToPreviousBriefArray(key, -1, -1, -1, -1, -1, -1, nil);
return 0;
}
case COMMAND_PRINT_SUBTITLE_NOW_OVERRIDE_FADE:
{
wchar* key = CTheScripts::GetTextByKeyFromScript(&m_nIp);
CollectParameters(&m_nIp, 2);
if (FrontEndMenuManager.m_PrefsShowSubtitles)
CMessages::AddMessageJumpQ(key, GET_INTEGER_PARAM(0), GET_INTEGER_PARAM(1)); // true, true
else
CMessages::AddToPreviousBriefArray(key, -1, -1, -1, -1, -1, -1, nil);
return 0;
}
case COMMAND_PRINT_SUBTITLE_NOW_NO_BRIEF:
{
wchar* key = CTheScripts::GetTextByKeyFromScript(&m_nIp);
CollectParameters(&m_nIp, 2);
if (FrontEndMenuManager.m_PrefsShowSubtitles)
CMessages::AddMessageJumpQ(key, GET_INTEGER_PARAM(0), GET_INTEGER_PARAM(1)); // false, false
else
CMessages::AddToPreviousBriefArray(key, -1, -1, -1, -1, -1, -1, nil);
return 0;
}
case COMMAND_PRINT_WITH_NUMBER_NOW_NO_BRIEF:
{
wchar* key = CTheScripts::GetTextByKeyFromScript(&m_nIp);
CollectParameters(&m_nIp, 3);
CMessages::AddMessageJumpQWithNumber(key, GET_INTEGER_PARAM(1), GET_INTEGER_PARAM(2), GET_INTEGER_PARAM(0), -1, -1, -1, -1, -1); // 0
return 0;
}
case COMMAND_GET_ANGLE_BETWEEN_POINTS:
{
CollectParameters(&m_nIp, 4);
SET_FLOAT_PARAM(0, CGeneral::GetAngleBetweenPoints(GET_FLOAT_PARAM(0), GET_FLOAT_PARAM(1), GET_FLOAT_PARAM(2), GET_FLOAT_PARAM(3)));
StoreParameters(&m_nIp, 1);
return 0;
}
case COMMAND_OVERRIDE_CHAR_MOVE_ANIM:
{
CollectParameters(&m_nIp, 1);
CPed* pPed = CPools::GetPedPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pPed);
pPed->bOverrideMoveAnim = true;
return 0;
}
case COMMAND_1627:
{
CollectParameters(&m_nIp, 1);
// something related to debug menu, not implemented
return 0;
}
case COMMAND_ENABLE_EMERGENCY_VEHICLES:
{
CollectParameters(&m_nIp, 1);
gbEmergencyVehiclesEnabled = GET_INTEGER_PARAM(0) != 0;
return 0;
}
case COMMAND_ADD_UNLOCKED_COSTUME:
CollectParameters(&m_nIp, 1);
// CStats::AddUnlockedCostume(GET_INTEGER_PARAM(0));
return 0;
case COMMAND_CLEAR_MULTIPLAYER_SPLASH_SCREEN:
// ClearMultiplayerSplashScreen();
return 0;
case COMMAND_PRINT_WITH_2_NUMBERS_NOW_NO_BRIEF:
{
wchar* key = CTheScripts::GetTextByKeyFromScript(&m_nIp);
CollectParameters(&m_nIp, 4);
CMessages::AddMessageJumpQWithNumber(key, GET_INTEGER_PARAM(2), GET_INTEGER_PARAM(3), GET_INTEGER_PARAM(0), GET_INTEGER_PARAM(1), -1, -1, -1, -1); // 0
return 0;
}
case COMMAND_GET_OBJECT_ORIENTATION:
{
CollectParameters(&m_nIp, 1);
CObject* pObject = CPools::GetObjectPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pObject);
SET_FLOAT_PARAM(1, LimitAngleOnCircle(RADTODEG(Asin(pObject->GetForward().z))));
SET_FLOAT_PARAM(2, LimitAngleOnCircle(RADTODEG(Atan2(-pObject->GetForward().x, pObject->GetForward().y))));
SET_FLOAT_PARAM(0, LimitAngleOnCircle(RADTODEG(Atan2(-pObject->GetRight().z, pObject->GetUp().z))));
StoreParameters(&m_nIp, 3);
return 0;
}
case COMMAND_SET_OBJECT_ORIENTATION:
{
CollectParameters(&m_nIp, 4);
CObject* pObject = CPools::GetObjectPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pObject);
pObject->SetOrientation(DEGTORAD(GET_FLOAT_PARAM(2)), DEGTORAD(GET_FLOAT_PARAM(1)), DEGTORAD(GET_FLOAT_PARAM(3)));
return 0;
}
case COMMAND_CHANGE_ONSCREEN_COUNTER_PREFIX:
{
uint16 offset = (uint8*)GetPointerToScriptVariable(&m_nIp, VAR_GLOBAL) - CTheScripts::ScriptSpace;
CollectParameters(&m_nIp, 1);
CUserDisplay::OnscnTimer.ChangeCounterPrefix(offset, GET_INTEGER_PARAM(0) != 0);
return 0;
}
case COMMAND_STORE_PLAYER_OUTFIT:
{
char tmp[12]; // TODO
CTheScripts::ReadTextLabelFromScript(&m_nIp, tmp);
for (int i = 0; i < KEY_LENGTH_IN_SCRIPT; i++)
CGameLogic::mStoredPlayerOutfit[i] = tmp[i];
printf("STORED PLAYOUR OUTFIT : %s\n", CGameLogic::mStoredPlayerOutfit);
m_nIp += KEY_LENGTH_IN_SCRIPT;
return 0;
}
case COMMAND_DISPLAY_ONSCREEN_TIMER_WITH_NUMBER_AND_STRING:
{
char onscreen_str1[12];
uint16 var = (uint8*)GetPointerToScriptVariable(&m_nIp, 0) - CTheScripts::ScriptSpace;
CollectParameters(&m_nIp, 2);
wchar* text = TheText.Get((char*)&CTheScripts::ScriptSpace[m_nIp]);
strncpy(onscreen_str1, (char*)&CTheScripts::ScriptSpace[m_nIp], KEY_LENGTH_IN_SCRIPT);
m_nIp += KEY_LENGTH_IN_SCRIPT;
CUserDisplay::OnscnTimer.AddCounter(var, GET_INTEGER_PARAM(1), onscreen_str1, 0, GET_INTEGER_PARAM(0), nil, 0);
return 0;
}
case COMMAND_SET_PLAYER_CURRENT_WEAPON_AMMO_IN_CLIP:
{
CollectParameters(&m_nIp, 1);
CWeapon* pWeapon = FindPlayerPed()->GetWeapon();
if (pWeapon && GET_INTEGER_PARAM(0))
pWeapon->m_nAmmoInClip = GET_INTEGER_PARAM(0);
return 0;
}
case COMMAND_SET_CHAR_WAIT_STATE_REPEAT:
{
CollectParameters(&m_nIp, 3);
CPed* pPed = CPools::GetPedPool()->GetAt(GET_INTEGER_PARAM(0));
if (pPed)
pPed->SetWaitState((eWaitState)GET_INTEGER_PARAM(1), GET_INTEGER_PARAM(2) >= 0 ? &GET_INTEGER_PARAM(2) : nil, true);
return 0;
}
case COMMAND_REGISTER_BEST_TIME_GOGO_FAGGIO:
CollectParameters(&m_nIp, 1);
// CStats::RegisterBestTimeGoGoFaggio(GET_INTEGER_PARAM(0));
return 0;
case COMMAND_LOCK_GARAGE:
CollectParameters(&m_nIp, 2);
CGarages::LockGarage(GET_INTEGER_PARAM(0), GET_INTEGER_PARAM(1));
return 0;
case COMMAND_IS_FINAL_GAME:
#ifdef FINAL
UpdateCompareFlag(true);
#else
UpdateCompareFlag(false);
#endif
return 0;
case COMMAND_SET_ALLOWED_COLLISION:
{
CollectParameters(&m_nIp, 2);
CTheScripts::AllowedCollision[0] = GET_INTEGER_PARAM(0);
CTheScripts::AllowedCollision[1] = GET_INTEGER_PARAM(1);
return 0;
}
case COMMAND_REGISTER_GUARDIAN_ANGEL_LEVEL:
CollectParameters(&m_nIp, 3);
//CStats::GuardianAngelHighestLevel_Ind = Max(CStats::GuardianAngelHighestLevel_Ind, GET_INTEGER_PARAM(0));
//CStats::GuardianAngelHighestLevel_Com = Max(CStats::GuardianAngelHighestLevel_Com, GET_INTEGER_PARAM(1));
//CStats::GuardianAngelHighestLevel_Sub = Max(CStats::GuardianAngelHighestLevel_Sub, GET_INTEGER_PARAM(2));
return 0;
case COMMAND_DISPLAY_ONSCREEN_TIMER_WITH_NUMBER_AND_2_STRINGS:
{
char onscreen_str1[12];
char onscreen_str2[12];
uint16 var = (uint8*)GetPointerToScriptVariable(&m_nIp, 0) - CTheScripts::ScriptSpace;
CollectParameters(&m_nIp, 3);
wchar* text = TheText.Get((char*)&CTheScripts::ScriptSpace[m_nIp]);
strncpy(onscreen_str1, (char*)&CTheScripts::ScriptSpace[m_nIp], KEY_LENGTH_IN_SCRIPT);
m_nIp += KEY_LENGTH_IN_SCRIPT;
wchar* text2 = TheText.Get((char*)&CTheScripts::ScriptSpace[m_nIp]);
strncpy(onscreen_str2, (char*)&CTheScripts::ScriptSpace[m_nIp], KEY_LENGTH_IN_SCRIPT);
m_nIp += KEY_LENGTH_IN_SCRIPT;
CUserDisplay::OnscnTimer.AddCounter(var, GET_INTEGER_PARAM(1), onscreen_str2, 0, GET_INTEGER_PARAM(0), onscreen_str1, GET_INTEGER_PARAM(2));
return 0;
}
case COMMAND_GET_PLAYER_STORED_WEAPON:
{
CollectParameters(&m_nIp, 1);
CPed* pPed = CWorld::Players[GET_INTEGER_PARAM(0)].m_pPed;
script_assert(pPed);
SET_INTEGER_PARAM(0, pPed->m_storedWeapon);
StoreParameters(&m_nIp, 1);
return 0;
}
case COMMAND_DISABLE_PAUSE_MENU:
CollectParameters(&m_nIp, 1);
// FrontEndMenuManager.mDisablePauseMenu = GET_INTEGER_PARAM(0) != 0; // TODO: static + member
return 0;
case COMMAND_IS_CHANNEL_PLAYING:
CollectParameters(&m_nIp, 1);
//UpdateCompareFlag(DMAudio.IsChannelPlaying(GET_INTEGER_PARAM(0));
UpdateCompareFlag(false);
return 0;
case COMMAND_SET_CLOCK_EVENT_WARNING:
CollectParameters(&m_nIp, 3);
/*
if (CHud::m_ClockEventWarningMinutes || GET_INTEGER_PARAMS(2)){
CHud::m_ClockEventWarningMinutes = GET_INTEGER_PARAMS(2);
CHud::m_ClockEventMinutes = GET_INTEGER_PARAMS(1);
CHud::m_ClockEventHours = GET_INTEGER_PARAMS(0);
CHud::m_ClockEventFlashTimer = 0;
}
*/
return 0;
case COMMAND_SET_EXTRA_COLOUR_LIGHT_DIRECTION:
CollectParameters(&m_nIp, 3);
// CWeather::ExtraColourLightDir = GET_VECTOR_PARAM(0);
// CWeather::ExtraColourLightDir.Normalise();
return 0;
case COMMAND_SET_CHAR_CAN_BE_TARGETTED_BY_LEADER:
{
CollectParameters(&m_nIp, 2);
CPed* pPed = CPools::GetPedPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pPed);
pPed->bCanBeTargettedByLeader = GET_INTEGER_PARAM(1) != 0;
return 0;
}
case COMMAND_PRINT_HELP_NO_BRIEF:
{
wchar* text = CTheScripts::GetTextByKeyFromScript(&m_nIp);
CHud::SetHelpMessage(text, false); // + false, false
return 0;
}
case COMMAND_PRINT_HELP_FOREVER_NO_BRIEF:
{
wchar* text = CTheScripts::GetTextByKeyFromScript(&m_nIp);
CHud::SetHelpMessage(text, false, true); // + false
return 0;
}
case COMMAND_PRINT_HELP_ALWAYS_NO_BRIEF:
{
// CHud::mAlwaysAllowHelpText = true;
wchar* text = CTheScripts::GetTextByKeyFromScript(&m_nIp);
CHud::SetHelpMessage(text, false); // + false, false
return 0;
}
case COMMAND_PRINT_HELP_FOREVER_ALWAYS_NO_BRIEF:
{
// CHud::mAlwaysAllowHelpText = true;
wchar* text = CTheScripts::GetTextByKeyFromScript(&m_nIp);
CHud::SetHelpMessage(text, false, true); // + false
return 0;
}
case COMMAND_SET_CAR_IS_REWARD:
{
CollectParameters(&m_nIp, 2);
CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pVehicle);
pVehicle->bRewardVehicle = (GET_INTEGER_PARAM(1) != 0);
return 0;
}
case COMMAND_FREEZE_ALL_PLAYER_FOLLOWERS:
{
CollectParameters(&m_nIp, 2);
CPlayerPed* pPlayerPed = CWorld::Players[GET_INTEGER_PARAM(0)].m_pPed;
script_assert(pPlayerPed);
for (int i = 0; i < CPools::GetVehiclePool()->GetSize(); i++) {
CPed* pPed = CPools::GetPedPool()->GetSlot(i);
if (pPed && IsPedPointerValid(pPed)) {
if (pPed->m_leader == pPlayerPed || (pPed->m_objective == OBJECTIVE_FOLLOW_CHAR_IN_FORMATION && pPed->m_pedInObjective == pPlayerPed))
pPed->bIsFrozen = (GET_INTEGER_PARAM(1) != 0);
}
}
return 0;
}
default:
script_assert(0);
}
return -1;
}

2803
src/control/Script2.cpp
View file

File diff suppressed because it is too large Load diff

4693
src/control/Script3.cpp
View file

File diff suppressed because it is too large Load diff

3647
src/control/Script4.cpp
View file

File diff suppressed because it is too large Load diff

290
src/control/Script5.cpp
View file

@ -29,13 +29,13 @@ uint32 CRunningScript::CollectLocateParameters(uint32* pIp, bool b3D)
uint8 type = CTheScripts::Read1ByteFromScript(&ip);
if (type >= ARGUMENT_LOCAL) {
ip--;
id = (uint32)(uintptr)GetPointerToScriptVariable(&ip, 0);
id = (uint32)(uintptr)GetPointerToScriptVariable(&ip);
}
CollectParameters(pIp, b3D ? 7 : 5, &(ScriptParams[1]));
return id;
}
void CRunningScript::LocatePlayerCommand(int32 command, uint32* pIp)
/*void CRunningScript::LocatePlayerCommand(int32 command, uint32* pIp)
{
bool b3D, result, debug, decided = false;
float X, Y, Z, dX, dY, dZ;
@ -114,14 +114,14 @@ void CRunningScript::LocatePlayerCommand(int32 command, uint32* pIp)
UpdateCompareFlag(result);
if (debug && Abs(pos.x - X) < 80.0f && Abs(pos.y - Y) < 80.0f)
CTheScripts::HighlightImportantArea(id, X - dX, Y - dY, X + dX, Y + dY, b3D ? Z : MAP_Z_LOW_LIMIT);
/*
if (CTheScripts::DbgFlag) {
if (b3D)
CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
else
CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
}
*/
//if (CTheScripts::DbgFlag) {
// if (b3D)
// CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
// else
// CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
//}
}
void CRunningScript::LocatePlayerCharCommand(int32 command, uint32* pIp)
@ -203,14 +203,14 @@ void CRunningScript::LocatePlayerCharCommand(int32 command, uint32* pIp)
#else
CTheScripts::HighlightImportantArea((uintptr)this + m_nIp, X - dX, Y - dY, X + dX, Y + dX, b3D ? Z : MAP_Z_LOW_LIMIT);
#endif
/*
if (CTheScripts::DbgFlag) {
if (b3D)
CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
else
CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
}
*/
//if (CTheScripts::DbgFlag) {
// if (b3D)
// CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
// else
// CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
//}
}
void CRunningScript::LocatePlayerCarCommand(int32 command, uint32* pIp)
@ -282,15 +282,15 @@ void CRunningScript::LocatePlayerCarCommand(int32 command, uint32* pIp)
UpdateCompareFlag(result);
if (debug)
CTheScripts::HighlightImportantArea((uintptr)this + m_nIp, X - dX, Y - dY, X + dX, Y + dY, b3D ? Z : MAP_Z_LOW_LIMIT);
/*
if (CTheScripts::DbgFlag) {
if (b3D)
CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
else
CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
}
*/
}
//if (CTheScripts::DbgFlag) {
// if (b3D)
// CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
// else
// CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
//}
}*/
void CRunningScript::LocateCharCommand(int32 command, uint32* pIp)
{
@ -388,14 +388,14 @@ void CRunningScript::LocateCharCommand(int32 command, uint32* pIp)
UpdateCompareFlag(result);
if (debug)
CTheScripts::HighlightImportantArea(id, X - dX, Y - dY, X + dX, Y + dY, b3D ? Z : MAP_Z_LOW_LIMIT);
/*
if (CTheScripts::DbgFlag) {
if (b3D)
CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
else
CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
}
*/
//if (CTheScripts::DbgFlag) {
// if (b3D)
// CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
// else
// CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
//}
}
void CRunningScript::LocateCharCharCommand(int32 command, uint32* pIp)
@ -479,14 +479,14 @@ void CRunningScript::LocateCharCharCommand(int32 command, uint32* pIp)
#else
CTheScripts::HighlightImportantArea((uintptr)this + m_nIp, X - dX, Y - dY, X + dX, Y + dX, b3D ? Z : MAP_Z_LOW_LIMIT);
#endif
/*
if (CTheScripts::DbgFlag) {
if (b3D)
CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
else
CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
}
*/
//if (CTheScripts::DbgFlag) {
// if (b3D)
// CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
// else
// CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
//}
}
void CRunningScript::LocateCharCarCommand(int32 command, uint32* pIp)
@ -559,14 +559,14 @@ void CRunningScript::LocateCharCarCommand(int32 command, uint32* pIp)
UpdateCompareFlag(result);
if (debug)
CTheScripts::HighlightImportantArea((uintptr)this + m_nIp, X - dX, Y - dY, X + dX, Y + dY, b3D ? Z : MAP_Z_LOW_LIMIT);
/*
if (CTheScripts::DbgFlag) {
if (b3D)
CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
else
CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
}
*/
//if (CTheScripts::DbgFlag) {
// if (b3D)
// CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
// else
// CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
//}
}
void CRunningScript::LocateCharObjectCommand(int32 command, uint32* pIp)
@ -639,14 +639,14 @@ void CRunningScript::LocateCharObjectCommand(int32 command, uint32* pIp)
UpdateCompareFlag(result);
if (debug)
CTheScripts::HighlightImportantArea((uintptr)this + m_nIp, X - dX, Y - dY, X + dX, Y + dY, b3D ? Z : MAP_Z_LOW_LIMIT);
/*
if (CTheScripts::DbgFlag) {
if (b3D)
CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
else
CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
}
*/
//if (CTheScripts::DbgFlag) {
// if (b3D)
// CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
// else
// CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
//}
}
void CRunningScript::LocateCarCommand(int32 command, uint32* pIp)
@ -713,14 +713,14 @@ void CRunningScript::LocateCarCommand(int32 command, uint32* pIp)
UpdateCompareFlag(result);
if (debug)
CTheScripts::HighlightImportantArea(id, X - dX, Y - dY, X + dX, Y + dY, b3D ? Z : MAP_Z_LOW_LIMIT);
/*
if (CTheScripts::DbgFlag) {
if (b3D)
CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
else
CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
}
*/
//if (CTheScripts::DbgFlag) {
// if (b3D)
// CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
// else
// CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
//}
}
void CRunningScript::LocateObjectCommand(int32 command, uint32* pIp)
@ -773,28 +773,28 @@ void CRunningScript::LocateObjectCommand(int32 command, uint32* pIp)
UpdateCompareFlag(result);
if (debug)
CTheScripts::HighlightImportantArea(id, X - dX, Y - dY, X + dX, Y + dY, b3D ? Z : MAP_Z_LOW_LIMIT);
/*
if (CTheScripts::DbgFlag) {
if (b3D)
CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
else
CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
}
*/
//if (CTheScripts::DbgFlag) {
// if (b3D)
// CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
// else
// CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
//}
}
void CRunningScript::LocateSniperBulletCommand(int32 command, uint32* pIp)
{
bool b3D, result, debug;
float X, Y, Z, dX, dY, dZ;
switch (command) {
/*switch (command) { // vcs tmp TODO:----------------------------------------------
case COMMAND_LOCATE_SNIPER_BULLET_3D:
b3D = true;
break;
default:
b3D = false;
break;
}
}*/
CollectParameters(pIp, b3D ? 7 : 5);
X = GET_FLOAT_PARAM(0);
Y = GET_FLOAT_PARAM(1);
@ -814,17 +814,17 @@ void CRunningScript::LocateSniperBulletCommand(int32 command, uint32* pIp)
UpdateCompareFlag(result);
if (debug)
CTheScripts::HighlightImportantArea((uintptr)this + m_nIp, X - dX, Y - dY, X + dX, Y + dY, b3D ? Z : MAP_Z_LOW_LIMIT);
/*
if (CTheScripts::DbgFlag) {
if (b3D)
CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
else
CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
}
*/
//if (CTheScripts::DbgFlag) {
// if (b3D)
// CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
// else
// CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
//}
}
void CRunningScript::PlayerInAreaCheckCommand(int32 command, uint32* pIp)
/*void CRunningScript::PlayerInAreaCheckCommand(int32 command, uint32* pIp)
{
bool b3D, result, debug, decided = false;
float infX, infY, infZ, supX, supY, supZ;
@ -933,14 +933,14 @@ void CRunningScript::PlayerInAreaCheckCommand(int32 command, uint32* pIp)
UpdateCompareFlag(result);
if (debug)
CTheScripts::HighlightImportantArea((uintptr)this + m_nIp, infX, infY, supX, supY, b3D ? (infZ + supZ) / 2 : MAP_Z_LOW_LIMIT);
/*
if (CTheScripts::DbgFlag) {
if (b3D)
CTheScripts::DrawDebugCube(infX, infY, infZ, supX, supY, supZ);
else
CTheScripts::DrawDebugSquare(infX, infY, supX, supY);
}
*/
//if (CTheScripts::DbgFlag) {
// if (b3D)
// CTheScripts::DrawDebugCube(infX, infY, infZ, supX, supY, supZ);
// else
// CTheScripts::DrawDebugSquare(infX, infY, supX, supY);
//}
}
void CRunningScript::PlayerInAngledAreaCheckCommand(int32 command, uint32* pIp)
@ -1058,17 +1058,17 @@ void CRunningScript::PlayerInAngledAreaCheckCommand(int32 command, uint32* pIp)
if (debug)
CTheScripts::HighlightImportantAngledArea((uintptr)this + m_nIp, infX, infY, supX, supY,
rotatedSupX, rotatedSupY, rotatedInfX, rotatedInfY, b3D ? (infZ + supZ) / 2 : MAP_Z_LOW_LIMIT);
/*
if (CTheScripts::DbgFlag) {
if (b3D)
CTheScripts::DrawDebugAngledCube(infX, infY, infZ, supX, supY, supZ,
rotatedSupX, rotatedSupY, rotatedInfX, rotatedInfY);
else
CTheScripts::DrawDebugAngledSquare(infX, infY, supX, supY,
rotatedSupX, rotatedSupY, rotatedInfX, rotatedInfY);
}
*/
}
//if (CTheScripts::DbgFlag) {
// if (b3D)
// CTheScripts::DrawDebugAngledCube(infX, infY, infZ, supX, supY, supZ,
// rotatedSupX, rotatedSupY, rotatedInfX, rotatedInfY);
// else
// CTheScripts::DrawDebugAngledSquare(infX, infY, supX, supY,
// rotatedSupX, rotatedSupY, rotatedInfX, rotatedInfY);
//}
}*/
void CRunningScript::CharInAreaCheckCommand(int32 command, uint32* pIp)
{
@ -1528,14 +1528,14 @@ void CRunningScript::LocateCollectiveCommand(int32 command, uint32* pIp)
UpdateCompareFlag(result);
if (debug)
CTheScripts::HighlightImportantArea(id, X - dX, Y - dY, X + dX, Y + dY, b3D ? Z : MAP_Z_LOW_LIMIT);
/*
if (CTheScripts::DbgFlag) {
if (b3D)
CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
else
CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
}
*/
//if (CTheScripts::DbgFlag) {
// if (b3D)
// CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
// else
// CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
//}
}
void CRunningScript::LocateCollectiveCharCommand(int32 command, uint32* pIp)
@ -1621,14 +1621,14 @@ void CRunningScript::LocateCollectiveCharCommand(int32 command, uint32* pIp)
UpdateCompareFlag(result);
if (debug)
CTheScripts::HighlightImportantArea((uintptr)this + m_nIp, X - dX, Y - dY, X + dX, Y + dY, b3D ? Z : MAP_Z_LOW_LIMIT);
/*
if (CTheScripts::DbgFlag) {
if (b3D)
CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
else
CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
}
*/
//if (CTheScripts::DbgFlag) {
// if (b3D)
// CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
// else
// CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
//}
}
void CRunningScript::LocateCollectiveCarCommand(int32 command, uint32* pIp)
@ -1707,14 +1707,14 @@ void CRunningScript::LocateCollectiveCarCommand(int32 command, uint32* pIp)
UpdateCompareFlag(result);
if (debug)
CTheScripts::HighlightImportantArea((uintptr)this + m_nIp, X - dX, Y - dY, X + dX, Y + dY, b3D ? Z : MAP_Z_LOW_LIMIT);
/*
if (CTheScripts::DbgFlag) {
if (b3D)
CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
else
CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
}
*/
//if (CTheScripts::DbgFlag) {
// if (b3D)
// CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
// else
// CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
//}
}
void CRunningScript::LocateCollectivePlayerCommand(int32 command, uint32* pIp)
@ -1792,14 +1792,14 @@ void CRunningScript::LocateCollectivePlayerCommand(int32 command, uint32* pIp)
UpdateCompareFlag(result);
if (debug)
CTheScripts::HighlightImportantArea((uintptr)this + m_nIp, X - dX, Y - dY, X + dX, Y + dY, b3D ? Z : MAP_Z_LOW_LIMIT);
/*
if (CTheScripts::DbgFlag) {
if (b3D)
CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
else
CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
}
*/
//if (CTheScripts::DbgFlag) {
// if (b3D)
// CTheScripts::DrawDebugCube(X - dX, Y - dY, Z - dZ, X + dX, Y + dY, Z + dZ);
// else
// CTheScripts::DrawDebugSquare(X - dX, Y - dY, X + dX, Y + dY);
//}
}
void CRunningScript::CollectiveInAreaCheckCommand(int32 command, uint32* pIp)
@ -1912,14 +1912,14 @@ void CRunningScript::CollectiveInAreaCheckCommand(int32 command, uint32* pIp)
UpdateCompareFlag(result);
if (debug)
CTheScripts::HighlightImportantArea((uintptr)this + m_nIp, infX, infY, supX, supY, b3D ? (infZ + supZ) / 2 : MAP_Z_LOW_LIMIT);
/*
if (CTheScripts::DbgFlag) {
if (b3D)
CTheScripts::DrawDebugCube(infX, infY, infZ, supX, supY, supZ);
else
CTheScripts::DrawDebugSquare(infX, infY, supX, supY);
}
*/
//if (CTheScripts::DbgFlag) {
// if (b3D)
// CTheScripts::DrawDebugCube(infX, infY, infZ, supX, supY, supZ);
// else
// CTheScripts::DrawDebugSquare(infX, infY, supX, supY);
//}
}
#endif

2411
src/control/Script6.cpp
View file

File diff suppressed because it is too large Load diff

2234
src/control/Script7.cpp
View file

File diff suppressed because it is too large Load diff

780
src/control/Script8.cpp
View file

@ -27,783 +27,5 @@
#include "World.h"
#include "Zones.h"
// LCS: file done except TODOs (also check commented out strings)
int8 CRunningScript::ProcessCommands1400To1499(int32 command)
{
switch (command) {
case COMMAND_REGISTER_VIGILANTE_LEVEL:
CollectParameters(&m_nIp, 1);
CStats::RegisterLevelVigilanteMission(GET_INTEGER_PARAM(0));
return 0;
case COMMAND_CLEAR_ALL_CHAR_ANIMS:
{
CollectParameters(&m_nIp, 1);
CPed* pPed = CPools::GetPedPool()->GetAt(GET_INTEGER_PARAM(0));
if (pPed && pPed->GetPedState() != PED_DRIVING && pPed->GetPedState() != PED_AIM_GUN) {
pPed->m_pVehicleAnim = nil;
pPed->RestartNonPartialAnims();
RpAnimBlendClumpRemoveAllAssociations(pPed->GetClump());
pPed->SetPedState(PED_IDLE);
pPed->SetMoveState(PEDMOVE_STILL);
pPed->m_nLastPedState = PED_NONE;
pPed->ClearAimFlag();
pPed->ClearLookFlag();
pPed->bIsPointingGunAt = false;
if (pPed->IsPlayer())
((CPlayerPed*)pPed)->m_fMoveSpeed = 0.0f;
else
pPed->m_nStoredMoveState = PEDMOVE_STILL;
CAnimManager::AddAnimation(pPed->GetClump(), pPed->m_animGroup, ANIM_STD_IDLE);
pPed->bIsPedDieAnimPlaying = false;
}
return 0;
}
case COMMAND_SET_MAXIMUM_NUMBER_OF_CARS_IN_GARAGE:
CollectParameters(&m_nIp, 2);
CGarages::SetMaxNumStoredCarsForGarage(GET_INTEGER_PARAM(0), GET_INTEGER_PARAM(1));
return 0;
case COMMAND_WANTED_STARS_ARE_FLASHING:
{
CWanted* pWanted = CWorld::Players[CWorld::PlayerInFocus].m_pPed->m_pWanted;
UpdateCompareFlag(pWanted->m_nMinWantedLevel - pWanted->GetWantedLevel() > 0);
return 0;
}
case COMMAND_SET_ALLOW_HURRICANES:
CollectParameters(&m_nIp, 1);
CStats::NoMoreHurricanes = GET_INTEGER_PARAM(0);
return 0;
case COMMAND_PLAY_ANNOUNCEMENT:
{
CollectParameters(&m_nIp, 1);
DMAudio.PlayRadioAnnouncement(GET_INTEGER_PARAM(0) + STREAMED_SOUND_NEWS_A);
return 0;
}
case COMMAND_SET_PLAYER_IS_IN_STADIUM:
{
CollectParameters(&m_nIp, 1);
CTheScripts::bPlayerIsInTheStatium = GET_INTEGER_PARAM(0);
return 0;
}
case COMMAND_GET_BUS_FARES_COLLECTED_BY_PLAYER:
{
CollectParameters(&m_nIp, 1);
CPlayerInfo* pPlayerInfo = &CWorld::Players[GET_INTEGER_PARAM(0)];
SET_INTEGER_PARAM(0, pPlayerInfo->m_pPed->m_nLastBusFareCollected);
pPlayerInfo->m_pPed->m_nLastBusFareCollected = 0;
StoreParameters(&m_nIp, 1);
return 0;
}
case COMMAND_SET_CHAR_OBJ_BUY_ICE_CREAM:
{
CollectParameters(&m_nIp, 2);
CPed* pPed = CPools::GetPedPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pPed);
CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(GET_INTEGER_PARAM(1));
script_assert(pVehicle);
SET_INTEGER_PARAM(0, 0);
if (pPed->m_objective == OBJECTIVE_NONE && !pPed->bHasAlreadyUsedAttractor) {
C2dEffect* pEffect = (C2dEffect*)GetPedAttractorManager()->GetEffectForIceCreamVan(pVehicle, pPed->GetPosition()); // has to be casted, because inner methods are const
if (pEffect) {
CVector pos;
CPedAttractorManager::ComputeEffectPos(pEffect, pVehicle->GetMatrix(), pos);
if ((pPed->GetPosition() - pos).MagnitudeSqr() < SQR(20.0f)) {
if (GetPedAttractorManager()->HasEmptySlot(pEffect) && GetPedAttractorManager()->IsApproachable(pEffect, pVehicle->GetMatrix(), 0, pPed)) {
if (GetPedAttractorManager()->RegisterPedWithAttractor(pPed, pEffect, pVehicle->GetMatrix()))
SET_INTEGER_PARAM(0, 1);
}
}
}
}
StoreParameters(&m_nIp, 1);
return 0;
}
case COMMAND_DISPLAY_RADAR:
CollectParameters(&m_nIp, 1);
CHud::m_HideRadar = GET_INTEGER_PARAM(0) == 0;
// on PS2 two flags are set, on mobile none
return 0;
case COMMAND_REGISTER_BEST_POSITION:
CollectParameters(&m_nIp, 2);
CStats::RegisterBestPosition(GET_INTEGER_PARAM(0), GET_INTEGER_PARAM(1));
return 0;
case COMMAND_IS_PLAYER_IN_INFO_ZONE:
{
CollectParameters(&m_nIp, 1);
CPlayerInfo* pPlayerInfo = &CWorld::Players[GET_INTEGER_PARAM(0)];
char key[KEY_LENGTH_IN_SCRIPT];
memset(key, 0, KEY_LENGTH_IN_SCRIPT);
CTheScripts::ReadTextLabelFromScript(&m_nIp, key);
m_nIp += KEY_LENGTH_IN_SCRIPT;
CVector pos = pPlayerInfo->GetPos();
CZone* infoZone = CTheZones::FindInformationZoneForPosition(&pos);
UpdateCompareFlag(strncmp(key, infoZone->name, 8) == 0); // original code doesn't seem to be using strncmp in here and compare 2 ints instead
return 0;
}
case COMMAND_CLEAR_CHAR_ICE_CREAM_PURCHASE:
{
CollectParameters(&m_nIp, 1);
CPed* pPed = CPools::GetPedPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pPed);
if (pPed->m_attractor)
GetPedAttractorManager()->DeRegisterPed(pPed, pPed->m_attractor);
return 0;
}
case COMMAND_IS_IN_CAR_FIRE_BUTTON_PRESSED:
UpdateCompareFlag(CPad::GetPad(0)->GetCarGunFired());
return 0;
case COMMAND_HAS_CHAR_ATTEMPTED_ATTRACTOR:
{
CollectParameters(&m_nIp, 1);
CPed* pPed = CPools::GetPedPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pPed);
UpdateCompareFlag(pPed->bHasAlreadyUsedAttractor);
return 0;
}
case COMMAND_SET_LOAD_COLLISION_FOR_CAR_FLAG:
{
CollectParameters(&m_nIp, 2);
CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pVehicle);
if (GET_INTEGER_PARAM(1)) {
pVehicle->bDontLoadCollision = false;
if (m_bMissionFlag) {
CWorld::Remove(pVehicle);
pVehicle->bIsStaticWaitingForCollision = true;
CWorld::Add(pVehicle);
}
}
else {
pVehicle->bDontLoadCollision = true;
if (pVehicle->bIsStaticWaitingForCollision) {
pVehicle->bIsStaticWaitingForCollision = false;
if (!pVehicle->GetIsStatic())
pVehicle->AddToMovingList();
}
}
return 0;
}
case COMMAND_SET_LOAD_COLLISION_FOR_CHAR_FLAG:
{
CollectParameters(&m_nIp, 2);
CPed* pPed = CPools::GetPedPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pPed);
if (GET_INTEGER_PARAM(1)) {
pPed->bDontLoadCollision = false;
if (m_bMissionFlag) {
CWorld::Remove(pPed);
pPed->bIsStaticWaitingForCollision = true;
CWorld::Add(pPed);
}
}
else {
pPed->bDontLoadCollision = true;
if (pPed->bIsStaticWaitingForCollision) {
pPed->bIsStaticWaitingForCollision = false;
if (!pPed->GetIsStatic())
pPed->AddToMovingList();
}
}
return 0;
}
//case COMMAND_SET_LOAD_COLLISION_FOR_OBJECT_FLAG:
case COMMAND_ADD_BIG_GUN_FLASH:
{
CollectParameters(&m_nIp, 6);
CWeapon::AddGunFlashBigGuns(GET_VECTOR_PARAM(0), GET_VECTOR_PARAM(3));
return 0;
}
case COMMAND_HAS_CHAR_BOUGHT_ICE_CREAM:
{
CollectParameters(&m_nIp, 1);
CPed* pPed = CPools::GetPedPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pPed);
UpdateCompareFlag(pPed->bBoughtIceCream);
return 0;
}
case COMMAND_GET_PROGRESS_PERCENTAGE:
SET_FLOAT_PARAM(0, CStats::GetPercentageProgress());
StoreParameters(&m_nIp, 1);
return 0;
case COMMAND_SET_SHORTCUT_PICKUP_POINT:
{
CollectParameters(&m_nIp, 4);
CGameLogic::AddShortCutPointAfterDeath(GET_VECTOR_PARAM(0), GET_FLOAT_PARAM(3));
return 0;
}
case COMMAND_SET_SHORTCUT_DROPOFF_POINT_FOR_MISSION:
{
CollectParameters(&m_nIp, 4);
CGameLogic::AddShortCutDropOffPointForMission(GET_VECTOR_PARAM(0), GET_FLOAT_PARAM(3));
return 0;
}
case COMMAND_GET_RANDOM_ICE_CREAM_CUSTOMER_IN_AREA:
{
CollectParameters(&m_nIp, 7);
int ped_handle = -1;
CVector pos = FindPlayerCoors();
float x1 = GET_FLOAT_PARAM(0);
float y1 = GET_FLOAT_PARAM(1);
float x2 = GET_FLOAT_PARAM(2);
float y2 = GET_FLOAT_PARAM(3);
int i = CPools::GetPedPool()->GetSize();
while (--i && ped_handle == -1) {
CPed* pPed = CPools::GetPedPool()->GetSlot(i);
if (!pPed)
continue;
if (CTheScripts::LastRandomPedId == CPools::GetPedPool()->GetIndex(pPed))
continue;
if (pPed->CharCreatedBy != RANDOM_CHAR)
continue;
if (!pPed->IsPedInControl())
continue;
if (pPed->bRemoveFromWorld)
continue;
if (pPed->bFadeOut)
continue;
if (pPed->m_nWaitState != WAITSTATE_FALSE)
continue;
if (pPed->bHasAlreadyUsedAttractor)
continue;
if (pPed->m_attractor)
continue;
if (!ThisIsAValidRandomPed(pPed->m_nPedType, GET_INTEGER_PARAM(4), GET_INTEGER_PARAM(5), GET_INTEGER_PARAM(6)))
continue;
if (pPed->bIsLeader || pPed->m_leader)
continue;
if (!pPed->IsWithinArea(x1, y1, x2, y2))
continue;
if (pos.z - PED_FIND_Z_OFFSET > pPed->GetPosition().z)
continue;
if (pos.z + PED_FIND_Z_OFFSET < pPed->GetPosition().z)
continue;
ped_handle = CPools::GetPedPool()->GetIndex(pPed);
CTheScripts::LastRandomPedId = ped_handle;
pPed->CharCreatedBy = MISSION_CHAR;
pPed->bRespondsToThreats = false;
++CPopulation::ms_nTotalMissionPeds;
if (m_bIsMissionScript)
CTheScripts::MissionCleanUp.AddEntityToList(ped_handle, CLEANUP_CHAR);
}
SET_INTEGER_PARAM(0, ped_handle);
StoreParameters(&m_nIp, 1);
return 0;
}
//case COMMAND_GET_RANDOM_ICE_CREAM_CUSTOMER_IN_ZONE:
case COMMAND_UNLOCK_ALL_CAR_DOORS_IN_AREA:
{
CollectParameters(&m_nIp, 4);
uint32 i = CPools::GetVehiclePool()->GetSize();
float infX = GET_FLOAT_PARAM(0);
float infY = GET_FLOAT_PARAM(1);
float supX = GET_FLOAT_PARAM(2);
float supY = GET_FLOAT_PARAM(3);
while (i--) {
CVehicle* pVehicle = CPools::GetVehiclePool()->GetSlot(i);
if (!pVehicle)
continue;
if (pVehicle->IsWithinArea(infX, infY, supX, supY))
pVehicle->m_nDoorLock = CARLOCK_UNLOCKED;
}
return 0;
}
case COMMAND_SET_GANG_ATTACK_PLAYER_WITH_COPS:
CollectParameters(&m_nIp, 2);
CGangs::SetWillAttackPlayerWithCops((ePedType)((int)PEDTYPE_GANG1 + GET_INTEGER_PARAM(0)), !!GET_INTEGER_PARAM(1));
return 0;
case COMMAND_SET_CHAR_FRIGHTENED_IN_JACKED_CAR:
{
CollectParameters(&m_nIp, 2);
CPed* pPed = CPools::GetPedPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pPed);
pPed->bHeldHostageInCar = GET_INTEGER_PARAM(1);
pPed->b1A4_2 = GET_INTEGER_PARAM(1);
return 0;
}
case COMMAND_SET_VEHICLE_TO_FADE_IN:
{
CollectParameters(&m_nIp, 2);
CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pVehicle);
CVisibilityPlugins::SetClumpAlpha(pVehicle->GetClump(), GET_INTEGER_PARAM(1));
return 0;
}
case COMMAND_REGISTER_ODDJOB_MISSION_PASSED:
++CStats::MissionsPassed;
CStats::CheckPointReachedSuccessfully();
CTheScripts::LastMissionPassedTime = CTimer::GetTimeInMilliseconds();
CGameLogic::RemoveShortCutDropOffPointForMission();
return 0;
case COMMAND_IS_PLAYER_IN_SHORTCUT_TAXI:
{
CollectParameters(&m_nIp, 1);
CPed* pPed = CWorld::Players[GET_INTEGER_PARAM(0)].m_pPed;
script_assert(pPed);
UpdateCompareFlag(pPed->bInVehicle && pPed->m_pMyVehicle && pPed->m_pMyVehicle == CGameLogic::pShortCutTaxi);
return 0;
}
case COMMAND_IS_CHAR_DUCKING:
{
CollectParameters(&m_nIp, 1);
CPed* pPed = CPools::GetPedPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pPed);
UpdateCompareFlag(RpAnimBlendClumpGetAssociation(pPed->GetClump(), ANIM_STD_DUCK_DOWN) != nil);
return 0;
}
case COMMAND_CREATE_DUST_EFFECT_FOR_CUTSCENE_HELI:
{
CollectParameters(&m_nIp, 3);
CObject* pHeli = CPools::GetObjectPool()->GetAt(GET_INTEGER_PARAM(0));
bool found = false;
float waterLevel = -1000.0f;
CVector pos = pHeli->GetPosition();
float radius = GET_FLOAT_PARAM(1);
float ground = CWorld::FindGroundZFor3DCoord(pos.x, pos.y, pos.z, &found);
if (!CWaterLevel::GetWaterLevel(pos.x, pos.y, pos.z, &waterLevel, false))
waterLevel = 0.0f;
if (waterLevel > ground)
ground = waterLevel;
if (GET_INTEGER_PARAM(2) > 8)
SET_INTEGER_PARAM(2, 8);
CVehicle::HeliDustGenerate(pHeli, (pos.z - ground - 1.0f - radius) * 0.3 + radius, ground, GET_INTEGER_PARAM(2));
return 0;
}
case COMMAND_REGISTER_FIRE_LEVEL:
CollectParameters(&m_nIp, 1);
CStats::RegisterLevelFireMission(GET_INTEGER_PARAM(0));
return 0;
case COMMAND_IS_AUSTRALIAN_GAME:
UpdateCompareFlag(false); // should we make some check?
return 0;
case COMMAND_DISARM_CAR_BOMB:
{
CollectParameters(&m_nIp, 1);
CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(GET_INTEGER_PARAM(0));
if (pVehicle->IsCar()) {
if (((CAutomobile*)pVehicle)->m_bombType != CARBOMB_NONE) {
((CAutomobile*)pVehicle)->m_bombType = CARBOMB_NONE;
((CAutomobile*)pVehicle)->m_pBombRigger = nil;
}
}
#ifdef FIX_BUGS
else if (pVehicle->IsBike()) {
if (((CBike*)pVehicle)->m_bombType != CARBOMB_NONE) {
((CBike*)pVehicle)->m_bombType = CARBOMB_NONE;
((CBike*)pVehicle)->m_pBombRigger = nil;
}
}
#endif
return 0;
}
case COMMAND_IS_JAPANESE_GAME:
#ifdef MORE_LANGUAGES
UpdateCompareFlag(FrontEndMenuManager.m_PrefsLanguage == CMenuManager::LANGUAGE_JAPANESE);
#elif (defined GTAVC_JP_PATCH)
UpdateCompareFlag(true);
#else
UpdateCompareFlag(false);
#endif
return 0;
case COMMAND_1442:
CollectParameters(&m_nIp, 4);
return 0;
//case COMMAND_1443:
case COMMAND_GET_DISTANCE_BETWEEN_2D_POINTS:
{
CollectParameters(&m_nIp, 4);
float X1 = GET_FLOAT_PARAM(0);
float Y1 = GET_FLOAT_PARAM(1);
float X2 = GET_FLOAT_PARAM(2);
float Y2 = GET_FLOAT_PARAM(3);
float fDistance = Sqrt((X1 - X2) * (X1 - X2) + (Y1 - Y2) * (Y1 - Y2));
SET_FLOAT_PARAM(0, fDistance);
StoreParameters(&m_nIp, 1);
return 0;
}
case COMMAND_GET_DISTANCE_BETWEEN_3D_POINTS:
{
CollectParameters(&m_nIp, 6);
float X1 = GET_FLOAT_PARAM(0);
float Y1 = GET_FLOAT_PARAM(1);
float Z1 = GET_FLOAT_PARAM(2);
float X2 = GET_FLOAT_PARAM(3);
float Y2 = GET_FLOAT_PARAM(4);
float Z2 = GET_FLOAT_PARAM(5);
float fDistance = Sqrt((X1 - X2) * (X1 - X2) + (Y1 - Y2) * (Y1 - Y2) + (Z1 - Z2) * (Z1 - Z2));
SET_FLOAT_PARAM(0, fDistance);
StoreParameters(&m_nIp, 1);
return 0;
}
case COMMAND_DOT_PRODUCT_2D:
{
CollectParameters(&m_nIp, 4);
float X1 = GET_FLOAT_PARAM(0);
float Y1 = GET_FLOAT_PARAM(1);
float X2 = GET_FLOAT_PARAM(2);
float Y2 = GET_FLOAT_PARAM(3);
float fDistance = X1 * X2 + Y1 * Y2;
SET_FLOAT_PARAM(0, fDistance);
StoreParameters(&m_nIp, 1);
return 0;
}
case COMMAND_DOT_PRODUCT_3D:
{
CollectParameters(&m_nIp, 6);
float X1 = GET_FLOAT_PARAM(0);
float Y1 = GET_FLOAT_PARAM(1);
float Z1 = GET_FLOAT_PARAM(2);
float X2 = GET_FLOAT_PARAM(3);
float Y2 = GET_FLOAT_PARAM(4);
float Z2 = GET_FLOAT_PARAM(5);
float fDistance = X1 * X2 + Y1 * Y2 + Z1 * Z2;
SET_FLOAT_PARAM(0, fDistance);
StoreParameters(&m_nIp, 1);
return 0;
}
case COMMAND_DEBUG_PRINT_WITH_1_FLOAT:
return 0;
case COMMAND_DEBUG_PRINT_WITH_2_FLOATS:
return 0;
case COMMAND_DEBUG_PRINT_WITH_3_FLOATS:
return 0;
case COMMAND_GET_PAD_BUTTON_STATE:
{
CollectParameters(&m_nIp, 1);
switch (GET_INTEGER_PARAM(0)) {
case 0: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GetOddJobTrigger()); break;
case 1: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GetBrake()); break;
case 2: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GetSteeringLeftRight()); break;
case 3: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GetSteeringUpDown()); break;
case 4: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GetCarGunLeftRight()); break;
case 5: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GetCarGunUpDown()); break;
case 6: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GetPedWalkLeftRight()); break;
case 7: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GetPedWalkUpDown()); break;
case 8: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GetLookLeft()); break;
case 9: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GetLookRight()); break;
case 10: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GetLookBehindForCar()); break;
case 11: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GetLookBehindForPed()); break;
case 12: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GetHorn()); break;
case 13: SET_INTEGER_PARAM(0, CPad::GetPad(0)->HornJustDown()); break;
case 14: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GetCarGunFired()); break;
case 15: SET_INTEGER_PARAM(0, CPad::GetPad(0)->CarGunJustDown()); break;
case 16: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GetHandBrake()); break;
case 17: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GetBrake()); break;
case 18: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GetExitVehicle()); break;
case 19: SET_INTEGER_PARAM(0, CPad::GetPad(0)->ExitVehicleJustDown()); break;
case 20: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GetWeapon()); break;
case 21: SET_INTEGER_PARAM(0, CPad::GetPad(0)->WeaponJustDown()); break;
case 22: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GetAccelerate()); break;
case 23: SET_INTEGER_PARAM(0, CPad::GetPad(0)->CycleCameraModeUpJustDown()); break;
case 24: SET_INTEGER_PARAM(0, CPad::GetPad(0)->CycleWeaponLeftJustDown()); break;
case 25: SET_INTEGER_PARAM(0, CPad::GetPad(0)->CycleWeaponRightJustDown()); break;
case 26: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GetTarget()); break;
case 27: SET_INTEGER_PARAM(0, CPad::GetPad(0)->TargetJustDown()); break;
case 28: SET_INTEGER_PARAM(0, CPad::GetPad(0)->JumpJustDown()); break;
case 29: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GetSprint()); break;
case 30: SET_INTEGER_PARAM(0, CPad::GetPad(0)->ShiftTargetLeftJustDown()); break;
case 31: SET_INTEGER_PARAM(0, CPad::GetPad(0)->ForceCameraBehindPlayer()); break;
case 32: SET_INTEGER_PARAM(0, CPad::GetPad(0)->SniperZoomIn()); break;
case 33: SET_INTEGER_PARAM(0, CPad::GetPad(0)->SniperZoomOut()); break;
case 34: SET_INTEGER_PARAM(0, CPad::GetPad(0)->SniperModeLookLeftRight()); break;
case 35: SET_INTEGER_PARAM(0, CPad::GetPad(0)->SniperModeLookUpDown()); break;
case 36: SET_INTEGER_PARAM(0, CPad::GetPad(0)->LookAroundLeftRight()); break;
case 37: SET_INTEGER_PARAM(0, CPad::GetPad(0)->LookAroundUpDown()); break;
case 38: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GuiLeft()); break;
case 39: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GuiRight()); break;
case 40: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GuiUp()); break;
case 41: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GuiDown()); break;
case 42: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GuiSelect()); break;
case 43: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GuiBack()); break;
case 44: SET_INTEGER_PARAM(0, CPad::GetPad(0)->GetSkipCutscene()); if (GET_INTEGER_PARAM(0)) TheCamera.m_bIgnoreFadingStuffForMusic = false; break; // spectacular hack
}
StoreParameters(&m_nIp, 1);
return 0;
}
case COMMAND_SET_NAVIGATION_ARROW:
{
CollectParameters(&m_nIp, 3);
// cNavArrow::SetTarget(GET_FLOAT_PARAM(0), GET_FLOAT_PARAM(0), GET_FLOAT_PARAM(0)); // TODO, although it's unused
return 0;
}
case COMMAND_CLEAR_NAVIGATION_ARROW:
{
// cNavArrow::ClearTarget(); // TODO, although it's unused
return 0;
}
case COMMAND_CALL:
case COMMAND_CALLNOT:
{
m_anStack[m_nStackPointer++] = m_nIp | BIT(STACKVALUE_IS_FUNCTION_CALL_BIT) | ((command == COMMAND_CALLNOT) ? BIT(STACKVALUE_INVERT_RETURN_BIT) : 0);
uint8 nInputParams = CTheScripts::Read1ByteFromScript(&m_nIp);
uint8 nOutputParameters = CTheScripts::Read1ByteFromScript(&m_nIp);
uint8 nLocalsOffset = CTheScripts::Read1ByteFromScript(&m_nIp);
uint32 nIPBeforeParameters = m_nIp;
CollectParameters(&m_nIp, 1);
if (nInputParams)
CollectParameters(&m_nIp, nInputParams, &m_anLocalVariables[m_nLocalsPointer + nLocalsOffset]);
m_nLocalsPointer += nLocalsOffset;
m_anStack[m_nStackPointer - 1] |= (m_nIp - nIPBeforeParameters) << STACKVALUE_IP_PARAMS_OFFSET;
if (GET_INTEGER_PARAM(0) < 0)
m_nIp = CTheScripts::MainScriptSize - GET_INTEGER_PARAM(0);
else
m_nIp = GET_INTEGER_PARAM(0);
return 0;
}
case COMMAND_IS_CAR_AUTOMOBILE:
{
CollectParameters(&m_nIp, 1);
CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pVehicle);
UpdateCompareFlag(pVehicle->GetModelIndex() >= MI_FIRST_VEHICLE && pVehicle->GetModelIndex() < MI_FERRY);
return 0;
}
case COMMAND_IS_CAR_BIKE:
{
CollectParameters(&m_nIp, 1);
CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pVehicle);
UpdateCompareFlag(pVehicle->GetModelIndex() >= MI_ANGEL && pVehicle->GetModelIndex() <= MI_SANCHEZ);
return 0;
}
return 0;
case COMMAND_IS_CAR_PLANE:
{
CollectParameters(&m_nIp, 1);
CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pVehicle);
UpdateCompareFlag(pVehicle->GetModelIndex() >= MI_AIRTRAIN && pVehicle->GetModelIndex() <= MI_DEADDODO);
return 0;
}
case COMMAND_IS_CAR_HELI:
{
CollectParameters(&m_nIp, 1);
CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pVehicle);
UpdateCompareFlag(pVehicle->GetModelIndex() >= MI_ESCAPE && pVehicle->GetModelIndex() <= MI_CHOPPER);
return 0;
}
#ifdef FIX_BUGS
case COMMAND_1476: // they DO have it in script
return 0;
#endif
case COMMAND_RETURN_IF_TRUE:
if (m_bCondResult) {
ReturnFromGosubOrFunction();
}
return 0;
case COMMAND_RETURN_TRUE_IF_TRUE:
if (m_bCondResult) {
UpdateCompareFlag(false);
ReturnFromGosubOrFunction();
}
return 0;
case COMMAND_SET_CHAR_ONLY_ALLOWED_TO_SIT_BEHIND:
{
CollectParameters(&m_nIp, 2);
CPed* pPed = CPools::GetPedPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pPed);
pPed->bOnlyAllowedToSitBehind = GET_INTEGER_PARAM(1);
return 0;
}
case COMMAND_SET_RC_HELI_HEIGHT_LIMIT:
CollectParameters(&m_nIp, 1);
CVehicle::rcHeliHeightLimit = GET_FLOAT_PARAM(0);
return 0;
case COMMAND_CREATE_SCRIPT_CORONA:
{
CollectParameters(&m_nIp, 9);
base::cSList<script_corona>::tSItem* pCorona = new base::cSList<script_corona>::tSItem();
pCorona->item.x = GET_FLOAT_PARAM(0);
pCorona->item.y = GET_FLOAT_PARAM(1);
pCorona->item.z = GET_FLOAT_PARAM(2);
pCorona->item.id = CTheScripts::NextScriptCoronaID++;
if (pCorona->item.z <= MAP_Z_LOW_LIMIT)
pCorona->item.z = CWorld::FindGroundZForCoord(pCorona->item.x, pCorona->item.y);
pCorona->item.size = GET_FLOAT_PARAM(3);
pCorona->item.r = GET_INTEGER_PARAM(6);
pCorona->item.g = GET_INTEGER_PARAM(7);
pCorona->item.b = GET_INTEGER_PARAM(8);
pCorona->item.type = GET_INTEGER_PARAM(4);
pCorona->item.flareType = GET_INTEGER_PARAM(5);
SET_INTEGER_PARAM(0, pCorona->item.id);
CTheScripts::mCoronas.Insert(pCorona);
StoreParameters(&m_nIp, 1);
return 0;
}
case COMMAND_REMOVE_SCRIPT_CORONA:
{
CollectParameters(&m_nIp, 1);
for (base::cSList<script_corona>::tSItem* i = CTheScripts::mCoronas.first; i; i = i->next) {
if (i->item.id == GET_INTEGER_PARAM(0)) {
CTheScripts::mCoronas.Remove(i);
delete i;
break;
}
}
return 0;
}
case COMMAND_IS_BOAT_IN_WATER:
{
CollectParameters(&m_nIp, 1);
CBoat* pVehicle = (CBoat*)CPools::GetVehiclePool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pVehicle && pVehicle->IsBoat());
UpdateCompareFlag(pVehicle->bBoatInWater);
return 0;
}
case COMMAND_IS_CAR_DRIVER_BEING_JACKED:
{
CollectParameters(&m_nIp, 1);
CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pVehicle);
UpdateCompareFlag(pVehicle->bIsBeingCarJacked);
return 0;
}
case COMMAND_SET_CHAR_ONLY_ALLOWED_TO_SIT_IN_FRONT:
{
CollectParameters(&m_nIp, 2);
CPed* pPed = CPools::GetPedPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pPed);
pPed->bOnlyAllowedToSitInFront = GET_INTEGER_PARAM(1);
return 0;
}
case COMMAND_SET_CAR_TILTED_BY_CHAR:
{
CollectParameters(&m_nIp, 2);
CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(GET_INTEGER_PARAM(0));
CPed* pPed = CPools::GetPedPool()->GetAt(GET_INTEGER_PARAM(1));
script_assert(pVehicle);
pVehicle->ApplyTurnForce(0.0f, 0.0f, CGeneral::GetRandomNumberInRange(-0.8f, -1.2f)* pPed->m_fMass,
pPed->GetPosition().x - pVehicle->GetPosition().x, pPed->GetPosition().y - pVehicle->GetPosition().y, 0.0f);
DMAudio.PlayOneShot(pVehicle->m_audioEntityId, SOUND_CAR_JERK, 0.0f);
return 0;
}
case COMMAND_GET_WEAPON_TYPE_FOR_PICKUP_IN_AREA:
{
CollectParameters(&m_nIp, 4);
float X = GET_FLOAT_PARAM(0);
float Y = GET_FLOAT_PARAM(1);
float Z = GET_FLOAT_PARAM(2);
float radius = GET_FLOAT_PARAM(3);
int model = -1;
bool found = false;
for (uint32 i = 0; i < NUMPICKUPS; i++) {
CPickup* pPickup = &CPickups::aPickUps[i];
if (pPickup->m_eType != PICKUP_NONE) {
CVector fDist = pPickup->m_vecPos - CVector(X, Y, Z);
#ifndef FIX_BUGS // this breaks ALL pickups!
pPickup->m_eModelIndex = 4;
#endif
if (fDist.Magnitude() < radius && pPickup->m_pObject) {
found = true;
model = CPickups::WeaponForModel(pPickup->m_pObject->GetModelIndex());
}
}
}
SET_INTEGER_PARAM(0, model);
StoreParameters(&m_nIp, 1);
}
case COMMAND_IS_PLAYER_USING_FIRST_PERSON_WEAPON_CAMERA:
CollectParameters(&m_nIp, 1);
UpdateCompareFlag(TheCamera.Using1stPersonWeaponMode());
return 0;
//case COMMAND_1489:
//case COMMAND_1490:
//case COMMAND_1491:
case COMMAND_SET_DEBUG_MENU_ACTIVE:
CollectParameters(&m_nIp, 1);
// this sets two values on PS2 and PSP, but not on mobile - TODO?
return 0;
case COMMAND_SET_DRAW_HUD:
CollectParameters(&m_nIp, 1);
CHud::m_Wants_To_Draw_Hud = (GET_INTEGER_PARAM(0) != 0);
return 0;
case COMMAND_GET_RANDOM_CHAR_IN_AREA_NO_CHECKS:
{
CollectParameters(&m_nIp, 4);
int ped_handle = -1;
CVector pos = FindPlayerCoors();
float x1 = GET_FLOAT_PARAM(0);
float y1 = GET_FLOAT_PARAM(1);
float x2 = GET_FLOAT_PARAM(2);
float y2 = GET_FLOAT_PARAM(3);
int i = CPools::GetPedPool()->GetSize();
while (--i && ped_handle == -1) {
CPed* pPed = CPools::GetPedPool()->GetSlot(i);
if (!pPed)
continue;
if (pPed->bRemoveFromWorld)
continue;
if (pPed->bFadeOut)
continue;
if (pPed->m_nWaitState != WAITSTATE_FALSE)
continue;
if (!pPed->IsWithinArea(x1, y1, x2, y2))
continue;
if (pos.z - PED_FIND_Z_OFFSET > pPed->GetPosition().z)
continue;
if (pos.z + PED_FIND_Z_OFFSET < pPed->GetPosition().z)
continue;
ped_handle = CPools::GetPedPool()->GetIndex(pPed);
CTheScripts::LastRandomPedId = ped_handle;
pPed->CharCreatedBy = MISSION_CHAR;
pPed->bRespondsToThreats = false;
++CPopulation::ms_nTotalMissionPeds;
if (m_bIsMissionScript)
CTheScripts::MissionCleanUp.AddEntityToList(ped_handle, CLEANUP_CHAR);
}
SET_INTEGER_PARAM(0, ped_handle);
StoreParameters(&m_nIp, 1);
return 0;
}
case COMMAND_GET_RANDOM_CAR_IN_AREA_NO_CHECKS_NO_SAVE:
{
CollectParameters(&m_nIp, 4);
int handle = -1;
uint32 i = CPools::GetVehiclePool()->GetSize();
float infX = GET_FLOAT_PARAM(0);
float infY = GET_FLOAT_PARAM(1);
float supX = GET_FLOAT_PARAM(2);
float supY = GET_FLOAT_PARAM(3);
while (i-- && handle == -1) {
CVehicle* pVehicle = CPools::GetVehiclePool()->GetSlot(i);
if (!pVehicle)
continue;
if (!pVehicle->IsWithinArea(infX, infY, supX, supY))
continue;
handle = CPools::GetVehiclePool()->GetIndex(pVehicle);
}
SET_INTEGER_PARAM(0, handle);
StoreParameters(&m_nIp, 1);
return 0;
}
case COMMAND_STORE_CAR_COLLIDED_WITH_NO_SAVE:
{
CollectParameters(&m_nIp, 1);
CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(GET_INTEGER_PARAM(0));
if (!pVehicle)
printf("STORE_CAR_COLLIDED_WITH_NO_SAVE - Car doesn\'t exist\n");
else {
if (pVehicle->m_pLastDamageEntity == nil)
SET_INTEGER_PARAM(0, -1);
else {
// what they are doing is not very safe as m_pLastDamageEntity doesn't have to be CVehicle
#ifdef FIX_BUGS
if (!pVehicle->m_pLastDamageEntity->IsVehicle()) {
SET_INTEGER_PARAM(0, -1);
}
else
#endif
{
SET_INTEGER_PARAM(0, CPools::GetVehiclePool()->GetIndex((CVehicle*)pVehicle->m_pLastDamageEntity));
pVehicle->m_pLastDamageEntity = nil;
}
}
}
StoreParameters(&m_nIp, 1);
return 0;
}
default:
script_assert(0);
}
return -1;
}

755
src/control/Script9.cpp
View file

@ -23,759 +23,4 @@
#include "Vehicle.h"
#include "World.h"
// LCS: file done except TODOs (also check commented out strings)
int8 CRunningScript::ProcessCommands1500To1599(int32 command)
{
switch (command) {
case COMMAND_DISABLE_FERRY_PATH:
{
CollectParameters(&m_nIp, 1);
CFerry::DissableFerryPath(GET_INTEGER_PARAM(0));
return 0;
}
case COMMAND_ENABLE_FERRY_PATH:
{
CollectParameters(&m_nIp, 1);
CFerry::EnableFerryPath(GET_INTEGER_PARAM(0));
return 0;
}
case COMMAND_GET_CLOSEST_DOCKED_FERRY:
{
CollectParameters(&m_nIp, 2);
CFerry* pFerry = CFerry::GetClosestFerry(GET_FLOAT_PARAM(0), GET_FLOAT_PARAM(1));
int id = -1;
if (pFerry && pFerry->IsDocked())
id = pFerry->m_nFerryId;
SET_INTEGER_PARAM(0, id);
StoreParameters(&m_nIp, 1);
return 0;
}
case COMMAND_OPEN_FERRY_DOOR:
{
CollectParameters(&m_nIp, 1);
CFerry* pFerry = CFerry::GetFerry(GET_INTEGER_PARAM(0));
script_assert(pFerry);
pFerry->OpenDoor();
return 0;
}
case COMMAND_CLOSE_FERRY_DOOR:
{
CollectParameters(&m_nIp, 1);
CFerry* pFerry = CFerry::GetFerry(GET_INTEGER_PARAM(0));
script_assert(pFerry);
pFerry->CloseDoor();
return 0;
}
case COMMAND_IS_FERRY_DOOR_OPEN:
{
CollectParameters(&m_nIp, 1);
CFerry* pFerry = CFerry::GetFerry(GET_INTEGER_PARAM(0));
script_assert(pFerry);
UpdateCompareFlag(pFerry->IsDoorOpen());
return 0;
}
case COMMAND_IS_FERRY_DOOR_CLOSED:
{
CollectParameters(&m_nIp, 1);
CFerry* pFerry = CFerry::GetFerry(GET_INTEGER_PARAM(0));
script_assert(pFerry);
UpdateCompareFlag(pFerry->IsDoorClosed());
return 0;
}
case COMMAND_SKIP_FERRY_TO_NEXT_DOCK:
{
CollectParameters(&m_nIp, 1);
CFerry* pFerry = CFerry::GetFerry(GET_INTEGER_PARAM(0));
script_assert(pFerry);
pFerry->SkipFerryToNextDock();
return 0;
}
case COMMAND_SET_CHAR_DROPS_WEAPONS_ON_DEATH:
{
CollectParameters(&m_nIp, 2);
CPed* pPed = CPools::GetPedPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pPed);
pPed->bDropsWeaponsOnDeath = (GET_INTEGER_PARAM(1) != 0);
return 0;
}
case COMMAND_IS_CHAR_CROUCHING:
{
CollectParameters(&m_nIp, 1);
CPed* pPed = CPools::GetPedPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pPed);
UpdateCompareFlag(pPed->bIsDucking);
return 0;
}
case COMMAND_GET_FERRY_BOARDING_SPACE:
{
CollectParameters(&m_nIp, 4);
CFerry* pFerry = CFerry::GetFerry(GET_INTEGER_PARAM(0));
script_assert(pFerry);
CVector space = pFerry->GetBoardingSpace((CFerry::eSpaceUse)GET_INTEGER_PARAM(1), (CFerry::eSpaceStyle)GET_INTEGER_PARAM(2), GET_INTEGER_PARAM(3));
SET_FLOAT_PARAM(0, space.x);
SET_FLOAT_PARAM(1, space.y);
StoreParameters(&m_nIp, 2);
return 0;
}
case COMMAND_GET_FERRY_HEADING:
{
CollectParameters(&m_nIp, 1);
CFerry* pFerry = CFerry::GetFerry(GET_INTEGER_PARAM(0));
script_assert(pFerry);
float fHeading = Atan2(-pFerry->GetForward().x, pFerry->GetForward().y);
SET_FLOAT_PARAM(0, fHeading);
StoreParameters(&m_nIp, 1);
return 0;
}
case COMMAND_SET_FERRIES_DISABLED:
{
CollectParameters(&m_nIp, 2);
CFerry::SetFerriesDisabled(GET_INTEGER_PARAM(1));
return 0;
}
case COMMAND_COMPLETE_FERRY_DOOR_MOVEMENT:
{
CollectParameters(&m_nIp, 1);
CFerry* pFerry = CFerry::GetFerry(GET_INTEGER_PARAM(0));
script_assert(pFerry);
pFerry->CompleteDorrMovement();
return 0;
}
case COMMAND_OVERRIDE_CAR_REMOTE_CONTROL:
{
CollectParameters(&m_nIp, 2);
CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pVehicle);
pVehicle->SetStatus(STATUS_PLAYER_REMOTE);
CVehicle::bDisableRemoteDetonation = true;
CWorld::Players[CWorld::PlayerInFocus].m_pRemoteVehicle = pVehicle;
pVehicle->RegisterReference((CEntity**)&CWorld::Players[CWorld::PlayerInFocus].m_pRemoteVehicle);
if (pVehicle->GetVehicleAppearance() == VEHICLE_APPEARANCE_HELI || pVehicle->GetVehicleAppearance() == VEHICLE_APPEARANCE_PLANE) {
TheCamera.TakeControl(pVehicle, CCam::MODE_CAM_ON_A_STRING, GET_INTEGER_PARAM(1) ? INTERPOLATION : JUMP_CUT, CAMCONTROL_SCRIPT);
TheCamera.SetZoomValueCamStringScript(0);
}
else {
TheCamera.TakeControl(pVehicle, CCam::MODE_1STPERSON, GET_INTEGER_PARAM(1) ? INTERPOLATION : JUMP_CUT, CAMCONTROL_SCRIPT);
script_assert(pVehicle->IsCar());
((CAutomobile*)pVehicle)->Damage.m_bSmashedDoorDoesntClose = true;
}
if (m_bIsMissionScript)
CTheScripts::MissionCleanUp.RemoveEntityFromList(GET_INTEGER_PARAM(0), CLEANUP_CAR);
if (FindPlayerVehicle())
FindPlayerVehicle()->bCanBeDamaged = false;
return 0;
}
case COMMAND_CANCEL_REMOTE_MODE:
{
if (FindPlayerVehicle())
FindPlayerVehicle()->bCanBeDamaged = true;
CRemote::TakeRemoteControlledCarFromPlayer(false);
CWorld::Players[CWorld::PlayerInFocus].field_D6 = false;
CWorld::Players[CWorld::PlayerInFocus].m_pRemoteVehicle = nil;
TheCamera.Restore();
return 0;
}
case COMMAND_REGISTER_CAR_SOLD:
// CStats::CarsSold++;
return 0;
case COMMAND_ADD_MONEY_MADE_WITH_CAR_SALES:
CollectParameters(&m_nIp, 1);
// CStats::MoneyMadeWithCarSales += GET_INTEGER_PARAM(0);
return 0;
case COMMAND_SET_BRIDGE_STATE:
{
CollectParameters(&m_nIp, 1);
#ifdef GTA_BRIDGE
/*
* 0 = locked
* 1 = unlocked
* 2 = operational
*/
switch (GET_INTEGER_PARAM(0)) {
case 0: CBridge::ForceBridgeState(STATE_BRIDGE_LOCKED); break;
case 1: CBridge::ForceBridgeState(STATE_BRIDGE_ALWAYS_UNLOCKED); break;
case 2:
if (CBridge::State == STATE_LIFT_PART_IS_DOWN || CBridge::State == STATE_BRIDGE_ALWAYS_UNLOCKED)
CBridge::ForceBridgeState(STATE_LIFT_PART_ABOUT_TO_MOVE_UP);
else
CBridge::ForceBridgeState(STATE_LIFT_PART_MOVING_DOWN);
break;
default: script_assert(false);
}
#endif
return 0;
}
case COMMAND_SET_OBJECT_TURN_SPEED:
{
CollectParameters(&m_nIp, 4);
CObject* pObject = CPools::GetObjectPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pObject);
CVector vSpeed = GET_VECTOR_PARAM(1) / GAME_SPEED_TO_METERS_PER_SECOND;
pObject->SetTurnSpeed(vSpeed.x, vSpeed.y, vSpeed.z);
return 0;
}
case COMMAND_SET_OBJECT_MASS:
{
CollectParameters(&m_nIp, 4);
CObject* pObject = CPools::GetObjectPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pObject);
pObject->m_fMass = GET_FLOAT_PARAM(1);
pObject->m_fTurnMass = GET_FLOAT_PARAM(2);
pObject->m_fAirResistance = GET_FLOAT_PARAM(3);
if (pObject->m_fMass < 99998.0f) {
pObject->bInfiniteMass = false;
pObject->m_phy_flagA08 = false;
pObject->bAffectedByGravity = true;
}
else {
pObject->bInfiniteMass = true;
pObject->m_phy_flagA08 = true;
pObject->bAffectedByGravity = false;
}
return 0;
}
case COMMAND_HAS_CUTSCENE_LOADED:
UpdateCompareFlag(CCutsceneMgr::ms_cutsceneLoadStatus == CUTSCENE_LOADED);
return 0;
case COMMAND_SET_UNIQUE_JUMPS_FOUND:
CollectParameters(&m_nIp, 1);
CStats::NumberOfUniqueJumpsFound = GET_INTEGER_PARAM(0);
return 0;
case COMMAND_SET_HIDDEN_PACKAGES_COLLECTED:
CollectParameters(&m_nIp, 1);
CWorld::Players[CWorld::PlayerInFocus].m_nCollectedPackages = GET_INTEGER_PARAM(0);
return 0;
case COMMAND_REGISTER_BIKE_SOLD:
// CStats::BikesSold++;
return 0;
case COMMAND_ADD_MONEY_MADE_WITH_BIKE_SALES:
CollectParameters(&m_nIp, 1);
// CStats::MoneyMadeWithBikeSales += GET_INTEGER_PARAM(0);
return 0;
case COMMAND_REGISTER_PACKAGE_SMUGGLED:
// CStats::PackagesSmuggled++;
return 0;
case COMMAND_REGISTER_SMUGGLER_WASTED:
// CStats::SmugglersWasted++;
return 0;
case COMMAND_REGISTER_FASTEST_SMUGGLING_TIME:
CollectParameters(&m_nIp, 1);
// CStats::RegisterFastestSmugglingTime(GET_INTEGER_PARAM(0));
return 0;
case COMMAND_SET_CHAR_DIVE_FROM_CAR:
{
CollectParameters(&m_nIp, 2);
CPed* pPed = CPools::GetPedPool()->GetAt(GET_INTEGER_PARAM(0));
CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(GET_INTEGER_PARAM(1));
script_assert(pPed);
pPed->bRespondsToThreats = true;
pPed->SetEvasiveDive(pVehicle, 1);
return 0;
}
case COMMAND_WRECK_CAR:
{
CollectParameters(&m_nIp, 1);
CAutomobile* pVehicle = (CAutomobile*)CPools::GetVehiclePool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pVehicle);
script_assert(pVehicle->IsCar());
pVehicle->m_fHealth = 0.0f;
pVehicle->SetStatus(STATUS_WRECKED);
pVehicle->bRenderScorched = true;
pVehicle->Damage.FuckCarCompletely();
if (pVehicle->GetModelIndex() != MI_RCBANDIT) {
pVehicle->SetBumperDamage(CAR_BUMP_FRONT, VEHBUMPER_FRONT);
pVehicle->SetBumperDamage(CAR_BUMP_REAR, VEHBUMPER_REAR);
pVehicle->SetDoorDamage(CAR_BONNET, DOOR_BONNET);
pVehicle->SetDoorDamage(CAR_BOOT, DOOR_BOOT);
pVehicle->SetDoorDamage(CAR_DOOR_LF, DOOR_FRONT_LEFT);
pVehicle->SetDoorDamage(CAR_DOOR_RF, DOOR_FRONT_RIGHT);
pVehicle->SetDoorDamage(CAR_DOOR_LR, DOOR_REAR_LEFT);
pVehicle->SetDoorDamage(CAR_DOOR_RR, DOOR_REAR_RIGHT);
}
pVehicle->m_bombType = CARBOMB_NONE;
pVehicle->bEngineOn = false;
pVehicle->bLightsOn = false;
pVehicle->m_fHealth = 0.0f;
pVehicle->m_nBombTimer = 0;
pVehicle->m_bSirenOrAlarm = false;
return 0;
}
case COMMAND_ADD_MONEY_MADE_IN_COACH:
CollectParameters(&m_nIp, 1);
// CStats::MoneyMadeInCoach += GET_INTEGER_PARAM(0);
return 0;
case COMMAND_ADD_MONEY_MADE_COLLECTING_TRASH:
CollectParameters(&m_nIp, 1);
// CStats::MoneyMadeCollectingTrash += GET_INTEGER_PARAM(0);
return 0;
case COMMAND_REGISTER_HITMAN_KILLED:
// CStats::HitmenKilled++;
return 0;
case COMMAND_REGISTER_GUARDIAN_ANGEL_MISSION_PASSED:
// CStats::GaurdianAngelMissionsPassed++;
return 0;
case COMMAND_REGISTER_HIGHEST_GUARDIAN_ANGEL_JUSTICE_DISHED:
CollectParameters(&m_nIp, 1);
// CStats::RegisterHighestGaurdianAngelJusticeDished(GET_INTEGER_PARAM(0));
return 0;
case COMMAND_REGISTER_BEST_BANDIT_LAP_TIME:
CollectParameters(&m_nIp, 2);
// CStats::RegisterBestBanditLapTime(GET_INTEGER_PARAM(0), GET_INTEGER_PARAM(1));
return 0;
case COMMAND_REGISTER_BEST_BANDIT_POSITION:
CollectParameters(&m_nIp, 2);
// CStats::RegisterBestBanditPosition(GET_INTEGER_PARAM(0), GET_INTEGER_PARAM(1));
return 0;
case COMMAND_REGISTER_MOST_TIME_LEFT_TRAIN_RACE:
CollectParameters(&m_nIp, 1);
// CStats::RegisterMostTimeLeftTrainRace(GET_INTEGER_PARAM(0));
return 0;
case COMMAND_REGISTER_HIGHEST_TRAIN_CASH_EARNED:
CollectParameters(&m_nIp, 1);
// CStats::RegisterHighestTrainCashEarned(GET_INTEGER_PARAM(0));
return 0;
case COMMAND_REGISTER_FASTEST_HELI_RACE_TIME:
// CStats::RegisterFastestHeliRaceTime(GET_INTEGER_PARAM(0));
CollectParameters(&m_nIp, 1);
return 0;
case COMMAND_REGISTER_BEST_HELI_RACE_POSITION:
// CStats::RegisterBestHeliRacePosition(GET_INTEGER_PARAM(0));
CollectParameters(&m_nIp, 1);
return 0;
case COMMAND_REGISTER_OUTFIT_CHANGE:
// CStats::NumberOutfitChanges++;
return 0;
case COMMAND_REGISTER_STREET_RACE_FASTEST_TIME:
// CStats::RegisterStreetRaceFastestTime(GET_INTEGER_PARAM(0), GET_INTEGER_PARAM(1));
CollectParameters(&m_nIp, 2);
return 0;
case COMMAND_REGISTER_STREET_RACE_FASTEST_LAP:
CollectParameters(&m_nIp, 2);
// CStats::RegisterStreetRaceFastestLap(GET_INTEGER_PARAM(0), GET_INTEGER_PARAM(1));
return 0;
case COMMAND_REGISTER_STREET_RACE_BEST_POSITION:
CollectParameters(&m_nIp, 2);
// CStats::RegisterStreetRaceBestPosition(GET_INTEGER_PARAM(0), GET_INTEGER_PARAM(1));
return 0;
case COMMAND_HAS_OBJECT_BEEN_DAMAGED_BY_WEAPON:
{
CollectParameters(&m_nIp, 2);
CObject* pObject = CPools::GetObjectPool()->GetAt(GET_INTEGER_PARAM(0));
bool result = false;
if (!pObject) {
printf("HAS_OBJECT_BEEN_DAMAGED_BY_WEAPON - Object doesn\'t exist\n");
}
else {
if (GET_INTEGER_PARAM(1) == WEAPONTYPE_ANYMELEE || GET_INTEGER_PARAM(1) == WEAPONTYPE_ANYWEAPON)
result = CheckDamagedWeaponType(pObject->m_nLastWeaponToDamage, GET_INTEGER_PARAM(1));
else
result = GET_INTEGER_PARAM(1) == pObject->m_nLastWeaponToDamage;
}
UpdateCompareFlag(result);
return 0;
}
case COMMAND_CLEAR_OBJECT_LAST_WEAPON_DAMAGE:
{
CollectParameters(&m_nIp, 1);
CObject* pObject = CPools::GetObjectPool()->GetAt(GET_INTEGER_PARAM(0));
if (!pObject)
printf("CLEAR_OBJECT_LAST_WEAPON_DAMAGE - pObject doesn\'t exist");
else
pObject->m_nLastWeaponToDamage = -1;
return 0;
}
case COMMAND_SET_CAR_TURN_SPEED:
{
CollectParameters(&m_nIp, 4);
CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pVehicle);
CVector vSpeed = GET_VECTOR_PARAM(1) / GAME_SPEED_TO_METERS_PER_SECOND;
pVehicle->SetTurnSpeed(vSpeed.x, vSpeed.y, vSpeed.z);
return 0;
}
case COMMAND_SET_CAR_MOVE_SPEED:
{
CollectParameters(&m_nIp, 4);
CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pVehicle);
CVector vSpeed = GET_VECTOR_PARAM(1) / GAME_SPEED_TO_METERS_PER_SECOND;
pVehicle->SetMoveSpeed(vSpeed);
return 0;
}
case COMMAND_SET_OBJECT_PROOFS:
{
CollectParameters(&m_nIp, 6);
CObject* pObject = CPools::GetObjectPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pObject);
pObject->bBulletProof = (GET_INTEGER_PARAM(1) != 0);
pObject->bFireProof = (GET_INTEGER_PARAM(2) != 0);
pObject->bExplosionProof = (GET_INTEGER_PARAM(3) != 0);
pObject->bCollisionProof = (GET_INTEGER_PARAM(4) != 0);
pObject->bMeleeProof = (GET_INTEGER_PARAM(5) != 0);
return 0;
}
case COMMAND_GET_CAMERA_PED_ZOOM_INDICATOR:
if (TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_FOLLOWPED)
SET_INTEGER_PARAM(0, TheCamera.PedZoomIndicator);
else
SET_INTEGER_PARAM(0, -1);
StoreParameters(&m_nIp, 1);
return 0;
case COMMAND_SET_CAMERA_PED_ZOOM_INDICATOR:
CollectParameters(&m_nIp, 1);
if (TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_FOLLOWPED)
TheCamera.PedZoomIndicator = GET_INTEGER_PARAM(0);
return 0;
case COMMAND_GET_CAR_ORIENTATION:
{
CollectParameters(&m_nIp, 1);
CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pVehicle);
SET_FLOAT_PARAM(1, LimitAngleOnCircle(RADTODEG(Asin(pVehicle->GetForward().z))));
SET_FLOAT_PARAM(2, LimitAngleOnCircle(RADTODEG(Atan2(-pVehicle->GetForward().x, pVehicle->GetForward().y))));
SET_FLOAT_PARAM(0, LimitAngleOnCircle(RADTODEG(Atan2(-pVehicle->GetRight().z, pVehicle->GetUp().z))));
StoreParameters(&m_nIp, 3);
return 0;
}
case COMMAND_SET_CAR_ORIENTATION:
{
CollectParameters(&m_nIp, 4);
CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pVehicle);
pVehicle->SetOrientation(DEGTORAD(GET_FLOAT_PARAM(2)), DEGTORAD(GET_FLOAT_PARAM(1)), DEGTORAD(GET_FLOAT_PARAM(3)));
return 0;
}
case COMMAND_IS_DEBUG_MENU_ON:
// on PS2 it's something actual - TODO
UpdateCompareFlag(false);
return 0;
case COMMAND_OPEN_VAN_BACK_DOORS:
{
CollectParameters(&m_nIp, 1);
CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(GET_INTEGER_PARAM(0));
assert(pVehicle);
pVehicle->ProcessOpenDoor(CAR_DOOR_RR, ANIM_STD_VAN_OPEN_DOOR_REAR_RHS, 1.0f);
pVehicle->ProcessOpenDoor(CAR_DOOR_LR, ANIM_STD_VAN_OPEN_DOOR_REAR_LHS, 1.0f);
return 0;
}
case COMMAND_GET_CHAR_THREAT_CHAR:
{
CollectParameters(&m_nIp, 1);
CPed* pPed = CPools::GetPedPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pPed);
SET_INTEGER_PARAM(0, 0);
CEntity* pThreat = pPed->m_threatEntity;
if (pThreat && pThreat->IsPed())
SET_INTEGER_PARAM(0, CPools::GetPedPool()->GetIndex((CPed*)pThreat));
StoreParameters(&m_nIp, 1);
return 0;
}
case COMMAND_FREEZE_PED_ZOOM_SWITCH:
CollectParameters(&m_nIp, 1);
TheCamera.m_bFreezePedZoomSwitch = GET_INTEGER_PARAM(0);
return 0;
case COMMAND_SET_OBJECT_RENDERED_DAMAGED:
{
CollectParameters(&m_nIp, 1);
CObject* pObject = CPools::GetObjectPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pObject);
pObject->bRenderDamaged = true;
return 0;
}
case COMMAND_GET_RANDOM_CAR_IN_AREA_NO_SAVE:
{
CollectParameters(&m_nIp, 5);
int handle = -1;
uint32 i = CPools::GetVehiclePool()->GetSize();
float infX = GET_FLOAT_PARAM(0);
float infY = GET_FLOAT_PARAM(1);
float supX = GET_FLOAT_PARAM(2);
float supY = GET_FLOAT_PARAM(3);
while (i-- && handle == -1) {
CVehicle* pVehicle = CPools::GetVehiclePool()->GetSlot(i);
if (!pVehicle)
continue;
if (pVehicle->GetVehicleAppearance() != VEHICLE_APPEARANCE_CAR && pVehicle->GetVehicleAppearance() != VEHICLE_APPEARANCE_BIKE)
continue;
#ifdef FIX_BUGS
if (pVehicle->m_fHealth <= 0.0f)
#else
if (pVehicle->m_fHealth == 0.0f)
#endif
continue;
if (pVehicle->GetModelIndex() != GET_INTEGER_PARAM(4) && GET_INTEGER_PARAM(4) >= 0)
continue;
if (pVehicle->VehicleCreatedBy != RANDOM_VEHICLE)
continue;
if (!pVehicle->IsWithinArea(infX, infY, supX, supY))
continue;
handle = CPools::GetVehiclePool()->GetIndex(pVehicle);
}
SET_INTEGER_PARAM(0, handle);
StoreParameters(&m_nIp, 1);
return 0;
}
case COMMAND_IS_PLAYER_MADE_SAFE:
{
UpdateCompareFlag(CPad::GetPad(0)->IsPlayerControlsDisabledBy(PLAYERCONTROL_PLAYERINFO));
return 0;
}
case COMMAND_PRINT_IF_FREE:
{
wchar* text = CTheScripts::GetTextByKeyFromScript(&m_nIp);
CollectParameters(&m_nIp, 2);
//CMessages::AddMessageIfFree(text, GET_INTEGER_PARAM(0), GET_INTEGER_PARAM(1)); TODO
return 0;
}
case COMMAND_IS_E3_BUILD:
UpdateCompareFlag(false);
return 0;
case COMMAND_DECLARE_FORT_STAUNTON_DESTROYED_FLAG:
CTheScripts::FSDestroyedFlag = (uint8*)GetPointerToScriptVariable(&m_nIp, VAR_GLOBAL) - CTheScripts::ScriptSpace;
return 0;
case COMMAND_CLEAR_BIG_MESSAGES:
//CMessages::ClearBigMessagesOnly(); TODO
//CHud::ClearBigMessagesExcept(2, 2); TODO
CGarages::MessageEndTime = CGarages::MessageStartTime;
return 0;
case COMMAND_CLEAR_AREA_OF_OBJECTS:
{
CollectParameters(&m_nIp, 6);
uint32 i = CPools::GetObjectPool()->GetSize();
float infX = GET_FLOAT_PARAM(0);
float infY = GET_FLOAT_PARAM(1);
float infZ = GET_FLOAT_PARAM(2);
float supX = GET_FLOAT_PARAM(3);
float supY = GET_FLOAT_PARAM(4);
float supZ = GET_FLOAT_PARAM(5);
while (i--) {
CObject* pObject = CPools::GetObjectPool()->GetSlot(i);
if (pObject && pObject->CanBeDeleted() && pObject->IsWithinArea(infX, infY, infZ, supX, supY, supZ)) {
pObject->DeleteRwObject();
CWorld::Remove(pObject);
delete pObject;
}
}
i = CPools::GetDummyPool()->GetSize();
while (i--) {
CDummy* pDummy = CPools::GetDummyPool()->GetSlot(i);
if (pDummy && pDummy->IsObject() && pDummy->IsWithinArea(infX, infY, infZ, supX, supY, supZ)) {
pDummy->DeleteRwObject();
CWorld::Remove(pDummy);
delete pDummy;
}
}
return 0;
}
case COMMAND_LOAD_NON_STANDARD_PED_ANIM:
CollectParameters(&m_nIp, 1);
CPed::LoadNonStandardPedAnim((eWaitState)GET_INTEGER_PARAM(0));
return 0;
case COMMAND_UNLOAD_NON_STANDARD_PED_ANIM:
CollectParameters(&m_nIp, 1);
CPed::UnloadNonStandardPedAnim((eWaitState)GET_INTEGER_PARAM(0));
return 0;
case COMMAND_1566:
CollectParameters(&m_nIp, 1);
return 0;
case COMMAND_BUILD_WORLD_GEOMETRY:
CollectParameters(&m_nIp, 1);
if (/*gBuildWorldGeom*/ false) {
//base::cWorldGeom::GetInstance()->Build(GET_INTEGER_PARAM(0));
UpdateCompareFlag(true);
}
else {
UpdateCompareFlag(false);
}
return 0;
case COMMAND_STORE_BUILDING_SWAP:
CollectParameters(&m_nIp, 4);
// base::cWorldGeom::GetInstance()->StoreBuildingSwap(GET_INTEGER_PARAM(0), GET_INTEGER_PARAM(1), GET_INTEGER_PARAM(2), GET_INTEGER_PARAM(3) != 0);
return 0;
case COMMAND_IS_MULTIPLAYER_ACTIVE:
#ifdef GTA_NETWORK
UpdateCompareFlag(gIsMultiplayerGame);
#else
UpdateCompareFlag(false);
#endif
return 0;
case COMMAND_GET_MULTIPLAYER_MODE:
SET_INTEGER_PARAM(0, 0); // TODO
StoreParameters(&m_nIp, 1);
return 0;
case COMMAND_MULTIPLAYER_SCRIPT_DONE:
printf("COMMAND_MULTIPLAYER_SCRIPT_DONE\n");
//gbStartingScriptsFromLua = false; TODO?
return 0;
case COMMAND_IS_MULTIPLAYER_SERVER:
UpdateCompareFlag(false); // TODO?
return 0;
case COMMAND_IS_MULTIPLAYER_TEAM_GAME:
UpdateCompareFlag(false); // TODO?
return 0;
case COMMAND_GET_MULTIPLAYER_TEAM_ID:
SET_INTEGER_PARAM(0, 0); // TODO
StoreParameters(&m_nIp, 1);
return 0;
case COMMAND_DOES_SHORTCUT_TAXI_EXIST:
UpdateCompareFlag(CGameLogic::pShortCutTaxi != nil);
return 0;
case COMMAND_SET_ONSCREEN_TIMER_COLOUR:
CollectParameters(&m_nIp, 4);
gbColour = CRGBA(GET_INTEGER_PARAM(0), GET_INTEGER_PARAM(1), GET_INTEGER_PARAM(2), GET_INTEGER_PARAM(3));
return 0;
case COMMAND_SET_ONSCREEN_TIMER_BACKGROUND_COLOUR:
CollectParameters(&m_nIp, 4);
gbColour2 = CRGBA(GET_INTEGER_PARAM(0), GET_INTEGER_PARAM(1), GET_INTEGER_PARAM(2), GET_INTEGER_PARAM(3));
return 0;
case COMMAND_REMOVE_CAR_BOOT:
{
CollectParameters(&m_nIp, 1);
CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pVehicle);
script_assert(pVehicle->IsCar());
CAutomobile* pAutomobile = (CAutomobile*)pVehicle;
pAutomobile->Damage.SetDoorStatus(DOOR_BOOT, DOOR_STATUS_MISSING);
pAutomobile->SetDoorDamage(CAR_BOOT, DOOR_BOOT, true);
return 0;
}
case COMMAND_ADD_POINT_3D_MARKER:
{
uint32 ip = m_nIp;
uint32 id = (uint32)(uintptr)GetPointerToScriptVariable(&ip, 0);
static CVector vPreviousLocation;
CollectParameters(&m_nIp, 7);
CVector pos = GET_VECTOR_PARAM(0);
if (pos.z <= MAP_Z_LOW_LIMIT)
pos.z = CWorld::FindGroundZForCoord(pos.x, pos.y);
if (vPreviousLocation != pos) {
//C3dMarkers::CopyMarker(id, id - 1, 1, 1);
}
// TODO: 5 is not a valid type
//C3dMarkers::PlaceMarker(id, 5, pos, GET_FLOAT_PARAM(3) * 0.7f, GET_INTEGER_PARAM(4), GET_INTEGER_PARAM(5), GET_INTEGER_PARAM(6), 255, 128, 0.0f, 1); // TODO: 0, 100.0f, 1, 0
vPreviousLocation = pos;
return 0;
}
case COMMAND_GET_VECTOR_FROM_MULTIPLAYER:
SET_VECTOR_PARAM(0, gVectorSetInLua);
StoreParameters(&m_nIp, 3);
return 0;
case COMMAND_PRINT_HELP_ALWAYS:
{
// CHud::mAlwaysAllowHelpText = true; // TODO
wchar* text = CTheScripts::GetTextByKeyFromScript(&m_nIp);
CHud::SetHelpMessage(text, false); // + false, true
return 0;
}
case COMMAND_PRINT_HELP_FOREVER_ALWAYS:
{
// CHud::mAlwaysAllowHelpText = true; // TODO
wchar* text = CTheScripts::GetTextByKeyFromScript(&m_nIp);
CHud::SetHelpMessage(text, false, true); // + true
return 0;
}
case COMMAND_SWITCH_FERRY_COLLISION:
CollectParameters(&m_nIp, 1);
CFerry::SwitchFerryCollision(GET_INTEGER_PARAM(0));
return 0;
case COMMAND_SET_CHAR_MAX_HEALTH:
{
CollectParameters(&m_nIp, 2);
CPed* pPed = CPools::GetPedPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pPed);
pPed->m_fHealth = GET_INTEGER_PARAM(1);
pPed->m_fMaxHealth = GET_INTEGER_PARAM(1);
return 0;
}
case COMMAND_SET_CHAR_SHOOT_TIMER:
{
CollectParameters(&m_nIp, 2);
CPed* pPed = CPools::GetPedPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pPed);
pPed->m_nScriptShootTimer = GET_INTEGER_PARAM(1);
return 0;
}
case COMMAND_SET_CHAR_ATTACK_TIMER:
{
CollectParameters(&m_nIp, 2);
CPed* pPed = CPools::GetPedPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pPed);
pPed->m_nScriptAttackTimer = GET_INTEGER_PARAM(1);
return 0;
}
case COMMAND_SET_HELI_ROTOR_BLADES_FULLSPEED:
{
CollectParameters(&m_nIp, 1);
CAutomobile* pHeli = (CAutomobile*)CPools::GetVehiclePool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pHeli);
if (pHeli->GetVehicleAppearance() == VEHICLE_APPEARANCE_HELI)
pHeli->m_aWheelSpeed[1] = 0.22f;
return 0;
}
case COMMAND_SET_CRUSHER_REWARD_MULTIPLIER:
{
CollectParameters(&m_nIp, 1);
CGarages::CrusherRewardMultiplier = GET_INTEGER_PARAM(0);
return 0;
}
case COMMAND_SWAP_BUILDINGS:
{
CollectParameters(&m_nIp, 2);
// base::cWorldStream::Instance()->SwapBuilding(GET_INTEGER_PARAM(0), GET_INTEGER_PARAM(1));
return 0;
}
case COMMAND_STREAM_BUILDING_SWAPS:
{
// UpdateCompareFlag(base::cWorldStream::Instance()->StreamBuildingSwaps());
UpdateCompareFlag(true);
return 0;
}
case COMMAND_IS_WORLD_STREAMING_COMPLETE:
{
// UpdateCompareFlag(base::cWorldStream::Instance()->IsStreamingComplet());
UpdateCompareFlag(true);
return 0;
}
case COMMAND_SWAP_TO_STREAMED_SECTOR:
{
// base::cWorldStream::Instance()->SwapToStreamedSector();
return 0;
}
case COMMAND_SET_CHAR_ATTACKS_PLAYER_WITH_COPS:
{
CollectParameters(&m_nIp, 2);
CPed* pPed = CPools::GetPedPool()->GetAt(GET_INTEGER_PARAM(0));
script_assert(pPed);
pPed->bAttacksPlayerWithCops = (GET_INTEGER_PARAM(1) != 0);
return 0;
}
case COMMAND_REGISTER_FACE_PLANT_DISTANCE:
CollectParameters(&m_nIp, 1);
//CStats::LongestFacePlantDist = Max(CStats::LongestFacePlantDist, GET_FLOAT_PARAM(0));
return 0;
case COMMAND_REGISTER_MAX_SECONDS_ON_CARNAGE_LEFT:
CollectParameters(&m_nIp, 1);
//CStats::MaxSecondsOnCarnageLeft = Max(CStats::MaxSecondsOnCarnageLeft, GET_INTEGER_PARAM(0));
return 0;
case COMMAND_REGISTER_MAX_KILLS_ON_RC_TRIAD:
CollectParameters(&m_nIp, 1);
//CStats::MaxKillsOnRcTriad = Max(CStats::MaxKillsOnRcTriad, GET_INTEGER_PARAM(0));
return 0;
case COMMAND_REGISTER_HIGHEST_LEVEL_SLASH_TV:
CollectParameters(&m_nIp, 1);
//CStats::HighestLevelSlashTv = Max(CStats::HighestLevelSlashTv, GET_INTEGER_PARAM(0));
return 0;
case COMMAND_ADD_MONEY_MADE_WITH_SLASH_TV:
CollectParameters(&m_nIp, 1);
//CStats::MoneyMadeWithSlashTv += GET_INTEGER_PARAM(0);
return 0;
case COMMAND_ADD_TOTAL_KILLS_ON_SLASH_TV:
CollectParameters(&m_nIp, 1);
//CStats::TotalKillsOnSlashTV += GET_INTEGER_PARAM(0);
return 0;
default:
script_assert(0);
}
return -1;
}

1365
src/control/ScriptCommands.h
View file

File diff suppressed because it is too large Load diff

52
src/control/ScriptDebug.cpp
View file

@ -24,8 +24,8 @@ uint32 CRunningScript::storedIp;
#define REGISTER_COMMAND(command, in, out, cond, ovrd, visual) { command, #command, in, out, cond, ovrd, visual }
#define INPUT_ARGUMENTS(...) { __VA_ARGS__ ARGTYPE_NONE }
#define OUTPUT_ARGUMENTS(...) { __VA_ARGS__ ARGTYPE_NONE }
const tScriptCommandData commands[] = {
REGISTER_COMMAND(COMMAND_NOP, INPUT_ARGUMENTS(), OUTPUT_ARGUMENTS(), false, -1, ""),
const tScriptCommandData commands[1] = {
/*REGISTER_COMMAND(COMMAND_NOP, INPUT_ARGUMENTS(), OUTPUT_ARGUMENTS(), false, -1, ""),
REGISTER_COMMAND(COMMAND_WAIT, INPUT_ARGUMENTS(ARGTYPE_INT,), OUTPUT_ARGUMENTS(), false, -1, ""),
REGISTER_COMMAND(COMMAND_GOTO, INPUT_ARGUMENTS(ARGTYPE_LABEL,), OUTPUT_ARGUMENTS(), false, -1, ""),
REGISTER_COMMAND(COMMAND_SHAKE_CAM, INPUT_ARGUMENTS(ARGTYPE_INT,), OUTPUT_ARGUMENTS(), false, -1, ""),
@ -1686,12 +1686,13 @@ const tScriptCommandData commands[] = {
REGISTER_COMMAND(COMMAND_PRINT_HELP_FOREVER_ALWAYS_NO_BRIEF, INPUT_ARGUMENTS(), OUTPUT_ARGUMENTS(), false, -1, ""),
REGISTER_COMMAND(COMMAND_SET_CAR_IS_REWARD, INPUT_ARGUMENTS(ARGTYPE_INT, ARGTYPE_INT,), OUTPUT_ARGUMENTS(), false, -1, ""),
REGISTER_COMMAND(COMMAND_FREEZE_ALL_PLAYER_FOLLOWERS, INPUT_ARGUMENTS(ARGTYPE_INT, ARGTYPE_INT,), OUTPUT_ARGUMENTS(), false, -1, ""),
*/
};
#undef REGISTER_COMMAND
#undef INPUT_ARGUMENTS
#undef OUTPUT_ARGUMENTS
static_assert(ARRAY_SIZE(commands) == LAST_SCRIPT_COMMAND, "commands array not filled");
///////////////static_assert(ARRAY_SIZE(commands) == LAST_SCRIPT_COMMAND, "commands array not filled");
#if SCRIPT_LOG_FILE_LEVEL == 1 || SCRIPT_LOG_FILE_LEVEL == 2
static FILE* dbg_log;
@ -1710,9 +1711,11 @@ static void PrintToLog(const char* format, ...)
va_end(va);
#if SCRIPT_LOG_FILE_LEVEL == 1 || SCRIPT_LOG_FILE_LEVEL == 2
#ifndef MAZAHAKA_DEBUG_NOFILE
if (dbg_log)
fwrite(tmp, 1, strlen(tmp), dbg_log);
#endif
#endif
}
#endif
@ -1733,11 +1736,34 @@ int32* GetPointerToScriptVariableForDebug(CRunningScript* pScript, uint32* pIp,
uint8 type = CTheScripts::Read1ByteFromScript(pIp);
if (type >= ARGUMENT_GLOBAL_ARRAY) {
uint8 index_in_block = CTheScripts::Read1ByteFromScript(pIp);
//debug("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&index_in_block %d\n", index_in_block);
//debug("pIp 0x%p\n", &CTheScripts::ScriptSpace[(*pIp) - 1]);
uint8 index_id = CTheScripts::Read1ByteFromScript(pIp);
uint8 size = CTheScripts::Read1ByteFromScript(pIp);
/*#ifdef MAZAHAKA_8_IN_LOCAL_VARS_SCRIPTS_ASSERT_STUFF
if(!(pScript->m_anLocalVariables[pScript->m_nLocalsPointer + index_id] < size)) {
debug("index_in_block %d\n", index_in_block); // 94
debug("index_id %d\n", index_id); // 5
debug("size %d\n", size); // 4
debug("pIp %d\n", *pIp); // 4
debug("pIp 0x%p\n", &CTheScripts::ScriptSpace[(*pIp) - 3]); // 4
debug("\n");
// debug(""); // 4 breakpoint
}
#endif*/
script_assert(size > 0);
#ifdef MAZAHAKA_8_IN_LOCAL_VARS_SCRIPTS_ASSERT_STUFF
//#if 0
//script_assert(pScript->m_anLocalVariables[pScript->m_nLocalsPointer + index_id] < size); // :RAYS2_7614 0573: does_vehicle_exist $3934(5@,4)
// knowed issue
if(pScript->m_abScriptName && strcmp(pScript->m_abScriptName, "rays2")) { script_assert(pScript->m_anLocalVariables[pScript->m_nLocalsPointer + index_id] < size); }
uint8 index = Min(pScript->m_anLocalVariables[pScript->m_nLocalsPointer + index_id + 8], size - 1);
#else
script_assert(pScript->m_anLocalVariables[pScript->m_nLocalsPointer + index_id] < size);
uint8 index = Min(pScript->m_anLocalVariables[pScript->m_nLocalsPointer + index_id], size - 1);
#endif
sprintf(tmpstr, " $%d[%d@ (%d)]", ((int)(type - ARGUMENT_GLOBAL_ARRAY) << 8) + index_in_block, index_id, pScript->m_anLocalVariables[pScript->m_nLocalsPointer + index_id]);
strcat(buf, tmpstr);
return (int32*)&CTheScripts::ScriptSpace[4 * (((int)(type - ARGUMENT_GLOBAL_ARRAY) << 8) + index + index_in_block)];
@ -1751,9 +1777,26 @@ int32* GetPointerToScriptVariableForDebug(CRunningScript* pScript, uint32* pIp,
else if (type >= ARGUMENT_LOCAL_ARRAY) {
uint8 index_id = CTheScripts::Read1ByteFromScript(pIp);
uint8 size = CTheScripts::Read1ByteFromScript(pIp);
/*#ifdef MAZAHAKA_8_IN_LOCAL_VARS_SCRIPTS_ASSERT_STUFF
if(!(pScript->m_anLocalVariables[pScript->m_nLocalsPointer + index_id] < size)) {
debug("index_id %d\n", index_id);
debug("size %d\n", size);
debug("pIp %d\n", *pIp); // 4
debug("pIp 0x%p\n", &CTheScripts::ScriptSpace[(*pIp) - 3]); // 4
debug("\n"); // debug(""); // 4 breakpoint
}
#endif*/
script_assert(size > 0);
//#ifdef MAZAHAKA_8_IN_LOCAL_VARS_SCRIPTS_ASSERT_STUFF
#if 0
script_assert(pScript->m_anLocalVariables[pScript->m_nLocalsPointer + index_id + 8] < size);
uint8 index = Min(pScript->m_anLocalVariables[pScript->m_nLocalsPointer + index_id + 8], size - 1);
#else
script_assert(pScript->m_anLocalVariables[pScript->m_nLocalsPointer + index_id] < size);
uint8 index = Min(pScript->m_anLocalVariables[pScript->m_nLocalsPointer + index_id], size - 1);
#endif
sprintf(tmpstr, " %d@[%d@ (%d)]", (type - ARGUMENT_LOCAL_ARRAY), index_id, pScript->m_anLocalVariables[pScript->m_nLocalsPointer + index_id]);
strcat(buf, tmpstr);
return &pScript->m_anLocalVariables[pScript->m_nLocalsPointer + (type - ARGUMENT_LOCAL_ARRAY) + index];
@ -1772,6 +1815,8 @@ int32* GetPointerToScriptVariableForDebug(CRunningScript* pScript, uint32* pIp,
return nil;
}
//#if SCRIPT_LOG_FILE_LEVEL == 1 || SCRIPT_LOG_FILE_LEVEL == 2 // mazahaka tmp compile error without scriptdebug
#if 1
int CRunningScript::CollectParameterForDebug(char* buf, bool& var)
{
var = false;
@ -1951,6 +1996,7 @@ void CRunningScript::LogAfterProcessingCommand(int32 command)
}
}
}
#endif
#ifdef MISSION_SWITCHER
void