switch (sound) {

case SOUND_STEP_START:

case SOUND_STEP_END:

}

break;

case SOUND_FALL_LAND:

case SOUND_FALL_COLLAPSE:

}

break;

case SOUND_FIGHT_PUNCH_33:

m_sQueueSample.m_nSampleIndex = SFX_FIGHT_1;

const int policeChannel = channels + 1;

const int allChannels = channels + 2;

cAudioManager::cAudioManager()

{

m_bIsInitialised = false;

m_nActiveSamples = NUM_SOUNDS_SAMPLES_SLOTS;

m_nActiveSampleQueue = 1;

ClearRequestedQueue();

{

public:

bool m_bIsInitialised;

bool m_bFifthFrameFlag;

uint8 m_nActiveSamples;

uint8 field_4; // unused

#include "stream.h"

#include "sampman.h"

#ifdef _WIN32

#pragma comment( lib, "libsndfile-1.lib" )

#pragma comment( lib, "libmpg123-0.lib" )

#endif

#include <sndfile.h>

#include <mpg123.h>

#endif

#ifndef _WIN32

#include "crossplatform.h"

#endif

class CSndFile : public IDecoder

{

SNDFILE *m_pfSound;

uint32 Decode(void *buffer)

{

if ( !IsOpened() ) return 0;

}

};

class CMP3File : public IDecoder

{

m_pMH = mpg123_new(nil, nil);

if ( m_pMH )

{

long rate = 0;

int channels = 0;

int encoding = 0;

assert("We can't handle audio files more then 2 GB yet :shrug:" && (size < UINT32_MAX));

#endif

if (err != MPG123_OK && err != MPG123_DONE) return 0;

return (uint32)size;

}

};

class COpusFile : public IDecoder

{

OggOpusFile *m_FileH;

if (size < 0)

return 0;

return size * m_nChannels * GetSampleSize();

}

};

void CStream::Initialise()

{

mpg123_init();

#endif

}

void CStream::Terminate()

{

mpg123_exit();

#endif

}

m_alBuffers(buffers),

m_pBuffer(nil),

m_bPaused(false),

DEV("Stream %s\n", m_aFilename);

m_pSoundFile = new CSndFile(m_aFilename);

#else

m_pSoundFile = new COpusFile(m_aFilename);

#endif

else

bool CStream::HasSource()

{

}

bool CStream::IsOpened()

if ( !m_bPaused )

{

return true;

}

{

if ( !HasSource() ) return;

ALint sourceState = AL_PAUSED;

}

void CStream::SetPause(bool bPause)

void CStream::SetPitch(float pitch)

{

if ( !HasSource() ) return;

}

void CStream::SetGain(float gain)

{

if ( !HasSource() ) return;

}

{

if ( !HasSource() ) return;

}

void CStream::SetVolume(uint32 nVol)

void CStream::SetPan(uint8 nPan)

{

m_nPan = nPan;

}

void CStream::SetPosMS(uint32 nPos)

ALint offset;

//alGetSourcei(m_alSource, AL_SAMPLE_OFFSET, &offset);

return m_pSoundFile->Tell()

+ m_pSoundFile->samples2ms(offset/m_pSoundFile->GetSampleSize()) / m_pSoundFile->GetChannels();

}

return m_pSoundFile->GetLength();

}

{

if ( !HasSource() )

return false;

if ( !IsOpened() )

return false;

return false;

uint32 size = m_pSoundFile->Decode(m_pBuffer);

if( size == 0 )

return false;

return true;

}

int32 CStream::FillBuffers()

{

int32 i = 0;

{

break;

}

return i;

void CStream::ClearBuffers()

{

if ( !HasSource() ) return;

ALuint value;

}

bool CStream::Setup()

if ( IsOpened() )

{

m_pSoundFile->Seek(0);

//SetPosition(0.0f, 0.0f, 0.0f);

SetPitch(1.0f);

//SetPan(m_nPan);

if ( state )

{

ALint sourceState = AL_PLAYING;

if (sourceState != AL_PLAYING )

m_bActive = true;

}

else

{

ALint sourceState = AL_STOPPED;

m_bActive = false;

}

}

if ( !m_bPaused )

{

ALint looping = AL_FALSE;

if ( looping == AL_TRUE )

{

TRACE("stream set looping");

}

{

}

{

}

}

}

#ifdef AUDIO_OAL

#include <AL/al.h>

class IDecoder

{

class CStream

{

char m_aFilename[128];

ALuint (&m_alBuffers)[NUM_STREAMBUFFERS];

bool m_bPaused;

IDecoder *m_pSoundFile;

bool HasSource();

void SetPitch(float pitch);

void SetGain(float gain);

void Pause();

void SetPlay(bool state);

int32 FillBuffers();

void ClearBuffers();

public:

static void Initialise();

static void Terminate();

~CStream();

void Delete();

extern int defaultProvider;

#endif

static char StreamedNameTable[][25] = {

"AUDIO\\HEAD.OPUS", "AUDIO\\CLASS.OPUS", "AUDIO\\KJAH.OPUS", "AUDIO\\RISE.OPUS", "AUDIO\\LIPS.OPUS", "AUDIO\\GAME.OPUS",

"AUDIO\\MSX.OPUS", "AUDIO\\FLASH.OPUS", "AUDIO\\CHAT.OPUS", "AUDIO\\HEAD.OPUS", "AUDIO\\POLICE.OPUS", "AUDIO\\CITY.OPUS",

"AUDIO\\door_2.OPUS", "AUDIO\\door_3.OPUS", "AUDIO\\door_4.OPUS", "AUDIO\\door_5.OPUS", "AUDIO\\door_6.OPUS", "AUDIO\\t3_a.OPUS",

"AUDIO\\t3_b.OPUS", "AUDIO\\t3_c.OPUS", "AUDIO\\k1_b.OPUS", "AUDIO\\cat1.OPUS"};

#else

static char StreamedNameTable[][25]=

{

"AUDIO\\MUSIC\\HEAD.VB",

"AUDIO\\MUSIC\\CLASS.VB",

"AUDIO\\MUSIC\\KJAH.VB",

"AUDIO\\MUSIC\\MISCOM.VB",

"AUDIO\\MUSIC\\END.VB",

#else

"AUDIO\\HEAD.WAV",

"AUDIO\\CLASS.WAV",

"AUDIO\\KJAH.WAV",

#include "MusicManager.h"

#include "Frontend.h"

#include "Timer.h"

#include <opusfile.h>

#endif

char SampleBankDataFilename[] = "audio/sfx.RAW";

FILE *fpSampleDescHandle;

OggOpusFile *fpSampleDataHandle;

#else

FILE *fpSampleDataHandle;

uint8 nChannelVolume[MAXCHANNELS+MAX2DCHANNELS];

uint32 nStreamLength[TOTAL_STREAMED_SOUNDS];

ALuint ALStreamBuffers[MAX_STREAMS][NUM_STREAMBUFFERS];

struct tMP3Entry

if (stream)

stream->ProviderTerm();

alDeleteBuffers(NUM_STREAMBUFFERS, ALStreamBuffers[i]);

}

CChannel::DestroyChannels();

//TODO:

_maxSamples = MAXCHANNELS;

ALDevice = alcOpenDevice(providers[index].id);

ASSERT(ALDevice != NULL);

alGenAuxiliaryEffectSlots(1, &ALEffectSlot);

alGenEffects(1, &ALEffect);

}

for ( int32 i = 0; i < MAX_STREAMS; i++ )

{

CStream *stream = aStream[i];

if (stream)

return false;

}

cSampleManager::cSampleManager(void)

{

;

#ifdef AUDIO_CACHE

FILE *cacheFile = fcaseopen("audio\\sound.cache", "rb");

if (cacheFile) {

fread(nStreamLength, sizeof(uint32), TOTAL_STREAMED_SOUNDS, cacheFile);

fclose(cacheFile);

} else

{

uint32 tatalms = aStream[0]->GetLengthMS();

delete aStream[0];

aStream[0] = NULL;

nStreamLength[i] = tatalms;

USERERROR("Can't open '%s'\n", StreamedNameTable[i]);

}

#ifdef AUDIO_CACHE

cacheFile = fcaseopen("audio\\sound.cache", "wb");

}

{

if ( !InitialiseSampleBanks() )

return false;

}

int samplesRead = 0;

int samplesSize = nSampleBankSize[nBank] / 2;

op_pcm_seek(fpSampleDataHandle, 0);

}

}

int samplesRead = 0;

int samplesSize = m_aSamples[nComment].nSize / 2;

op_pcm_seek(fpSampleDataHandle, m_aSamples[nComment].nOffset / 2);

strcpy(filename, StreamedNameTable[nFile]);

ASSERT(stream != NULL);

aStream[nStream] = stream;

nFile = 0;

strcat(filename, StreamedNameTable[nFile]);

ASSERT(stream != NULL);

aStream[nStream] = stream;

}

if (mp3->pLinkPath != NULL)

else {

strcpy(filename, _mp3DirectoryPath);

strcat(filename, mp3->aFilename);

}

if (aStream[nStream]->IsOpened()) {

{

nFile = 0;

strcat(filename, StreamedNameTable[nFile]);

ASSERT(stream != NULL);

aStream[nStream] = stream;

}

if (e->pLinkPath != NULL)

else {

strcpy(filename, _mp3DirectoryPath);

strcat(filename, e->aFilename);

strcpy(filename, StreamedNameTable[nFile]);

ASSERT(stream != NULL);

aStream[nStream] = stream;

fpSampleDescHandle = fcaseopen(SampleBankDescFilename, "rb");

if ( fpSampleDescHandle == NULL )

return false;

fpSampleDataHandle = fcaseopen(SampleBankDataFilename, "rb");

if ( fpSampleDataHandle == NULL )

{

fpSampleDataHandle = op_open_file(SampleBankDataFilename, &e);

#endif

fread(m_aSamples, sizeof(tSample), TOTAL_AUDIO_SAMPLES, fpSampleDescHandle);

int32 _nSampleDataEndOffset = m_aSamples[TOTAL_AUDIO_SAMPLES - 1].nOffset + m_aSamples[TOTAL_AUDIO_SAMPLES - 1].nSize;

#endif

fclose(fpSampleDescHandle);

class CGarage

{

uint8 m_eGarageType;

uint8 m_eGarageState;

bool field_2; // unused

void FindDoorsEntitiesSectorList(CPtrList&, bool);

void PlayerArrestedOrDied();

};

VALIDATE_SIZE(CGarage, 140);

enum {

MESSAGE_LENGTH = 8

};

static int32 BankVansCollected;

static bool BombsAreFree;

static bool RespraysAreFree;

static CStoredCar aCarsInSafeHouse3[NUM_GARAGE_STORED_CARS];

static bool bCamShouldBeOutisde;

static void Init(void);

#ifndef PS2

static void Shutdown(void);

static void SetFreeBombs(bool bValue) { BombsAreFree = bValue; }

static void SetFreeResprays(bool bValue) { RespraysAreFree = bValue; }

static bool IsCarSprayable(CVehicle*);

static float FindDoorHeightForMI(int32);

static void CloseHideOutGaragesBeforeSave(void);

static int32 GetBombTypeForGarageType(uint8 type) { return type - GARAGE_BOMBSHOP1 + 1; }

static int32 GetCarsCollectedIndexForGarageType(uint8 type) { return type - GARAGE_COLLECTCARS_1; }

};

uint16 CTheScripts::NumberOfIntroRectanglesThisFrame;

uint16 CTheScripts::NumberOfIntroTextLinesThisFrame;

uint8 CTheScripts::UseTextCommands;

CUpsideDownCarCheck CTheScripts::UpsideDownCars;

CStuckCarCheck CTheScripts::StuckCars;

uint16 CTheScripts::CommandsExecuted;

REGISTER_COMMAND(COMMAND_SET_JAMES_CAR_ON_PATH_TO_PLAYER, INPUT_ARGUMENTS(ARGTYPE_INT,), OUTPUT_ARGUMENTS(), false, -1, ""),

REGISTER_COMMAND(COMMAND_LOAD_END_OF_GAME_TUNE, INPUT_ARGUMENTS(), OUTPUT_ARGUMENTS(), false, -1, ""),

REGISTER_COMMAND(COMMAND_ENABLE_PLAYER_CONTROL_CAMERA, INPUT_ARGUMENTS(), OUTPUT_ARGUMENTS(), false, -1, ""),

REGISTER_COMMAND(COMMAND_SET_OBJECT_ROTATION, INPUT_ARGUMENTS(ARGTYPE_INT, ARGTYPE_FLOAT, ARGTYPE_FLOAT, ARGTYPE_FLOAT,), OUTPUT_ARGUMENTS(), false, -1, ""),

REGISTER_COMMAND(COMMAND_GET_DEBUG_CAMERA_COORDINATES, INPUT_ARGUMENTS(), OUTPUT_ARGUMENTS(ARGTYPE_FLOAT, ARGTYPE_FLOAT, ARGTYPE_FLOAT,), false, -1, ""),

REGISTER_COMMAND(COMMAND_GET_DEBUG_CAMERA_FRONT_VECTOR, INPUT_ARGUMENTS(), OUTPUT_ARGUMENTS(ARGTYPE_FLOAT, ARGTYPE_FLOAT, ARGTYPE_FLOAT,), false, -1, ""),

}

}

{

for (int i = 0; i < MAX_CLEANUP; i++){

if (m_sEntities[i].type == CLEANUP_UNUSED)

void CMissionCleanup::AddEntityToList(int32 id, uint8 type)

{

if (!pNew)

return;

pNew->id = id;

bool CUpsideDownCarCheck::IsCarUpsideDown(int32 id)

{

}

void CUpsideDownCarCheck::UpdateTimers()

bool CUpsideDownCarCheck::AreAnyCarsUpsideDown()

{

for (int i = 0; i < MAX_UPSIDEDOWN_CAR_CHECKS; i++){

return true;

}

return false;

uint16 index = 0;

while (index < MAX_UPSIDEDOWN_CAR_CHECKS && m_sCars[index].m_nVehicleIndex >= 0)

index++;

if (index >= MAX_UPSIDEDOWN_CAR_CHECKS)

return;

m_sCars[index].m_nVehicleIndex = id;

m_sCars[index].m_nUpsideDownTimer = 0;

}

{

for (int i = 0; i < MAX_UPSIDEDOWN_CAR_CHECKS; i++){

if (m_sCars[i].m_nVehicleIndex == id)

}

return false;

}

int index = 0;

while (index < MAX_STUCK_CAR_CHECKS && m_sCars[index].m_nVehicleIndex >= 0)

index++;

m_sCars[index].m_nVehicleIndex = id;

m_sCars[index].m_vecPos = pv->GetPosition();

m_sCars[index].m_nLastCheck = CTimer::GetTimeInMilliseconds();

ScriptsArray[i].Init();

ScriptsArray[i].AddScriptToList(&pIdleScripts);

}

UpsideDownCars.Init();

StuckCars.Init();

CFileMgr::SetDir("data");

retval = ProcessCommands800To899(command);

else if (command < 1000)

retval = ProcessCommands900To999(command);

else if (command < 1200)

retval = ProcessCommands1000To1099(command);

#else

ScriptParams[0] = CPools::GetPedPool()->GetIndex(ped);

StoreParameters(&m_nIp, 1);

if (m_bIsMissionScript)

return 0;

}

case COMMAND_DELETE_CHAR:

--CPopulation::ms_nTotalMissionPeds;

}

if (m_bIsMissionScript)

return 0;

}

case COMMAND_CHAR_WANDER_DIR:

ScriptParams[0] = handle;

StoreParameters(&m_nIp, 1);

if (m_bIsMissionScript)

return 0;

}

case COMMAND_DELETE_CAR:

delete car;

}

if (m_bIsMissionScript)

return 0;

}

case COMMAND_CAR_GOTO_COORDINATES:

car->AutoPilot.m_nCruiseSpeed = *(float*)&ScriptParams[1];

if (missionRetryScriptIndex == 40 && car->GetModelIndex() == MI_CHEETAH) // Turismo

car->AutoPilot.m_nCruiseSpeed = 8 * car->AutoPilot.m_nCruiseSpeed / 10;

#else

#endif

return 0;

}

return 0;

if (strcmp(m_abScriptName, "love3") == 0) /* A Drop in the Ocean */

CPickups::RemoveAllFloatingPickups();

return 0;

}

case COMMAND_STORE_CAR_CHAR_IS_IN:

pOld->bIsLocked = false;

CCarCtrl::NumRandomCars++;

CCarCtrl::NumMissionCars--;

}

}

CCarCtrl::NumMissionCars++;

CCarCtrl::NumRandomCars--;

CTheScripts::StoreVehicleWasRandom = true;

break;

case PARKED_VEHICLE:

pCurrent->VehicleCreatedBy = MISSION_VEHICLE;

CCarCtrl::NumMissionCars++;

CCarCtrl::NumParkedCars--;

CTheScripts::StoreVehicleWasRandom = true;

break;

case MISSION_VEHICLE:

case PERMANENT_VEHICLE:

pOld->bIsLocked = false;

CCarCtrl::NumRandomCars++;

CCarCtrl::NumMissionCars--;

}

}

CCarCtrl::NumMissionCars++;

CCarCtrl::NumRandomCars--;

CTheScripts::StoreVehicleWasRandom = true;

break;

case PARKED_VEHICLE:

pCurrent->VehicleCreatedBy = MISSION_VEHICLE;

CCarCtrl::NumMissionCars++;

CCarCtrl::NumParkedCars--;

CTheScripts::StoreVehicleWasRandom = true;

break;

case MISSION_VEHICLE:

case PERMANENT_VEHICLE:

ScriptParams[0] = CPools::GetObjectPool()->GetIndex(pObj);

StoreParameters(&m_nIp, 1);

if (m_bIsMissionScript)

return 0;

}

case COMMAND_DELETE_OBJECT:

delete pObj;

}

if (m_bIsMissionScript)

return 0;

}

case COMMAND_ADD_SCORE:

ScriptParams[0] = CPools::GetPedPool()->GetIndex(pPed);

StoreParameters(&m_nIp, 1);

if (m_bIsMissionScript)

return 0;

}

case COMMAND_WARP_PLAYER_FROM_CAR_TO_COORD:

return -1;

}

#ifdef MISSION_REPLAY

bool CRunningScript::CanAllowMissionReplay()

else if (type == 2) {

doingMissionRetry = false;

AllowMissionReplay = 6;

}

}

#pragma once

#include "common.h"

#include "Ped.h"

#include "PedType.h"

#include "Text.h"

void FlushLog();

#define script_assert(_Expression) FlushLog(); assert(_Expression);

#ifdef USE_PRECISE_MEASUREMENT_CONVERTION

#else

#endif

#define GTA_SCRIPT_COLLECTIVE

#endif

m_bCentered = false;

m_bBackground = false;

m_bBackgroundOnly = false;

m_sBackgroundColor = CRGBA(128, 128, 128, 128);

m_bTextProportional = true;

m_bTextBeforeFade = false;

m_fAtX = 0.0f;

m_fAtY = 0.0f;

memset(&m_Text, 0, sizeof(m_Text));

CLEANUP_OBJECT

};

{

uint8 type;

int32 id;

class CMissionCleanup

{

uint8 m_nCount;

CMissionCleanup();

void Init();

void AddEntityToList(int32, uint8);

void RemoveEntityFromList(int32, uint8);

void Process();

};

{

int32 m_nVehicleIndex;

uint32 m_nUpsideDownTimer;

class CUpsideDownCarCheck

{

public:

void Init();

bool IsCarUpsideDown(int32);

void UpdateTimers();

bool AreAnyCarsUpsideDown();

void AddCarToCheck(int32);

bool m_bStuck;

stuck_car_data() { }

};

class CStuckCarCheck

class CTheScripts

{

static uint8 ScriptSpace[SIZE_SCRIPT_SPACE];

static CRunningScript ScriptsArray[MAX_NUM_SCRIPTS];

static int32 BaseBriefIdForContact[MAX_NUM_CONTACTS];

static CStoredLine aStoredLines[MAX_NUM_STORED_LINES];

static bool DbgFlag;

static uint32 OnAMissionFlag;

static CStuckCarCheck StuckCars;

static CUpsideDownCarCheck UpsideDownCars;

static int32 StoreVehicleIndex;

static uint16 CommandsExecuted;

static uint16 ScriptsUpdated;

static void Init();

static void Process();

return Read4BytesFromScript(&tmp);

}

static CRunningScript* StartNewScript(uint32);

static void CleanUpThisVehicle(CVehicle*);

static void SetObjectiveForAllPedsInCollective(int, eObjective);

#endif

#ifdef MISSION_SWITCHER

public:

static void SwitchToMission(int32 mission);

enum {

NUM_LOCAL_VARS = 16,

NUM_TIMERS = 2

};

ORS_8

};

CRunningScript* next;

CRunningScript* prev;

char m_abScriptName[8];

static const uint32 nSaveStructSize;

void CollectParameters(uint32*, int16);

int32 CollectNextParameterWithoutIncreasingPC(uint32);

int32* GetPointerToScriptVariable(uint32*, int16);

int8 ProcessCommands800To899(int32);

int8 ProcessCommands900To999(int32);

int8 ProcessCommands1000To1099(int32);

int8 ProcessCommands1100To1199(int32);

#endif

void LocatePlayerCommand(int32, uint32*);

return false;

}

}

};

#ifdef MISSION_REPLAY

CPed* pPed = CPools::GetPedPool()->GetAt(ScriptParams[0]);

CTheScripts::CleanUpThisPed(pPed);

if (m_bIsMissionScript)

return 0;

}

case COMMAND_MARK_CAR_AS_NO_LONGER_NEEDED:

CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(ScriptParams[0]);

CTheScripts::CleanUpThisVehicle(pVehicle);

if (m_bIsMissionScript)

return 0;

}

case COMMAND_MARK_OBJECT_AS_NO_LONGER_NEEDED:

CObject* pObject = CPools::GetObjectPool()->GetAt(ScriptParams[0]);

CTheScripts::CleanUpThisObject(pObject);

if (m_bIsMissionScript)

return 0;

}

case COMMAND_DONT_REMOVE_CHAR:

CollectParameters(&m_nIp, 1);

CPed* pPed = CPools::GetPedPool()->GetAt(ScriptParams[0]);

script_assert(pPed);

return 0;

}

case COMMAND_DONT_REMOVE_CAR:

CollectParameters(&m_nIp, 1);

CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(ScriptParams[0]);

script_assert(pVehicle);

return 0;

}

case COMMAND_DONT_REMOVE_OBJECT:

CollectParameters(&m_nIp, 1);

CObject* pObject = CPools::GetObjectPool()->GetAt(ScriptParams[0]);

script_assert(pObject);

return 0;

}

case COMMAND_CREATE_CHAR_AS_PASSENGER:

ScriptParams[0] = CPools::GetPedPool()->GetIndex(pPed);

StoreParameters(&m_nIp, 1);

if (m_bIsMissionScript)

return 0;

}

case COMMAND_SET_CHAR_OBJ_KILL_CHAR_ON_FOOT:

CollectParameters(&m_nIp, 1);

CGarages::SetFreeBombs(ScriptParams[0] != 0);

return 0;

case COMMAND_SET_POWERPOINT:

{

CollectParameters(&m_nIp, 7);

return 0;

}

case COMMAND_SET_ALL_TAXI_LIGHTS:

CollectParameters(&m_nIp, 1);

CAutomobile::SetAllTaxiLights(ScriptParams[0] != 0);

ScriptParams[0] = CPools::GetObjectPool()->GetIndex(pObj);

StoreParameters(&m_nIp, 1);

if (m_bIsMissionScript)

return 0;

}

case COMMAND_IS_BOAT:

pPed->bRespondsToThreats = false;

++CPopulation::ms_nTotalMissionPeds;

if (m_bIsMissionScript)

}

ScriptParams[0] = ped_handle;

StoreParameters(&m_nIp, 1);

pPed->bRespondsToThreats = false;

++CPopulation::ms_nTotalMissionPeds;

if (m_bIsMissionScript)

}

ScriptParams[0] = ped_handle;

StoreParameters(&m_nIp, 1);

++CCarCtrl::NumMissionCars;

--CCarCtrl::NumRandomCars;

if (m_bIsMissionScript)

}

ScriptParams[0] = handle;

StoreParameters(&m_nIp, 1);

++CCarCtrl::NumMissionCars;

--CCarCtrl::NumRandomCars;

if (m_bIsMissionScript)

}

ScriptParams[0] = handle;

StoreParameters(&m_nIp, 1);

}

}

if (m_bIsMissionScript)

return 0;

}

case COMMAND_SET_CHAR_STAY_IN_SAME_PLACE:

ScriptParams[0] = CPools::GetPedPool()->GetIndex(ped);

StoreParameters(&m_nIp, 1);

if (m_bIsMissionScript)

return 0;

}

case COMMAND_SET_CHAR_OBJ_STEAL_ANY_CAR:

#undef SCRIPT_DATA_SIZE

void CTheScripts::ClearSpaceForMissionEntity(const CVector& pos, CEntity* pEntity)

{

static CColPoint aTempColPoints[MAX_COLLISION_POINTS];

#include "Zones.h"

#include "main.h"

int8 CRunningScript::ProcessCommands1000To1099(int32 command)

{

char tmp[48];

#endif

switch (command) {

ScriptParams[0] = CPools::GetVehiclePool()->GetIndex(pVehicle);

StoreParameters(&m_nIp, 1);

if (m_bIsMissionScript)

return 0;

}

case COMMAND_START_BOAT_FOAM_ANIMATION:

pPed->m_objective != OBJECTIVE_ENTER_CAR_AS_DRIVER);

return 0;

}

default:

script_assert(0);

}

case COMMAND_ENABLE_PLAYER_CONTROL_CAMERA:

CPad::GetPad(0)->SetEnablePlayerControls(PLAYERCONTROL_CAMERA);

return 0;

// These are "beta" VC commands (with bugs)

case COMMAND_SET_OBJECT_ROTATION:

{

pPed->bRespondsToThreats = false;

++CPopulation::ms_nTotalMissionPeds;

if (m_bIsMissionScript)

}

ScriptParams[0] = ped_handle;

StoreParameters(&m_nIp, 1);

pPed->bRespondsToThreats = false;

++CPopulation::ms_nTotalMissionPeds;

if (m_bIsMissionScript)

}

ScriptParams[0] = ped_handle;

StoreParameters(&m_nIp, 1);

COMMAND_SET_JAMES_CAR_ON_PATH_TO_PLAYER,

COMMAND_LOAD_END_OF_GAME_TUNE,

COMMAND_ENABLE_PLAYER_CONTROL_CAMERA,

COMMAND_SET_OBJECT_ROTATION,

COMMAND_GET_DEBUG_CAMERA_COORDINATES,

COMMAND_GET_DEBUG_CAMERA_FRONT_VECTOR,

"overpass_comse",

"newdockbuilding",

"newdockbuilding2",

"policeballhall",

"fuzballdoor",

"ind_land106",

"railtrax_2b",

"railtrax_straightss",

"railtrax_bentr",

""

};

char *TreeNames[] = {

"coast_treepatch",

}

ssize_t

{

int fd;

ssize_t n, len;

return -1;

#endif

len += n;

}while(n == 0x4000);

buf[len] = 0;

myfclose(fd);

static void ChangeDir(const char *dir);

static void SetDir(const char *dir);

static void SetDirMyDocuments(void);

static int OpenFile(const char *file, const char *mode);

static int OpenFile(const char *file) { return OpenFile(file, "rb"); }

static int OpenFileForWriting(const char *file);

CMenuScreenCustom::CMenuEntry &option = aScreens[m_nCurrScreen].m_aEntries[i];

if (option.m_Action == MENUACTION_CFO_SELECT) {

if (option.m_CFOSelect->onlyApplyOnEnter){

if (m_nCurrOption != i) {

if (option.m_CFOSelect->displayedValue != option.m_CFOSelect->lastSavedValue)

case MENUACTION_CFO_DYNAMIC:

CMenuScreenCustom::CMenuEntry &option = aScreens[m_nCurrScreen].m_aEntries[m_nCurrOption];

if (option.m_Action == MENUACTION_CFO_SELECT) {

if (!option.m_CFOSelect->onlyApplyOnEnter) {

option.m_CFOSelect->displayedValue++;

if (option.m_CFOSelect->displayedValue >= option.m_CFOSelect->numRightTexts || option.m_CFOSelect->displayedValue < 0)

case MENUACTION_CFO_DYNAMIC:

CMenuScreenCustom::CMenuEntry &option = aScreens[m_nCurrScreen].m_aEntries[m_nCurrOption];

if (option.m_Action == MENUACTION_CFO_SELECT) {

if (changeValueBy > 0) {

option.m_CFOSelect->displayedValue++;

if (option.m_CFOSelect->displayedValue >= option.m_CFOSelect->numRightTexts)

int8 displayedValue; // only if onlyApplyOnEnter enabled for now

int8 lastSavedValue; // only if onlyApplyOnEnter enabled

ChangeFunc changeFunc;

CCFOSelect() {};

this->value = value;

if (value)

this->lastSavedValue = this->displayedValue = *value;

this->numRightTexts = numRightTexts;

this->onlyApplyOnEnter = onlyApplyOnEnter;

this->changeFunc = changeFunc;

}

};

CPlayerSkin::Initialise();

#endif

return (true);

}

// missing altogether on PS2

void CGame::ShutdownRenderWare(void)

{

CMBlur::MotionBlurClose();

DestroySplashScreen();

CHud::Shutdown();

#ifdef CUSTOM_FRONTEND_OPTIONS

#ifdef IMPROVED_VIDEOMODE

#else

#define VIDEOMODE_SELECTOR

#endif

#endif

#ifdef CUTSCENE_BORDERS_SWITCH

#else

#define CUTSCENE_BORDERS_TOGGLE

#endif

#ifdef FREE_CAM

#else

#define FREE_CAM_TOGGLE

#endif

#ifdef PS2_ALPHA_TEST

#else

#define DUALPASS_SELECTOR

#endif

#ifdef EXTENDED_COLOURFILTER

#define POSTFX_SELECTORS \

#else

#define POSTFX_SELECTORS

#endif

#ifdef INVERT_LOOK_FOR_PAD

#else

#define INVERT_PAD_SELECTOR

#endif

// "S1CD13TR1X" - SQUARE L1 CIRCLE DOWN L1 R1 TRIANGLE RIGHT L1 CROSS

else if ( !_CHEATCMP("X1RT31DC1S") )

NastyLimbsCheat();

#undef _CHEATCMP

}

#endif

bUpdate = false;

if ( bUpdate )

GetPad(0)->Update(0);

GetPad(1)->NewState.Clear();

GetPad(1)->OldState.Clear();

#endif

mi = CModelInfo::GetModelInfo(streamId);

// Txd has to be loaded

if(CTxdStore::GetSlot(mi->GetTxdSlot())->texDict == nil){

debug("failed to load %s because TXD %s is not in memory\n", mi->GetName(), CTxdStore::GetTxdName(mi->GetTxdSlot()));

RemoveModel(streamId);

RemoveTxd(mi->GetTxdSlot());

ReRequestModel(streamId);

RwStreamClose(stream, &mem);

return false;

}

}

CCarCtrl::RemoveFromInterestingVehicleList(pVehicle);

delete pVehicle;

}

}

CObject::DeleteAllTempObjectsInArea(pos, radius);

gFireManager.ExtinguishPoint(pos, radius);

CExplosion::RemoveAllExplosionsInArea(pos, radius);

if(bRemoveProjectilesAndTidyUpShadows) {

CProjectileInfo::RemoveAllProjectiles();

int16 *nEntitiesFound, int16 maxEntitiesToFind, CEntity **aEntities, bool bBuildings,

bool bVehicles, bool bPeds, bool bObjects, bool bDummies)

{

*nEntitiesFound = 0;

const CVector2D vecSectorStartPos(position.x - radius, position.y - radius);

const CVector2D vecSectorEndPos(position.x + radius, position.y + radius);

for(int32 y = nStartY; y <= nEndY; y++) {

for(int32 x = nStartX; x <= nEndX; x++) {

if(bBuildings) {

modelId, pSector->m_lists[ENTITYLIST_BUILDINGS], position, radius, bCheck2DOnly,

nEntitiesFound, maxEntitiesToFind, aEntities);

modelId, pSector->m_lists[ENTITYLIST_BUILDINGS_OVERLAP], position, radius,

bCheck2DOnly, nEntitiesFound, maxEntitiesToFind, aEntities);

}

if(bVehicles) {

modelId, pSector->m_lists[ENTITYLIST_VEHICLES], position, radius, bCheck2DOnly,

nEntitiesFound, maxEntitiesToFind, aEntities);

modelId, pSector->m_lists[ENTITYLIST_VEHICLES_OVERLAP], position, radius,

bCheck2DOnly, nEntitiesFound, maxEntitiesToFind, aEntities);

}

if(bPeds) {

modelId, pSector->m_lists[ENTITYLIST_PEDS], position, radius, bCheck2DOnly,

nEntitiesFound, maxEntitiesToFind, aEntities);

modelId, pSector->m_lists[ENTITYLIST_PEDS_OVERLAP], position, radius, bCheck2DOnly,

nEntitiesFound, maxEntitiesToFind, aEntities);

}

if(bObjects) {

modelId, pSector->m_lists[ENTITYLIST_OBJECTS], position, radius, bCheck2DOnly,

nEntitiesFound, maxEntitiesToFind, aEntities);

modelId, pSector->m_lists[ENTITYLIST_OBJECTS_OVERLAP], position, radius,

bCheck2DOnly, nEntitiesFound, maxEntitiesToFind, aEntities);

}

if(bDummies) {

modelId, pSector->m_lists[ENTITYLIST_DUMMIES], position, radius, bCheck2DOnly,

nEntitiesFound, maxEntitiesToFind, aEntities);

modelId, pSector->m_lists[ENTITYLIST_DUMMIES_OVERLAP], position, radius,

bCheck2DOnly, nEntitiesFound, maxEntitiesToFind, aEntities);

}

int16 maxEntitiesToFind, CEntity **aEntities, bool bBuildings, bool bVehicles,

bool bPeds, bool bObjects, bool bDummies)

{

*nCollidingEntities = 0;

const CVector2D vecSectorStartPos(position.x - radius, position.y - radius);

const CVector2D vecSectorEndPos(position.x + radius, position.y + radius);

for(int32 y = nStartY; y <= nEndY; y++) {

for(int32 x = nStartX; x <= nEndX; x++) {

if(bBuildings) {

pSector->m_lists[ENTITYLIST_BUILDINGS], position, radius, bCheck2DOnly,

nCollidingEntities, maxEntitiesToFind, aEntities);

pSector->m_lists[ENTITYLIST_BUILDINGS_OVERLAP], position, radius, bCheck2DOnly,

nCollidingEntities, maxEntitiesToFind, aEntities);

}

if(bVehicles) {

pSector->m_lists[ENTITYLIST_VEHICLES], position, radius, bCheck2DOnly,

nCollidingEntities, maxEntitiesToFind, aEntities);

pSector->m_lists[ENTITYLIST_VEHICLES_OVERLAP], position, radius, bCheck2DOnly,

nCollidingEntities, maxEntitiesToFind, aEntities);

}

if(bPeds) {

radius, bCheck2DOnly, nCollidingEntities,

maxEntitiesToFind, aEntities);

pSector->m_lists[ENTITYLIST_PEDS_OVERLAP], position, radius, bCheck2DOnly,

nCollidingEntities, maxEntitiesToFind, aEntities);

}

if(bObjects) {

pSector->m_lists[ENTITYLIST_OBJECTS], position, radius, bCheck2DOnly,

nCollidingEntities, maxEntitiesToFind, aEntities);

pSector->m_lists[ENTITYLIST_OBJECTS_OVERLAP], position, radius, bCheck2DOnly,

nCollidingEntities, maxEntitiesToFind, aEntities);

}

if(bDummies) {

pSector->m_lists[ENTITYLIST_DUMMIES], position, radius, bCheck2DOnly,

nCollidingEntities, maxEntitiesToFind, aEntities);

pSector->m_lists[ENTITYLIST_DUMMIES_OVERLAP], position, radius, bCheck2DOnly,

nCollidingEntities, maxEntitiesToFind, aEntities);

}

int16 maxEntitiesToFind, CEntity **aEntities, bool bBuildings, bool bVehicles,

bool bPeds, bool bObjects, bool bDummies)

{

*nIntersecting = 0;

for(int32 y = nStartY; y <= nEndY; y++) {

for(int32 x = nStartX; x <= nEndX; x++) {

if(bBuildings) {

vecStartPos, vecEndPos, nIntersecting,

maxEntitiesToFind, aEntities);

pSector->m_lists[ENTITYLIST_BUILDINGS_OVERLAP], vecStartPos, vecEndPos,

nIntersecting, maxEntitiesToFind, aEntities);

}

if(bVehicles) {

vecStartPos, vecEndPos, nIntersecting,

maxEntitiesToFind, aEntities);

pSector->m_lists[ENTITYLIST_VEHICLES_OVERLAP], vecStartPos, vecEndPos,

nIntersecting, maxEntitiesToFind, aEntities);

}

if(bPeds) {

vecStartPos, vecEndPos, nIntersecting,

maxEntitiesToFind, aEntities);

vecStartPos, vecEndPos, nIntersecting,

maxEntitiesToFind, aEntities);

}

if(bObjects) {

vecStartPos, vecEndPos, nIntersecting,

maxEntitiesToFind, aEntities);

pSector->m_lists[ENTITYLIST_OBJECTS_OVERLAP], vecStartPos, vecEndPos, nIntersecting,

maxEntitiesToFind, aEntities);

}

if(bDummies) {

vecStartPos, vecEndPos, nIntersecting,

maxEntitiesToFind, aEntities);

pSector->m_lists[ENTITYLIST_DUMMIES_OVERLAP], vecStartPos, vecEndPos, nIntersecting,

maxEntitiesToFind, aEntities);

}

CEntity **aEntities, bool bBuildings, bool bVehicles, bool bPeds,

bool bObjects, bool bDummies)

{

*nEntitiesFound = 0;

for(int32 y = nStartY; y <= nEndY; y++) {

for(int32 x = nStartX; x <= nEndX; x++) {

if(bBuildings) {

pSector->m_lists[ENTITYLIST_BUILDINGS], boundingBox, matrix, position,

nEntitiesFound, maxEntitiesToFind, aEntities);

pSector->m_lists[ENTITYLIST_BUILDINGS_OVERLAP], boundingBox, matrix, position,

nEntitiesFound, maxEntitiesToFind, aEntities);

}

if(bVehicles) {

pSector->m_lists[ENTITYLIST_VEHICLES], boundingBox, matrix, position,

nEntitiesFound, maxEntitiesToFind, aEntities);

pSector->m_lists[ENTITYLIST_VEHICLES_OVERLAP], boundingBox, matrix, position,

nEntitiesFound, maxEntitiesToFind, aEntities);

}

if(bPeds) {

pSector->m_lists[ENTITYLIST_PEDS], boundingBox, matrix, position, nEntitiesFound,

maxEntitiesToFind, aEntities);

pSector->m_lists[ENTITYLIST_PEDS_OVERLAP], boundingBox, matrix, position,

nEntitiesFound, maxEntitiesToFind, aEntities);

}

if(bObjects) {

pSector->m_lists[ENTITYLIST_OBJECTS], boundingBox, matrix, position, nEntitiesFound,

maxEntitiesToFind, aEntities);

pSector->m_lists[ENTITYLIST_OBJECTS_OVERLAP], boundingBox, matrix, position,

nEntitiesFound, maxEntitiesToFind, aEntities);

}

if(bDummies) {

pSector->m_lists[ENTITYLIST_DUMMIES], boundingBox, matrix, position, nEntitiesFound,

maxEntitiesToFind, aEntities);

pSector->m_lists[ENTITYLIST_DUMMIES_OVERLAP], boundingBox, matrix, position,

nEntitiesFound, maxEntitiesToFind, aEntities);

}

int16 maxEntitiesToFind, CEntity **aEntities, bool bVehicles, bool bPeds,

bool bObjects)

{

*nIntersecting = 0;

for(int32 y = nStartY; y <= nEndY; y++) {

for(int32 x = nStartX; x <= nEndX; x++) {

if(bVehicles) {

pSector->m_lists[ENTITYLIST_VEHICLES], vecStartPos, vecEndPos, nIntersecting,

maxEntitiesToFind, aEntities, true, false);

pSector->m_lists[ENTITYLIST_VEHICLES_OVERLAP], vecStartPos, vecEndPos,

nIntersecting, maxEntitiesToFind, aEntities, true, false);

}

if(bPeds) {

pSector->m_lists[ENTITYLIST_PEDS], vecStartPos, vecEndPos, nIntersecting,

maxEntitiesToFind, aEntities, false, true);

pSector->m_lists[ENTITYLIST_PEDS_OVERLAP], vecStartPos, vecEndPos, nIntersecting,

maxEntitiesToFind, aEntities, false, true);

}

if(bObjects) {

pSector->m_lists[ENTITYLIST_OBJECTS], vecStartPos, vecEndPos, nIntersecting,

maxEntitiesToFind, aEntities, false, false);

pSector->m_lists[ENTITYLIST_OBJECTS_OVERLAP], vecStartPos, vecEndPos, nIntersecting,

maxEntitiesToFind, aEntities, false, false);

}

}

}

CCarCtrl::RemoveFromInterestingVehicleList(pVehicle);

delete pVehicle;

}

}

void

CWorld::CallOffChaseForArea(float x1, float y1, float x2, float y2)

{

float fStartX = x1 - 10.0f;

float fStartY = y1 - 10.0f;

float fEndX = x2 + 10.0f;

float fEndY = y2 + 10.0f;

for(int32 y = nStartY; y <= nEndY; y++) {

for(int32 x = nStartX; x <= nEndX; x++) {

y2, fStartX, fStartY, fEndX, fEndY);

y1, x2, y2, fStartX, fStartY, fEndX, fEndY);

y2);

}

}

CSector *pSector = GetSector(i % NUMSECTORS_X, i / NUMSECTORS_Y);

for(CPtrNode *pNode = pSector->m_lists[ENTITYLIST_BUILDINGS].first; pNode; pNode = pNode->next) {

CEntity *pEntity = (CEntity *)pNode->item;

delete pEntity;

}

for(CPtrNode *pNode = pSector->m_lists[ENTITYLIST_VEHICLES].first; pNode; pNode = pNode->next) {

CEntity *pEntity = (CEntity *)pNode->item;

delete pEntity;

}

for(CPtrNode *pNode = pSector->m_lists[ENTITYLIST_PEDS].first; pNode; pNode = pNode->next) {

CEntity *pEntity = (CEntity *)pNode->item;

delete pEntity;

}

for(CPtrNode *pNode = pSector->m_lists[ENTITYLIST_OBJECTS].first; pNode; pNode = pNode->next) {

CEntity *pEntity = (CEntity *)pNode->item;

delete pEntity;

}

for(CPtrNode *pNode = pSector->m_lists[ENTITYLIST_DUMMIES].first; pNode; pNode = pNode->next) {

CEntity *pEntity = (CEntity *)pNode->item;

delete pEntity;

}

#ifndef FIX_BUGS

CSector *pSector = GetSector(i % NUMSECTORS_X, i / NUMSECTORS_Y);

for(CPtrNode *pNode = pSector->m_lists[ENTITYLIST_PEDS].first; pNode; pNode = pNode->next) {

CEntity *pEntity = (CEntity *)pNode->item;

delete pEntity;

}

for(CPtrNode *pNode = GetBigBuildingList(LEVEL_GENERIC).first; pNode; pNode = pNode->next) {

CVehicle *pVehicle = (CVehicle *)pNode->item;

if(pVehicle && pVehicle->IsVehicle() && pVehicle->IsPlane()) {

delete pVehicle;

}

}

for(CPtrNode *pNode = pSector->m_lists[ENTITYLIST_VEHICLES].first; pNode; pNode = pNode->next) {

CEntity *pEntity = (CEntity *)pNode->item;

delete pEntity;

}

}

modelId == MI_PARKTABLE) {

CVector &position = pEntity->GetMatrix().GetPosition();

float fBoundingBoxMinZ = pEntity->GetColModel()->boundingBox.min.z;

position.z + OBJECT_REPOSITION_OFFSET_Z, nil) -

fBoundingBoxMinZ;

pEntity->m_matrix.UpdateRW();

float fWaterLevel = 0.0f;

bool bFound = true;

const CVector &position = pEntity->GetPosition();

position.z + OBJECT_REPOSITION_OFFSET_Z, &bFound);

if(CWaterLevel::GetWaterLevelNoWaves(position.x, position.y, position.z + OBJECT_REPOSITION_OFFSET_Z,

&fWaterLevel)) {

CSector *pSector = GetSector(i % NUMSECTORS_X, i / NUMSECTORS_Y);

for(CPtrNode *pNode = pSector->m_lists[ENTITYLIST_BUILDINGS].first; pNode; pNode = pNode->next) {

CEntity *pEntity = (CEntity *)pNode->item;

delete pEntity;

}

for(CPtrNode *pNode = pSector->m_lists[ENTITYLIST_OBJECTS].first; pNode; pNode = pNode->next) {

CEntity *pEntity = (CEntity *)pNode->item;

delete pEntity;

}

for(CPtrNode *pNode = pSector->m_lists[ENTITYLIST_DUMMIES].first; pNode; pNode = pNode->next) {

CEntity *pEntity = (CEntity *)pNode->item;

delete pEntity;

}

pSector->m_lists[ENTITYLIST_BUILDINGS].Flush();

if(csObj->m_rwObject && RwObjectGetType(csObj->m_rwObject) == rpCLUMP &&

RpAnimBlendClumpGetFirstAssociation(csObj->GetClump())) {

RpAnimBlendClumpUpdateAnimations(csObj->GetClump(),

}

csObj->ProcessControl();

csObj->ProcessCollision();

#endif

RpAnimBlendClumpGetFirstAssociation(movingEnt->GetClump())) {

RpAnimBlendClumpUpdateAnimations(movingEnt->GetClump(),

}

}

for(CPtrNode *node = ms_listMovingEntityPtrs.first; node; node = node->next) {

{

CVector2D vecStartPos(position.x - fRadius, position.y - fRadius);

CVector2D vecEndPos(position.x + fRadius, position.y + fRadius);

for(int32 y = nStartY; y <= nEndY; y++) {

for(int32 x = nStartX; x <= nEndX; x++) {

fPower, pCreator, bProcessVehicleBombTimer);

pCreator, bProcessVehicleBombTimer);

fPower, pCreator, bProcessVehicleBombTimer);

}

}

if(!pEntity->GetIsStatic()) {

float fDamageMultiplier = Min((fRadius - fMagnitude) * 2.0f / fRadius, 1.0f);

CVector vecForceDir =

Max(fMagnitude, 0.01f));

vecForceDir.z = Max(vecForceDir.z, 0.0f);

if(pEntity == FindPlayerPed()) vecForceDir.z = Min(vecForceDir.z, 1.0f);

#define EXTENDED_COLOURFILTER // more options for colour filter (replaces mblur)

#define EXTENDED_PIPELINES // custom render pipelines (includes Neo)

#define SCREEN_DROPLETS // neo water droplets

#endif

#define FIX_SPRITES // fix sprites aspect ratio(moon, coronas, particle etc)

#define USE_BASIC_SCRIPT_DEBUG_OUTPUT

#endif

// Replay

//#define DONT_FIX_REPLAY_BUGS // keeps various bugs in CReplay, some of which are fairly cool!

//#define USE_BETA_REPLAY_MODE // adds another replay mode, a few seconds slomo (caution: buggy!)

// Audio

#define RADIO_SCROLL_TO_PREV_STATION

#endif

// IMG

#define BIG_IMG // allows to read larger img files

#undef NO_ISLAND_LOADING

#define PC_PARTICLE

#define VC_PED_PORTS // To not process collisions always. But should be tested if that's really beneficial

#endif

#ifdef LIBRW

#define FOUND_GAME_TO_LOAD b_FoundRecentSavedGameWantToLoad

#endif

void

ValidateVersion()

{

CameraSize(Scene.camera, nil, SCREEN_VIEWWINDOW, SCREEN_ASPECT_RATIO);

#endif

CVisibilityPlugins::SetRenderWareCamera(Scene.camera);

if(!RsCameraBeginUpdate(Scene.camera))

return false;

CameraSize(Scene.camera, nil, SCREEN_VIEWWINDOW, SCREEN_ASPECT_RATIO);

#endif

CVisibilityPlugins::SetRenderWareCamera(Scene.camera);

if(!RsCameraBeginUpdate(Scene.camera))

return false;

DebugMenuInit();

DebugMenuPopulate();

#endif // !DEBUGMENU

}

return (FALSE);

static void

Terminate3D(void)

{

CGame::ShutdownRenderWare();

#ifdef DEBUGMENU

DebugMenuShutdown();

}

#endif

void

RenderScene(void)

{

CClouds::Render();

DoRWRenderHorizon();

CRenderer::RenderRoads();

void

RenderEffects(void)

{

CGlass::Render();

CWaterCannons::Render();

CSpecialFX::Render();

PUSH_MEMID(MEMID_RENDERLIST);

tbStartTimer(0, "CnstrRenderList");

CRenderer::ConstructRenderList();

tbEndTimer("CnstrRenderList");

CameraSize(Scene.camera, nil, SCREEN_VIEWWINDOW, DEFAULT_ASPECT_RATIO);

#endif

CVisibilityPlugins::SetRenderWareCamera(Scene.camera);

if(!RsCameraBeginUpdate(Scene.camera))

goto popret;

}

CameraSize(Scene.camera, nil, SCREEN_VIEWWINDOW, DEFAULT_ASPECT_RATIO);

#endif

CVisibilityPlugins::SetRenderWareCamera(Scene.camera);

if(!RsCameraBeginUpdate(Scene.camera))

return;

CameraSize(Scene.camera, nil, SCREEN_VIEWWINDOW, DEFAULT_ASPECT_RATIO);

#endif

CVisibilityPlugins::SetRenderWareCamera(Scene.camera);

RsCameraBeginUpdate(Scene.camera);

}

void LoadINISettings();

void SaveINISettings();

#endif

void SaveINISettings()

{

bool changed = false;

#ifdef DONT_TRUST_RECOGNIZED_JOYSTICKS

if (strncmp(cfg.get("DetectJoystick", "JoystickName", "").c_str(), gSelectedJoystickName, strlen(gSelectedJoystickName)) != 0) {

DebugMenuAddVarBool8("Render", "Frame limiter", &FrontEndMenuManager.m_PrefsFrameLimiter, nil);

DebugMenuAddVarBool8("Render", "VSynch", &FrontEndMenuManager.m_PrefsVsync, nil);

DebugMenuAddVar("Render", "Max FPS", &RsGlobal.maxFPS, nil, 1, 1, 1000, nil);

#ifdef EXTENDED_COLOURFILTER

static const char *filternames[] = { "None", "Simple", "Normal", "Mobile" };

e = DebugMenuAddVar("Render", "Colourfilter", &CPostFX::EffectSwitch, nil, 1, CPostFX::POSTFX_OFF, CPostFX::POSTFX_MOBILE, filternames);

void

CEntity::UpdateRwFrame(void)

{

}

#ifdef PED_SKIN

void

CPhysical::RemoveRefsToEntity(CEntity *ent)

{

if(m_aCollisionRecords[i] == ent){

for(j = i; j < m_nCollisionRecords-1; j++)

m_aCollisionRecords[j] = m_aCollisionRecords[j+1];

m_nCollisionRecords--;

}

}

m_vecMoveSpeed *= f;

m_vecTurnSpeed *= f;

}else{

m_vecMoveSpeed *= f;

m_vecTurnSpeed *= 0.99f;

}

}

bool

CPhysical::ApplyCollision(CPhysical *B, CColPoint &colpoint, float &impulseA, float &impulseB)

{

impulseB = (speedSum - fOtherSpeedB) * B->m_fMass;

impulseLimit = adhesiveLimit*CTimer::GetTimeStep();

if(impulseA < -impulseLimit) impulseA = -impulseLimit;

A->ApplyFrictionMoveForce(frictionDir*impulseA);

B->ApplyFrictionMoveForce(frictionDir*impulseB);

return true;

if(fOtherSpeed > 0.0f){

frictionDir = vOtherSpeed * (1.0f/fOtherSpeed);

fImpulse = -fOtherSpeed * m_fMass;

if(fImpulse < -impulseLimit) fImpulse = -impulseLimit;

ApplyFrictionMoveForce(frictionDir*fImpulse);

ApplyFrictionTurnForce(frictionDir*fImpulse, pointpos);

skipShift = true;

Aobj->m_pCollidingEntity = B;

}

}else if(B->IsObject() && A->IsVehicle()){

CObject *Bobj = (CObject*)B;

if(Bobj->ObjectCreatedBy != TEMP_OBJECT &&

if(size.z < A->GetPosition().z ||

(Invert(A->GetMatrix(), inv) * size).z < 0.0f)

skipShift = true;

}else if(IsBodyPart(A->GetModelIndex()) && B->IsPed())

skipShift = true;

else if(A->IsPed() && IsBodyPart(B->GetModelIndex()))

void

CreateVehiclePipe(void)

{

printf("Error: couldn't open 'neo/carTweakingTable.dat'\n");

else{

char *fp = (char*)work_buff;

rw::d3d::destroyVertexShader(neoVehicle_VS);

neoVehicle_VS = nil;

((rw::d3d9::ObjPipeline*)vehiclePipe)->destroy();

vehiclePipe = nil;

}

void

CreateWorldPipe(void)

{

printf("Error: couldn't open 'neo/worldTweakingTable.dat'\n");

else

ReadTweakValueTable((char*)work_buff, WorldLightmapBlend);

void

DestroyGlossPipe(void)

{

((rw::d3d9::ObjPipeline*)glossPipe)->destroy();

glossPipe = nil;

}

void

CreateRimLightPipes(void)

{

printf("Error: couldn't open 'neo/rimTweakingTable.dat'\n");

else{

char *fp = (char*)work_buff;

using namespace rw;

using namespace rw::gl3;

printf("Error: couldn't open 'neo/carTweakingTable.dat'\n");

else{

char *fp = (char*)work_buff;

using namespace rw;

using namespace rw::gl3;

printf("Error: couldn't open 'neo/worldTweakingTable.dat'\n");

else

ReadTweakValueTable((char*)work_buff, WorldLightmapBlend);

{

using namespace rw::gl3;

printf("Error: couldn't open 'neo/rimTweakingTable.dat'\n");

else{

char *fp = (char*)work_buff;

option.m_TargetMenu = targetMenu;

}

{

int8 screenOptionOrder = RegisterNewOption();

option.m_CFOSelect->save = saveName;

option.m_CFOSelect->onlyApplyOnEnter = onlyApplyOnEnter;

option.m_CFOSelect->changeFunc = changeFunc;

}

void FrontendOptionAddDynamic(const char* gxtKey, DrawFunc drawFunc, int8 *var, ButtonPressFunc buttonPressFunc, const char* saveName)

// var is optional in AddDynamic, enables you to save them in an INI file(also needs passing char array to saveName param. obv), otherwise pass nil/0

void FrontendOptionAddBuiltinAction(const char* gxtKey, int action, int targetMenu = MENUPAGE_NONE, int saveSlot = SAVESLOT_NONE);

void FrontendOptionAddDynamic(const char* gxtKey, DrawFunc rightTextDrawFunc, int8 *var, ButtonPressFunc buttonPressFunc, const char* saveName = nil);

uint8 FrontendScreenAdd(const char* gxtKey, eMenuSprites sprite, int prevPage, int columnWidth, int headerHeight, int lineHeight, int8 font, float fontScaleX, float fontScaleY, int8 alignment, bool showLeftRightHelper, ReturnPrevPageFunc returnPrevPageFunc = nil);

/*

*

* This software is provided 'as-is', without any express or implied

* warranty. In no event will the authors be held liable for any damages

ScreenDroplets::RegisterSplash(CParticleObject *pobj)

{

CVector dist = pobj->GetPosition() - ms_prevCamPos;

ms_splashDuration = 14;

ms_splashObject = pobj;

}

using namespace rw;

RwUInt8 RwObjectGetType(const RwObject *obj) { return obj->type; }

void *RwMalloc(size_t size) { return engine->memfuncs.rwmalloc(size, 0); }

void *RwCalloc(size_t numObj, size_t sizeObj) {

//struct RwObject;

typedef rw::Object RwObject;

typedef RwObject *(*RwObjectCallBack)(RwObject *object, void *data);

RwUInt8 RwObjectGetType(const RwObject *obj);

#define rwsprintf sprintf

#define rwvsprintf vsprintf

m_pMyVehicle->SetStatus(STATUS_PHYSICS);

m_pMyVehicle->AutoPilot.m_nPrevRouteNode = 0;

if (m_nPedType == PEDTYPE_COP) {

m_pMyVehicle->AutoPilot.m_nCarMission = CCarAI::FindPoliceCarMissionForWantedLevel();

} else {

m_pMyVehicle->AutoPilot.m_nCarMission = MISSION_RAMPLAYER_FARAWAY;

}

m_pMyVehicle->AutoPilot.m_nDrivingStyle = DRIVINGSTYLE_AVOID_CARS;

for (int i = 0; i < m_maxWeaponTypeAllowed; i++) {

if (GetWeapon(i).m_nAmmoTotal > 0) {

eWeaponType weaponType = GetWeapon(i).m_eWeaponType;

SetCurrentWeapon(i);

return true;

}

CCarCtrl::SwitchVehicleToRealPhysics(m_pMyVehicle);

m_pMyVehicle->AutoPilot.m_nDrivingStyle = DRIVINGSTYLE_AVOID_CARS;

m_pMyVehicle->SetStatus(STATUS_PHYSICS);

}

} else

if (nearVehDriver && nearVehDriver != this && nearVehDriver->m_nPedType == m_nPedType) {

if (nearVeh->IsVehicleNormal() && nearVeh->IsCar()) {

nearVeh->AutoPilot.m_nCarMission = MISSION_RAMPLAYER_FARAWAY;

nearVeh->SetStatus(STATUS_PHYSICS);

nearVeh->AutoPilot.m_nTempAction = TEMPACT_NONE;

CAnimBlendAssociation *weaponAnimAssoc;

int32 weaponAnim;

float animStart;

float weaponAnimTime;

float animLoopEnd;

CWeaponInfo *ourWeapon;

bool attackShouldContinue;

float delayBetweenAnimAndFire;

CVector firePos;

weaponAnimAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ourWeapon->m_AnimToPlay);

attackShouldContinue = bIsAttacking;

reloadAnimAssoc = nil;

if (!weaponAnimAssoc) {

if (attackShouldContinue) {

weaponAnimAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ourWeapon->m_AnimToPlay, 8.0f);

}

else {

} else {

firePos = ourWeapon->m_vecFireOffset;

if (weaponAnimAssoc->animId == ourWeapon->m_Anim2ToPlay)

firePos.z = 0.7f * ourWeapon->m_fRadius - 1.0f;

firePos = GetMatrix() * firePos;

TransformToNode(firePos, weaponAnimAssoc->animId == ANIM_KICK_FLOOR ? PED_FOOTR : PED_HANDR);

} else {

firePos = GetMatrix() * firePos;

GetWeapon()->Fire(this, &firePos);

RemoveWeaponModel(ourWeapon->m_nModelId);

}

SelectGunIfArmed();

}

attackShouldContinue = false;

}

weaponAnimTime = weaponAnimAssoc->currentTime;

firePos = ourWeapon->m_vecFireOffset;

if (IsPlayer()) {

if (CPad::GetPad(0)->GetSprint()) {

// animBreakout is a member of WeaponInfo in VC, so it's me that added the below line.

if (!attackShouldContinue && weaponAnimAssoc->currentTime > animBreakOut) {

weaponAnimAssoc->blendDelta = -4.0f;

FinishedAttackCB(nil, this);

}

#endif

animLoopEnd = ourWeapon->m_fAnimLoopEnd;

animLoopEnd = 3.4f/6.0f;

weaponAnimTime = weaponAnimAssoc->currentTime;

// Anim loop end, either start the loop again or finish the attack

if (weaponAnimTime - 2.0f * weaponAnimAssoc->timeStep <= animLoopEnd

&& (bIsAttacking || CTimer::GetTimeInMilliseconds() < m_shootTimer)

&& GetWeapon()->m_eWeaponState != WEAPONSTATE_RELOADING) {

weaponAnim = weaponAnimAssoc->animId;

if (weaponAnim != ourWeapon->m_Anim2ToPlay || weaponAnim == ANIM_RBLOCK_CSHOOT) {

weaponAnimAssoc->Start(ourWeapon->m_fAnimLoopStart);

} else {

// Echoes of bullets, at the end of the attack. (Bug: doesn't play while reloading)

if (weaponAnimAssoc->currentTime - weaponAnimAssoc->timeStep <= ourWeapon->m_fAnimLoopEnd) {

case WEAPONTYPE_UZI:

DMAudio.PlayOneShot(m_audioEntityId, SOUND_WEAPON_UZI_BULLET_ECHO, 0.0f);

break;

}

// Fun fact: removing this part leds to reloading flamethrower

weaponAnimAssoc->flags |= ASSOC_DELETEFADEDOUT;

weaponAnimAssoc->flags &= ~ASSOC_RUNNING;

weaponAnimAssoc->blendDelta = -4.0f;

}

}

}

} else if (CWeaponInfo::GetWeaponInfo((eWeaponType)m_currentWeapon)->m_eWeaponFire != WEAPON_FIRE_MELEE) {

if (GetWeapon(m_currentWeapon).m_nAmmoTotal <= 0) {

}

}

}

}

#include "common.h"

#include "main.h"

#include "Treadable.h"

#include "Ped.h"

#include "Vehicle.h"

#include "Heli.h"

#include "Object.h"

#include "PathFind.h"

CEntity *CRenderer::ms_aVisibleEntityPtrs[NUMVISIBLEENTITIES];

CEntity *CRenderer::ms_aInVisibleEntityPtrs[NUMINVISIBLEENTITIES];

int32 CRenderer::ms_nNoOfInVisibleEntities;

CVector CRenderer::ms_vecCameraPosition;

CVehicle *CRenderer::m_pFirstPersonVehicle;

for(i = 0; i < ms_nNoOfVisibleEntities; i++)

ms_aVisibleEntityPtrs[i]->PreRender();

for (i = 0; i < ms_nNoOfInVisibleEntities; i++) {

#ifdef SQUEEZE_PERFORMANCE

if (ms_aInVisibleEntityPtrs[i]->IsVehicle() && ((CVehicle*)ms_aInVisibleEntityPtrs[i])->IsHeli())

RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)FALSE);

}

void

CRenderer::RenderRoads(void)

{

for(i = 0; i < ms_nNoOfVisibleEntities; i++){

t = (CTreadable*)ms_aVisibleEntityPtrs[i];

#ifndef MASTER

if(gbShowCarRoadGroups || gbShowPedRoadGroups){

int ind = 0;

for(i = 0; i < ms_nNoOfVisibleEntities; i++){

e = ms_aVisibleEntityPtrs[i];

continue;

#ifdef EXTENDED_PIPELINES

}

}

void

CRenderer::RenderFadingInEntities(void)

{

void

CRenderer::ConstructRenderList(void)

{

ms_nNoOfVisibleEntities = 0;

ms_nNoOfInVisibleEntities = 0;

ms_vecCameraPosition = TheCamera.GetPosition();

// unused

}

void

CRenderer::ScanBigBuildingList(CPtrList &list)

{

CPtrNode *node;

#endif

if(!ent->bZoneCulled){

if(SetupBigBuildingVisibility(ent) == VIS_VISIBLE)

#ifndef MASTER

EntitiesRendered++;

RenderedBigBuildings++;

if(IsEntityCullZoneVisible(ent)){

switch(SetupEntityVisibility(ent)){

case VIS_VISIBLE:

break;

case VIS_INVISIBLE:

if(!IsGlass(ent->GetModelIndex()))

break;

}

#endif

if(SetupEntityVisibility(ent) == VIS_STREAMME)

if(!m_loadingPriority || CStreaming::ms_numModelsRequested < 10)

CStreaming::RequestModel(ent->GetModelIndex(), 0);

if(IsEntityCullZoneVisible(ent)){

switch(SetupEntityVisibility(ent)){

case VIS_VISIBLE:

break;

case VIS_INVISIBLE:

if(!IsGlass(ent->GetModelIndex()))

break;

}

#endif

if(SetupEntityVisibility(ent) == VIS_STREAMME)

CStreaming::RequestModel(ent->GetModelIndex(), 0);

}else{

ent->m_scanCode = CWorld::GetCurrentScanCode();

switch(SetupEntityVisibility(ent)){

case VIS_VISIBLE:

break;

case VIS_OFFSCREEN:

dx = ms_vecCameraPosition.x - ent->GetPosition().x;

static CEntity *ms_aVisibleEntityPtrs[NUMVISIBLEENTITIES];

static int32 ms_nNoOfInVisibleEntities;

static CEntity *ms_aInVisibleEntityPtrs[NUMINVISIBLEENTITIES];

static CVector ms_vecCameraPosition;

static CVehicle *m_pFirstPersonVehicle;

static bool IsVehicleCullZoneVisible(CEntity *ent);

static void RemoveVehiclePedLights(CEntity *ent, bool reset);

};

CBrightLights::Render();

CShinyTexts::Render();

CMoneyMessages::Render();

C3dMarkers::Render();

}

void

CMoneyMessages::RegisterOne(CVector vecPos, const char *pText, uint8 bRed, uint8 bGreen, uint8 bBlue, float fSize, float fOpacity)

{

}

CRGBA FoamColour(255, 255, 255, 255);

RpAtomic *CWaterLevel::ms_pWavyAtomic;

RpGeometry *CWaterLevel::apGeomArray[8];

int16 CWaterLevel::nGeomUsed;

bool gbDontRenderWater;

//RwTexture *gpWaterTex;

void

CWaterLevel::RenderWater()

{

#ifndef MASTER

if (gbDontRenderWater)

return;

}

// Rain

float fNewRain;

if (NewWeatherType == WEATHER_RAINY) {

// if raining for >1 hour, values: 0, 0.33, 0.66, 0.99, switching every ~16.5s

else

Rain = Max(fNewRain, Rain - RAIN_CHANGE_SPEED * CTimer::GetTimeStep());

}

// Clouds

if (OldWeatherType != WEATHER_SUNNY)

#include "RwHelper.h"

#include "templates.h"

#include "Entity.h"

#include "ModelInfo.h"

#include "Lights.h"

CLinkList<CVisibilityPlugins::AlphaObjectInfo> CVisibilityPlugins::m_alphaList;

CLinkList<CVisibilityPlugins::AlphaObjectInfo> CVisibilityPlugins::m_alphaEntityList;

int32 CVisibilityPlugins::ms_atomicPluginOffset = -1;

int32 CVisibilityPlugins::ms_framePluginOffset = -1;

#endif // ASPECT_RATIO_SCALE

m_alphaEntityList.head.item.sort = 0.0f;

m_alphaEntityList.tail.item.sort = 100000000.0f;

}

void

{

m_alphaList.Shutdown();

m_alphaEntityList.Shutdown();

}

void

CVisibilityPlugins::InitAlphaEntityList(void)

{

m_alphaEntityList.Clear();

}

bool

AlphaObjectInfo item;

item.entity = e;

item.sort = dist;

bool ret = !!m_alphaEntityList.InsertSorted(item);

// if(!ret)

// printf("list full %d\n", m_alphaEntityList.Count());

static CLinkList<AlphaObjectInfo> m_alphaList;

static CLinkList<AlphaObjectInfo> m_alphaEntityList;

static RwCamera *ms_pCamera;

static RwV3d *ms_pCameraPosn;

static float ms_cullCompsDist;

CVector vecDAMAGE_ENGINE_POS_SMALL(-0.1f, -0.1f, 0.0f);

CVector vecDAMAGE_ENGINE_POS_BIG(-0.5f, -0.3f, 0.0f);

void

CAutomobile::ProcessControl(void)

{

int i;

float wheelRot;

CColModel *colModel;

if(bUsingSpecialColModel)

colModel = &CWorld::Players[CWorld::PlayerInFocus].m_ColModel;

break;

}

if(skipPhysics){

bHasContacted = false;

bIsInSafePosition = false;

traction *= 4.0f;

if(FindPlayerVehicle() && FindPlayerVehicle() == this){

if(m_bombType == CARBOMB_TIMED){

m_bombType = CARBOMB_TIMEDACTIVE;

m_nBombTimer = 7000;

}

}

void

CAutomobile::Teleport(CVector pos)

{

#include "common.h"

#include "General.h"

#include "Timecycle.h"

#include "HandlingMgr.h"

((CVehicleModelInfo*)CModelInfo::GetModelInfo(GetModelIndex()))->SetVehicleColour(m_currentColour1, m_currentColour2);

if (!CVehicle::bWheelsOnlyCheat)

CEntity::Render();

KeepWaterOutIndices[0] = 0;

KeepWaterOutIndices[1] = 2;

KeepWaterOutIndices[2] = 1;

KeepWaterOutVertices[2].v = 1.0f;

KeepWaterOutVertices[3].u = 1.0f;

KeepWaterOutVertices[3].v = 1.0f;

RwRenderStateSet(rwRENDERSTATETEXTURERASTER, gpWaterRaster);

RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);

RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)FALSE);

RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDZERO);

RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDONE);

if (!CVehicle::bWheelsOnlyCheat && RwIm3DTransform(KeepWaterOutVertices, 4, GetMatrix().m_attachment, rwIM3D_VERTEXUV)) {

RwIm3DRenderIndexedPrimitive(rwPRIMTYPETRILIST, KeepWaterOutIndices, 6);

RwIm3DEnd();

}

RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)TRUE);

RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);

RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);

}

void

CBoat::Teleport(CVector v)

virtual bool IsComponentPresent(int32 component) { return true; }

virtual void BlowUpCar(CEntity *ent);

void ApplyWaterResistance(void);

void SetupModelNodes();

void PruneWakeTrail(void);

case 11: handling->fTractionBias = strtod(word, nil); break;

case 12: handling->Transmission.nNumberOfGears = atoi(word); break;

case 13: handling->Transmission.fMaxVelocity = strtod(word, nil); break;

case 15: handling->Transmission.nDriveType = word[0]; break;

case 16: handling->Transmission.nEngineType = word[0]; break;

case 17: handling->fBrakeDeceleration = strtod(word, nil); break;

cHandlingDataMgr::ConvertDataToGameUnits(tHandlingData *handling)

{

// acceleration is in ms^-2, but we need mf^-2 where f is one frame time (50fps)

handling->Transmission.fEngineAcceleration *= 1.0f/(50.0f*50.0f);

handling->Transmission.fMaxVelocity *= 1000.0f/(60.0f*60.0f * 50.0f);

handling->fInvMass = 1.0f/handling->fMass;

handling->fBuoyancy = 100.0f/handling->nPercentSubmerged * GRAVITY*handling->fMass;

a = 0.0f;

b = 100.0f;

velocity = handling->Transmission.fMaxVelocity;

while(a < b && velocity > 0.0f){

velocity -= 0.01f;

a = handling->Transmission.fEngineAcceleration/6.0f;

}

if(handling->nIdentifier == HANDLING_RCBANDIT){

}else{

handling->Transmission.fMaxVelocity = velocity * 1.2f;

}

handling->Transmission.fMaxReverseVelocity = -0.2f;

else

fCheat = 1.0f;

float targetVelocity = Gears[gear].fMaxVelocity*speedMul*fCheat;

if(Abs(fVelocity) < Abs(Gears[gear].fMaxVelocity*fCheat))

fAcceleration = gasPedal * accel * CTimer::GetTimeStep();

else

uint8 Flags;

float fEngineAcceleration;

float fMaxVelocity;

float fMaxReverseVelocity;

float fCurVelocity;

if(!bBraking){

if(m_fGasPedal < 0.01f){

if(GetModelIndex() == MI_RCBANDIT)

else

#ifdef FIX_BUGS

brake *= CTimer::GetTimeStepFix();

#endif

if (m_randomSeed < DAMAGE_FLEE_IN_CAR_PROBABILITY_VALUE) {

CCarCtrl::SwitchVehicleToRealPhysics(this);

AutoPilot.m_nDrivingStyle = DRIVINGSTYLE_AVOID_CARS;

SetStatus(STATUS_PHYSICS);

}

}

#endif

int n = 0;

while (gaExplosion[n].m_nIteration != 0 && n < ARRAY_SIZE(gaExplosion))

n++;

if (n == ARRAY_SIZE(gaExplosion))

return false;

}

int i = 0;

while (gaProjectileInfo[i].m_bInUse && i < ARRAY_SIZE(gaProjectileInfo)) i++;

if (i == ARRAY_SIZE(gaProjectileInfo))

return false;