//g_vehicleLoad.cpp // leave this line at the top for all NPC_xxxx.cpp files... #include "g_headers.h" #include "../qcommon/q_shared.h" #include "anims.h" #include "g_vehicles.h" extern qboolean G_ParseLiteral( const char **data, const char *string ); extern void G_CreateG2AttachedWeaponModel( gentity_t *ent, const char *weaponModel, int boltNum, int weaponNum ); vehicleInfo_t g_vehicleInfo[MAX_VEHICLES]; int numVehicles = 1;//first one is null/default typedef enum { VF_INT, VF_FLOAT, VF_LSTRING, // string on disk, pointer in memory, TAG_LEVEL VF_VECTOR, VF_BOOL, VF_VEHTYPE, VF_ANIM } vehFieldType_t; typedef struct { char *name; int ofs; vehFieldType_t type; } vehField_t; vehField_t vehFields[VEH_PARM_MAX] = { {"name", VFOFS(name), VF_LSTRING}, //unique name of the vehicle //general data {"type", VFOFS(type), VF_VEHTYPE}, //what kind of vehicle {"numHands", VFOFS(numHands), VF_INT}, //if 2 hands, no weapons, if 1 hand, can use 1-handed weapons, if 0 hands, can use 2-handed weapons {"lookPitch", VFOFS(lookPitch), VF_FLOAT}, //How far you can look up and down off the forward of the vehicle {"lookYaw", VFOFS(lookYaw), VF_FLOAT}, //How far you can look left and right off the forward of the vehicle {"length", VFOFS(length), VF_FLOAT}, //how long it is - used for body length traces when turning/moving? {"width", VFOFS(width), VF_FLOAT}, //how wide it is - used for body length traces when turning/moving? {"height", VFOFS(height), VF_FLOAT}, //how tall it is - used for body length traces when turning/moving? {"centerOfGravity", VFOFS(centerOfGravity), VF_VECTOR},//offset from origin: {forward, right, up} as a modifier on that dimension (-1.0f is all the way back, 1.0f is all the way forward) //speed stats {"speedMax", VFOFS(speedMax), VF_FLOAT}, //top speed {"turboSpeed", VFOFS(turboSpeed), VF_FLOAT}, //turbo speed {"speedMin", VFOFS(speedMin), VF_FLOAT}, //if < 0, can go in reverse {"speedIdle", VFOFS(speedIdle), VF_FLOAT}, //what speed it drifts to when no accel/decel input is given {"accelIdle", VFOFS(accelIdle), VF_FLOAT}, //if speedIdle > 0, how quickly it goes up to that speed {"acceleration", VFOFS(acceleration), VF_FLOAT}, //when pressing on accelerator {"decelIdle", VFOFS(decelIdle), VF_FLOAT}, //when giving no input, how quickly it drops to speedIdle {"strafePerc", VFOFS(strafePerc), VF_FLOAT}, //multiplier on current speed for strafing. If 1.0f, you can strafe at the same speed as you're going forward, 0.5 is half, 0 is no strafing //handling stats {"bankingSpeed", VFOFS(bankingSpeed), VF_FLOAT}, //how quickly it pitches and rolls (not under player control) {"pitchLimit", VFOFS(pitchLimit), VF_FLOAT}, //how far it can roll forward or backward {"rollLimit", VFOFS(rollLimit), VF_FLOAT}, //how far it can roll to either side {"braking", VFOFS(braking), VF_FLOAT}, //when pressing on decelerator {"turningSpeed", VFOFS(turningSpeed), VF_FLOAT}, //how quickly you can turn {"turnWhenStopped", VFOFS(turnWhenStopped), VF_BOOL},//whether or not you can turn when not moving {"traction", VFOFS(traction), VF_FLOAT}, //how much your command input affects velocity {"friction", VFOFS(friction), VF_FLOAT}, //how much velocity is cut on its own {"maxSlope", VFOFS(maxSlope), VF_FLOAT}, //the max slope that it can go up with control //durability stats {"mass", VFOFS(mass), VF_INT}, //for momentum and impact force (player mass is 10) {"armor", VFOFS(armor), VF_INT}, //total points of damage it can take {"toughness", VFOFS(toughness), VF_FLOAT}, //modifies incoming damage, 1.0 is normal, 0.5 is half, etc. Simulates being made of tougher materials/construction {"malfunctionArmorLevel", VFOFS(malfunctionArmorLevel), VF_INT},//when armor drops to or below this point, start malfunctioning //visuals & sounds {"model", VFOFS(model), VF_LSTRING}, //what model to use - if make it an NPC's primary model, don't need this? {"skin", VFOFS(skin), VF_LSTRING}, //what skin to use - if make it an NPC's primary model, don't need this? {"riderAnim", VFOFS(riderAnim), VF_ANIM}, //what animation the rider uses {"gunswivelBone", VFOFS(gunswivelBone), VF_LSTRING},//gun swivel bones {"lFinBone", VFOFS(lFinBone), VF_LSTRING}, //left fin bone {"rFinBone", VFOFS(rFinBone), VF_LSTRING}, //right fin bone {"lExhaustTag", VFOFS(lExhaustTag), VF_LSTRING}, //left exhaust tag {"rExhaustTag", VFOFS(rExhaustTag), VF_LSTRING}, //right exhaust tag {"soundOn", VFOFS(soundOn), VF_LSTRING}, //sound to play when get on it {"soundLoop", VFOFS(soundLoop), VF_LSTRING}, //sound to loop while riding it {"soundOff", VFOFS(soundOff), VF_LSTRING}, //sound to play when get off {"exhaustFX", VFOFS(exhaustFX), VF_LSTRING}, //exhaust effect, played from "*exhaust" bolt(s) {"trailFX", VFOFS(trailFX), VF_LSTRING}, //trail effect, played from "*trail" bolt(s) {"impactFX", VFOFS(impactFX), VF_LSTRING}, //impact effect, for when it bumps into something {"explodeFX", VFOFS(explodeFX), VF_LSTRING}, //explosion effect, for when it blows up (should have the sound built into explosion effect) {"wakeFX", VFOFS(wakeFX), VF_LSTRING}, //effect it makes when going across water //other misc stats {"gravity", VFOFS(gravity), VF_INT}, //normal is 800 {"hoverHeight", VFOFS(hoverHeight), VF_FLOAT}, //if 0, it's a ground vehicle {"hoverStrength", VFOFS(hoverStrength), VF_FLOAT}, //how hard it pushes off ground when less than hover height... causes "bounce", like shocks {"waterProof", VFOFS(waterProof), VF_BOOL}, //can drive underwater if it has to {"bouyancy", VFOFS(bouyancy), VF_FLOAT}, //when in water, how high it floats (1 is neutral bouyancy) {"fuelMax", VFOFS(fuelMax), VF_INT}, //how much fuel it can hold (capacity) {"fuelRate", VFOFS(fuelRate), VF_INT}, //how quickly is uses up fuel {"visibility", VFOFS(visibility), VF_INT}, //for sight alerts {"loudness", VFOFS(loudness), VF_INT}, //for sound alerts {"explosionRadius", VFOFS(explosionRadius), VF_FLOAT},//range of explosion {"explosionDamage", VFOFS(explosionDamage), VF_INT},//damage of explosion //new stuff {"maxPassengers", VFOFS(maxPassengers), VF_INT}, // The max number of passengers this vehicle may have (Default = 0). {"hideRider", VFOFS(hideRider), VF_BOOL }, // rider (and passengers?) should not be drawn {"killRiderOnDeath", VFOFS(killRiderOnDeath), VF_BOOL },//if rider is on vehicle when it dies, they should die {"flammable", VFOFS(flammable), VF_BOOL }, //whether or not the vehicle should catch on fire before it explodes {"explosionDelay", VFOFS(explosionDelay), VF_INT}, //how long the vehicle should be on fire/dying before it explodes //camera stuff {"cameraOverride", VFOFS(cameraOverride), VF_BOOL }, //override the third person camera with the below values - normal is 0 (off) {"cameraRange", VFOFS(cameraRange), VF_FLOAT}, //how far back the camera should be - normal is 80 {"cameraVertOffset", VFOFS(cameraVertOffset), VF_FLOAT},//how high over the vehicle origin the camera should be - normal is 16 {"cameraHorzOffset", VFOFS(cameraHorzOffset), VF_FLOAT},//how far to left/right (negative/positive) of of the vehicle origin the camera should be - normal is 0 {"cameraPitchOffset", VFOFS(cameraPitchOffset), VF_FLOAT},//a modifier on the camera's pitch (up/down angle) to the vehicle - normal is 0 {"cameraFOV", VFOFS(cameraFOV), VF_FLOAT}, //third person camera FOV, default is 80 {"cameraAlpha", VFOFS(cameraAlpha), VF_BOOL }, //fade out the vehicle if it's in the way of the crosshair }; stringID_table_t VehicleTable[VH_NUM_VEHICLES+1] = { ENUM2STRING(VH_WALKER), //something you ride inside of, it walks like you, like an AT-ST ENUM2STRING(VH_FIGHTER), //something you fly inside of, like an X-Wing or TIE fighter ENUM2STRING(VH_SPEEDER), //something you ride on that hovers, like a speeder or swoop ENUM2STRING(VH_ANIMAL), //animal you ride on top of that walks, like a tauntaun ENUM2STRING(VH_FLIER), //animal you ride on top of that flies, like a giant mynoc? "", -1 }; void G_VehicleSetDefaults( vehicleInfo_t *vehicle ) { vehicle->name = "default"; //unique name of the vehicle /* //general data vehicle->type = VH_SPEEDER; //what kind of vehicle //FIXME: no saber or weapons if numHands = 2, should switch to speeder weapon, no attack anim on player vehicle->numHands = 2; //if 2 hands, no weapons, if 1 hand, can use 1-handed weapons, if 0 hands, can use 2-handed weapons vehicle->lookPitch = 35; //How far you can look up and down off the forward of the vehicle vehicle->lookYaw = 5; //How far you can look left and right off the forward of the vehicle vehicle->length = 0; //how long it is - used for body length traces when turning/moving? vehicle->width = 0; //how wide it is - used for body length traces when turning/moving? vehicle->height = 0; //how tall it is - used for body length traces when turning/moving? VectorClear( vehicle->centerOfGravity );//offset from origin: {forward, right, up} as a modifier on that dimension (-1.0f is all the way back, 1.0f is all the way forward) //speed stats - note: these are DESIRED speed, not actual current speed/velocity vehicle->speedMax = VEH_DEFAULT_SPEED_MAX; //top speed vehicle->turboSpeed = 0; //turboBoost vehicle->speedMin = 0; //if < 0, can go in reverse vehicle->speedIdle = 0; //what speed it drifts to when no accel/decel input is given vehicle->accelIdle = 0; //if speedIdle > 0, how quickly it goes up to that speed vehicle->acceleration = VEH_DEFAULT_ACCEL; //when pressing on accelerator (1/2 this when going in reverse) vehicle->decelIdle = VEH_DEFAULT_DECEL; //when giving no input, how quickly it desired speed drops to speedIdle vehicle->strafePerc = VEH_DEFAULT_STRAFE_PERC;//multiplier on current speed for strafing. If 1.0f, you can strafe at the same speed as you're going forward, 0.5 is half, 0 is no strafing //handling stats vehicle->bankingSpeed = VEH_DEFAULT_BANKING_SPEED; //how quickly it pitches and rolls (not under player control) vehicle->rollLimit = VEH_DEFAULT_ROLL_LIMIT; //how far it can roll to either side vehicle->pitchLimit = VEH_DEFAULT_PITCH_LIMIT; //how far it can pitch forward or backward vehicle->braking = VEH_DEFAULT_BRAKING; //when pressing on decelerator (backwards) vehicle->turningSpeed = VEH_DEFAULT_TURNING_SPEED; //how quickly you can turn vehicle->turnWhenStopped = qfalse; //whether or not you can turn when not moving vehicle->traction = VEH_DEFAULT_TRACTION; //how much your command input affects velocity vehicle->friction = VEH_DEFAULT_FRICTION; //how much velocity is cut on its own vehicle->maxSlope = VEH_DEFAULT_MAX_SLOPE; //the max slope that it can go up with control //durability stats vehicle->mass = VEH_DEFAULT_MASS; //for momentum and impact force (player mass is 10) vehicle->armor = VEH_DEFAULT_MAX_ARMOR; //total points of damage it can take vehicle->toughness = VEH_DEFAULT_TOUGHNESS; //modifies incoming damage, 1.0 is normal, 0.5 is half, etc. Simulates being made of tougher materials/construction vehicle->malfunctionArmorLevel = 0; //when armor drops to or below this point, start malfunctioning //visuals & sounds vehicle->model = "swoop"; //what model to use - if make it an NPC's primary model, don't need this? vehicle->modelIndex = 0; //set internally, not until this vehicle is spawned into the level vehicle->skin = NULL; //what skin to use - if make it an NPC's primary model, don't need this? vehicle->riderAnim = BOTH_GUNSIT1; //what animation the rider uses vehicle->gunswivelBone = NULL; //gun swivel bones vehicle->lFinBone = NULL; //left fin bone vehicle->rFinBone = NULL; //right fin bone vehicle->lExhaustTag = NULL; //left exhaust tag vehicle->rExhaustTag = NULL; //right exhaust tag vehicle->soundOn = NULL; //sound to play when get on it vehicle->soundLoop = NULL; //sound to loop while riding it vehicle->soundOff = NULL; //sound to play when get off vehicle->exhaustFX = NULL; //exhaust effect, played from "*exhaust" bolt(s) vehicle->trailFX = NULL; //trail effect, played from "*trail" bolt(s) vehicle->impactFX = NULL; //explosion effect, for when it blows up (should have the sound built into explosion effect) vehicle->explodeFX = NULL; //explosion effect, for when it blows up (should have the sound built into explosion effect) vehicle->wakeFX = NULL; //effect itmakes when going across water //other misc stats vehicle->gravity = VEH_DEFAULT_GRAVITY; //normal is 800 vehicle->hoverHeight = 0; //if 0, it's a ground vehicle vehicle->hoverStrength = 0;//how hard it pushes off ground when less than hover height... causes "bounce", like shocks vehicle->waterProof = qtrue; //can drive underwater if it has to vehicle->bouyancy = 1.0f; //when in water, how high it floats (1 is neutral bouyancy) vehicle->fuelMax = 1000; //how much fuel it can hold (capacity) vehicle->fuelRate = 1; //how quickly is uses up fuel vehicle->visibility = VEH_DEFAULT_VISIBILITY; //radius for sight alerts vehicle->loudness = VEH_DEFAULT_LOUDNESS; //radius for sound alerts vehicle->explosionRadius = VEH_DEFAULT_EXP_RAD; vehicle->explosionDamage = VEH_DEFAULT_EXP_DMG; //new stuff vehicle->maxPassengers = 0; vehicle->hideRider = qfalse; // rider (and passengers?) should not be drawn vehicle->killRiderOnDeath = qfalse; //if rider is on vehicle when it dies, they should die vehicle->flammable = qfalse; //whether or not the vehicle should catch on fire before it explodes vehicle->explosionDelay = 0; //how long the vehicle should be on fire/dying before it explodes //camera stuff vehicle->cameraOverride = qfalse; //whether or not to use all of the following 3rd person camera override values vehicle->cameraRange = 0.0f; //how far back the camera should be - normal is 80 vehicle->cameraVertOffset = 0.0f; //how high over the vehicle origin the camera should be - normal is 16 vehicle->cameraHorzOffset = 0.0f; //how far to left/right (negative/positive) of of the vehicle origin the camera should be - normal is 0 vehicle->cameraPitchOffset = 0.0f; //a modifier on the camera's pitch (up/down angle) to the vehicle - normal is 0 vehicle->cameraFOV = 0.0f; //third person camera FOV, default is 80 vehicle->cameraAlpha = qfalse; //fade out the vehicle if it's in the way of the crosshair */ } void G_VehicleClampData( vehicleInfo_t *vehicle ) {//sanity check and clamp the vehicle's data int i; for ( i = 0; i < 3; i++ ) { if ( vehicle->centerOfGravity[i] > 1.0f ) { vehicle->centerOfGravity[i] = 1.0f; } else if ( vehicle->centerOfGravity[i] < -1.0f ) { vehicle->centerOfGravity[i] = -1.0f; } } // Validate passenger max. if ( vehicle->maxPassengers > VEH_MAX_PASSENGERS ) { vehicle->maxPassengers = VEH_MAX_PASSENGERS; } else if ( vehicle->maxPassengers < 0 ) { vehicle->maxPassengers = 0; } } static void G_ParseVehicleParms( vehicleInfo_t *vehicle, const char **holdBuf ) { const char *token; const char *value; int i; vec3_t vec; byte *b = (byte *)vehicle; int _iFieldsRead = 0; vehicleType_t vehType; while ( holdBuf ) { token = COM_ParseExt( holdBuf, qtrue ); if ( !token[0] ) { gi.Printf( S_COLOR_RED"ERROR: unexpected EOF while parsing vehicles!\n" ); return; } if ( !Q_stricmp( token, "}" ) ) // End of data for this vehicle { break; } // Loop through possible parameters for ( i = 0; i < VEH_PARM_MAX; i++ ) { if ( vehFields[i].name && !Q_stricmp( vehFields[i].name, token ) ) { // found it if ( COM_ParseString( holdBuf, &value ) ) { continue; } switch( vehFields[i].type ) { case VF_INT: *(int *)(b+vehFields[i].ofs) = atoi(value); break; case VF_FLOAT: *(float *)(b+vehFields[i].ofs) = atof(value); break; case VF_LSTRING: // string on disk, pointer in memory, TAG_LEVEL *(char **)(b+vehFields[i].ofs) = G_NewString( value ); break; case VF_VECTOR: _iFieldsRead = sscanf (value, "%f %f %f", &vec[0], &vec[1], &vec[2]); assert(_iFieldsRead==3 ); if (_iFieldsRead!=3) { gi.Printf (S_COLOR_YELLOW"G_ParseVehicleParms: VEC3 sscanf() failed to read 3 floats ('angle' key bug?)\n"); } ((float *)(b+vehFields[i].ofs))[0] = vec[0]; ((float *)(b+vehFields[i].ofs))[1] = vec[1]; ((float *)(b+vehFields[i].ofs))[2] = vec[2]; break; case VF_BOOL: *(qboolean *)(b+vehFields[i].ofs) = (atof(value)!=0); break; case VF_VEHTYPE: vehType = (vehicleType_t)GetIDForString( VehicleTable, value ); *(vehicleType_t *)(b+vehFields[i].ofs) = vehType; break; case VF_ANIM: int anim = GetIDForString( animTable, value ); *(int *)(b+vehFields[i].ofs) = anim; break; } break; } } } } static void G_VehicleStoreParms( const char *p ) {//load up all into a table: g_vehicleInfo const char *token; vehicleInfo_t *vehicle; ////////////////// HERE ////////////////////// // The first vehicle just contains all the base level (not 'overridden') function calls. G_SetSharedVehicleFunctions( &g_vehicleInfo[0] ); numVehicles = 1; //try to parse data out COM_BeginParseSession(); //look for an open brace while ( p ) { token = COM_ParseExt( &p, qtrue ); if ( token[0] == 0 ) {//barf return; } if ( !Q_stricmp( token, "{" ) ) {//found one, parse out the goodies if ( numVehicles >= MAX_VEHICLES ) {//sorry, no more vehicle slots! gi.Printf( S_COLOR_RED"Too many vehicles in *.veh (limit %d)\n", MAX_VEHICLES ); break; } //token = token; vehicle = &g_vehicleInfo[numVehicles++]; G_VehicleSetDefaults( vehicle ); G_ParseVehicleParms( vehicle, &p ); //sanity check and clamp the vehicle's data G_VehicleClampData( vehicle ); ////////////////// HERE ////////////////////// // Setup the shared function pointers. G_SetSharedVehicleFunctions( vehicle ); switch( vehicle->type ) { case VH_SPEEDER: G_SetSpeederVehicleFunctions( vehicle ); break; case VH_ANIMAL: G_SetAnimalVehicleFunctions( vehicle ); break; case VH_FIGHTER: G_SetFighterVehicleFunctions( vehicle ); break; case VH_WALKER: G_SetAnimalVehicleFunctions( vehicle ); break; } } } } void G_VehicleLoadParms( void ) {//HMM... only do this if there's a vehicle on the level? int len, totallen, vehExtFNLen, fileCnt, i; char *buffer, *holdChar, *marker; char vehExtensionListBuf[2048]; // The list of file names read in #define MAX_VEHICLE_DATA_SIZE 0x20000 char VehicleParms[MAX_VEHICLE_DATA_SIZE]={0}; // gi.Printf( "Parsing *.veh vehicle definitions\n" ); //set where to store the first one totallen = 0; marker = VehicleParms; //now load in the .veh vehicle definitions fileCnt = gi.FS_GetFileList("ext_data/vehicles", ".veh", vehExtensionListBuf, sizeof(vehExtensionListBuf) ); holdChar = vehExtensionListBuf; for ( i = 0; i < fileCnt; i++, holdChar += vehExtFNLen + 1 ) { vehExtFNLen = strlen( holdChar ); //gi.Printf( "Parsing %s\n", holdChar ); len = gi.FS_ReadFile( va( "ext_data/vehicles/%s", holdChar), (void **) &buffer ); if ( len == -1 ) { gi.Printf( "G_VehicleLoadParms: error reading file %s\n", holdChar ); } else { if ( totallen && *(marker-1) == '}' ) {//don't let it end on a } because that should be a stand-alone token strcat( marker, " " ); totallen++; marker++; } if ( totallen + len >= MAX_VEHICLE_DATA_SIZE ) { G_Error( "G_VehicleLoadParms: ran out of space before reading %s\n(you must make the .npc files smaller)", holdChar ); } strcat( marker, buffer ); gi.FS_FreeFile( buffer ); totallen += len; marker += len; } } G_VehicleStoreParms(VehicleParms); }