dhewm/dhewm3-sdk
0
0
Fork 0
mirror of https://github.com/dhewm/dhewm3-sdk.git synced 2025-04-05 00:50:56 +00:00
Code Issues Projects Releases Packages Wiki Activity

Import Denton's Enhanced Doom3 Mod

Browse source
This commit is contained in:
Daniel Gibson 2018-08-26 05:41:08 +02:00
parent 4dd278d6fb
commit 7bfaf4cbf7
30 changed files with 4042 additions and 184 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
CMakeLists.txt
View file

@ -2,10 +2,10 @@ cmake_minimum_required(VERSION 3.0 FATAL_ERROR)
project(dhewm3sdk)
option(BASE "Build the base (game/) game code" ON)
set(BASE_NAME "base" CACHE STRING "Name of the mod built from game/ (will result in \${BASE_NAME}.dll)")
set(BASE_DEFS "GAME_DLL" CACHE STRING "Compiler definitions for the mod built from game/")
set(BASE_NAME "dentonmod" CACHE STRING "Name of the mod built from game/ (will result in \${BASE_NAME}.dll)")
set(BASE_DEFS "GAME_DLL;_PORTALSKY;_DENTONMOD" CACHE STRING "Compiler definitions for the mod built from game/")
option(D3XP "Build the d3xp/ game code" ON)
option(D3XP "Build the d3xp/ game code" OFF)
set(D3XP_NAME "d3xp" CACHE STRING "Name of the mod built from d3xp/ (will result in \${D3XP_NAME}.dll)")
set(D3XP_DEFS "GAME_DLL;_D3XP;CTF" CACHE STRING "Compiler definitions for the mod built from d3xp/")
@ -15,6 +15,7 @@ set(src_game_mod
# add additional .cpp files of your mod in game/
# (that you added to the ones already existant in the SDK/in dhewm3)
# like "game/MyFile.cpp" (without quotes, one file per line)
game/tracer.cpp
)
set(src_d3xp_mod

220
README.txt Normal file
View file

@ -0,0 +1,220 @@
NOTE from Daniel:
The following is (mostly) the original README of the mod and may refer to stuff that
is not contained in this sourcecode like shaders and other game data.
You can download the orignal mod (including the game data) from:
http://doom3.filefront.com/file/Dentons_Enhanced_Doom3;76838
(Or search for dentons_enhanced_doom3_2.02.zip)
Download it, unzip it and unzip the contained zip to your Doom3/dhewm3 installation
BUT MAKE SURE to rename the Dentonmod/ dir to dentonmod/, as doom3 doesn't like
uppercase characters in paths (while it works on Windows, it doesn't on Linux,
FreeBSD and possibly OSX!)
After compiling the source, you can start the game with
./dhewm3 +set fs_game dentonmod
A big THANK YOU to "Clone JC Denton" for releasing his mod under GPL!
The original ReadMe:
==================================================================================================
------------------------------ Denton's Enhanced Doom3 --------------------------------------------
==================================================================================================
By - Clone JC Denton (AKA Vicky Jadhav)
Contact- clone_jc_denton AT yahoo DOT com
==============================================
THANK YOU!
Thank you for downloading this mod.
======================================================================================
OVERVIEW
======================================================================================
This mod is version 2.02 of Denton's SDK based enhancement (Rated 9.7 out of 10 by filefront community). I received a very nice feedback as well as some constructive criticism from the people who played the previous version and therefore, in addition to many new features, this version tries to fix some issues that were addressed by the people.
Some of the new features are:
- New ultra quality yet highly scalable(DX9 only) bloom shader with HDR like shift sensitivity. There are now three types of bloom.
- This mod enables adding any number of particle effects and lights to weapons in a really easy way. New cool particle effects for muzzleflashes and weapon mods such as flashlight and laser sight etc.
- Material based decals, particles and sound effects.
- Denton's Ultra real stereo surround sound pack that takes advantage of new unified way of playing impact sounds.
- New customizable tracer effects, all new Plama-railgun with cool railbeam effect.
These features and lots of other improvements, I am really sure, will take your Doom 3 experience to a whole new level. This mod may also prove useful to mod makers as well as SP-map makers.
Actually, there were more of those whole new things in the development pipeline. But I have been busy with all sort of things but modding and the progress on this mod was halted for more than 3 months, so I am releasing it as it now.
================================================================================================
DLL related Changes
================================================================================================
# New Bloomshader: The new bloom uses heavily modified use_less' bloomshader as base and is for DX9 compliant hardware only. There are three types of bloom now. All these three types use 2 pass Gaussian blur and the first two types support HDR like shift sensitivity (taken from maha_x's bloomshader). The shifting of sensitivity is not as perfect as HDR, it works much like oblivion's HDR based shift sensitivity effect. The new bloomshader not only is works better on low end systems (with DX9 hardware) but also can provide ultra high quality bloom for high end systems.
# New weaponFX system: That let add any number of particle effects and lights to weapons in a really easy way. All you need to do is add some keys to weapon defs and use some simple scripts.
# RealTracers 2.0 (tm): All new tracer logic for creating tracers and beams with customizable colors, size and speed etc. The tracer logic supports models (.lwo, .prt) as well as new customizable beam type.
# Unified how decals, particle effects and sound applied to entity and world upon projectile impact.
# Added ability to attach smokeParticles to any entity: Ever wondered why all the hanging mummies, lying dead bodies or lying body parts(like dismembered hand, torso etc) never had blood spurting wound when shot at? Now, a smoke particle can be attached to any type of entity.
# A weapon now can have more than one projectile type but consumes the same ammo type: E.g. plasmagun now has two different projectile types: plasma-balls, and plasma-rail beam. In the similar manner you can have different projectile type for rocket launcher, such as normal rockets and grenades etc. Each of the different projectile type can have different recoil for the same weapon.
Some other changes include:
- New blood splat and blood pool decals system
- g_debugdamage when set to 1, now dumps collision material information to console.
- Improved behavior of exploding and burning barrels.
- Improved the eject brass behavior and added more control over it.
- Added alternate fire key for weapons.
- Lots of bug fixes, improvements and optimizations.
All the features/changes above are discussed in detail in info.txt; where as previous version features can be found in readme_old.txt.
Previous version features summary (in short):
- Support for up to 32 weapons with shared ammo considerations.
- Half-Life style quick weapon key.
- Improved Gibbing system.
- Tweaked the way ragdolls react to explosions, now an explosion can throw animated bodies in air.
- Physics based collision sounds for debris.
========================================================================================
Other changes -
========================================================================================
#Includes Denton's Ultra Real stereo surround sounds v3.2 (unreleased) introducing new audio experience.
------------------------------------------------------------------------------------------------
Version 3.2 changes:
- Impact sounds for different materials like, metal, wood, glass, plastic, sand, stone and concrete etc.
- New Super shotgun reload sounds, so that the gun feels more like Doom 2 Super shotgun. Note that, these sounds are not directly taken from Doom 2.
- Readjusted loudness of many sounds so that weapons do not feel overpowered.
- New plasma-rail and plasma recharge sounds.
- New stereo-surround plasma-hum sound.
- Version 2 shotgun fire sound is now back. It feels more in place now.
- Bullet_flight sound is now looping, this means you can hear whining sounds as tracers miss you, regardless of how long the monster that was shooting at you, is.
(Previous version changes details can be found in readme_old.txt)
------------------------------------------------------------------------------------------------
# New Particle Effects:
- All new third person as well as first particle effects for muzzleflashes of weapons like, pistol, machinegun, shotgun, and chaingun. Initially, I created one or two particle effects which were more realistic, but they didn't fit nicely in Doom 3 universe and then I created muzzleflash effects that wont take away the original feel of weapons.
- New smooth and natural looking muzzlesmoke effects that don't block you field of vision.
- New realistic particle effects for material based damage feedback, which include a unique effect for materials like metal, wood, concrete, sand, stone, plastic and cardboard.
- New realistic particle effects for rocket trail, rocket explosion, grenade explosion, barrel explosion, etc.
# added surface-type tags to lots of materials to support new material based damage feedback. Some materials were left unmodified though, since it was really a tiring job.
# Added Super Shotgun with it's GUI icon and PDA info. Now, you can actually pick up the super shotgun in admin level and later in Delta5 lab when you come back from hell.
# Weapon tweaks:
- Pistol rate of fire is increased so that it fires almost as fast as you shoot, but the base accuracy is affected depending on how fast you fire it.
- Added lasersight to pistol, which can be turned on/off using alt fire key (Mouse2 by default)
- Machinegun fire with normal rate of fire and has lesser spread, but the spread increases as you hold the trigger. So, for better accuracy, you need to fire in bursts.
- added flashlight attachment to shotgun which can now be turned on/off using alt fire key (Mouse2 by default)
- Added alternate fire to plasmagun. The secondary fire mode now fires plasmarail which consumes 10 plasma balls and does damage which is slightly less than damage done by 10 plasma balls.
# Wrote many new and modified existing skins, materials, defs. Added some new decal textures. Added new textures for different particle effects.
# GUI related changes:
- You can now configure alternate attack key by going to GUI window, main menu -> options -> control -> attack/look.
- Fixed an issue where multiplayer weapon icons were not showing correctly due to the addition of super shotgun.
# Includes ultra perfromance tweak(see autoexec.cfg and doomConfig.cfg) by Compguru76 which removes stuttering altogether at high and ultra high quality. I have modified this tweak to solve some compatibility issues with some ATI graphics cards.
# Previous version changes summary in short:
(refer to readme_old.txt for details)
- improved articulated figures (ragdolls) for all monsters.
- Fixed mass and density of many physics objects so that they react realistically to explosions and when shot by weapons.
- Locations based damages for all monsters except bosses.
- Tweaked projectile physics values for better kickback upon impact.
- Added Super shotgun with interruptible reload and appropriate eject brass behavior.
- New chaingun spinup behavior, now feels more realistic
- New particle effects for various explosions, impacts, projectile trails, monster burnaway etc
================================================================================================
Version 2.02 change summary (since version 2.0)
================================================================================================
- Added support for Doom 3 v1.3.1 as well as v1.3.0 (DLL related change)
- Fixed bug where shotgun reloaded 8 shells in one go (DLL related change, see info.txt for details)
- Fixed bug where plasma-rail consumed 19 projectiles where as it should consume only 10.
- Fixed a bug where william banks' pda showed as default pda in admin lab.
- Readjusted loudness super-shotgun reload sound.
- Miscellaneous small fixes.
================================================================================================
MAKING A SP MAP COMPATIBLE WITH THIS MOD
================================================================================================
Basically, any SP map should work well with this mod. Only the thing is, if the map is using custom materials, a default smoke and spark effect will be used for all those. If you like this mod and you are making any SP maps that you might want to make compatible with material based damage feedback system, remember to add tags (like wood, stone, plastic etc. ) to your custom materials.
Refer to info.txt for some more details.
================================================================================================
FEEDBACK
================================================================================================
If you have any queries regarding to this mod feel free to mail me. There are no known issues with this mod. However, if you find any, please let me know.
================================================================================================
CREDITS
================================================================================================
Scripting, decl modifications, GUI Scripting, Particle Effects, Shader Programs(for bloomshader), DLL Coding (VC++) all done by Vikram Jadhav (AKA Clone JC Denton)
Original Bloomshader1 code (with Gaussian Blur) - Use_less and SantaClaws
Original Bloomshader2 code (with shift sensitivity) - maha_x (maha_x[at]hotmail[dot]com)
Following features/bug fixes were contributed to this mod by Konrad Kulczycki (tadeusz[dot]kulczycki[at]neostrada[dot]pl):
------------------------------------------------
Placed super-shotgun in admin map and delta5 map.
Fixed bug where weapons were taken off of or added to the player inventory in a wrong way when teleporting to or from hell respectively.
Added pda icon and description for super-shotgun.
He had also added gravitygun and placed in maps like, mc_underground, enpro and delta5, but I've not included it in this release.
------------------------------------------------
Ultraperformance tweak - By compguru76 (compguru76 AT yahoo DOT com)
I would like to thank use_less and maha_x not only for writing such a wonderful bloomshaders but also allowing me to use their code in my mod. I would also like to thank oneofthe8devilz for providing me use_less' code before I could get in touch with use_less.
As per the original plans, a heavily modified gravity gun (originally created by bloodrayne) was going to be part of this mod. I am thankful to Bloodrayne for allowing me to include his work, but I couldn't give time to finish my work with the gravgun.
I'd also like to thank my friend, Konrad Kulczycki for his contribution to my mod and for his patience. Actually, he had contributed his work almost a year back, when I was planning a minor update for the first version.
Last but not least, I'd like to thank all the people who downloaded the previous version and showered me with really excellent feedback.
================================================================================================
What's missing?
================================================================================================
Following are the features I had originally planned to add to this mod. Due to the limited time I had, I couldn't develop them. I may complete some of them and release thro' an update/patch. However, I can't guarantee anything now.
Note that, these features are not exaggerations of any sort, they can be hundred percent implemented.
# Advanced weaponFX system that works for almost every entity. Which can be used for:
- custom muzzleflashes and weapon mods (e.g. laser, flashlight etc) that works on monsters' weapons,
- Setting up a grenade as laser trip mine, etc.
# Gravity gun with half-life 2 like functionality and with DLL based support. It was placed in some of the maps (See credits section), so that you can actually pick it up instead of using cheat codes.
# BlurVision effect when player receives melee attack from monsters.
# Weapon zooming system with visible scope GUI.
# Simulated particle bouncing for sparks and debris that comes of different materials when shot at.
# Advanced weapon-beam system that gives target information, which can be used for
- weapons with laser beams, where there accuracy is dicated by laser beams,
- laser guided rockets,
- target monitoring for gravity gun
================================================================================================
DISCLAIMER
================================================================================================
- This mod is tested to work with single player only. The new tracer effects and muzzleflash effects work for multiplayer too, but none of them have tested thoroughly.
- This mod is for Doom 3 only and does not work for Doom 3 ROE.
- This mod does not work with any other mod that has their own gamex86.dll.
You can use any of the mod assets and dll as you see fit, but don't forget to credit me. I'll be glad if you'd mailed me to notify that you are using it. Also, I am not releasing the code as of now, which I plan to release soon. Though, I'll mail the code on request.
===============================================================================================

29
game/AFEntity.cpp
View file

@ -126,6 +126,11 @@ idMultiModelAF::Think
void idMultiModelAF::Think( void ) {
RunPhysics();
Present();
#ifdef _DENTONMOD
if ( thinkFlags & TH_UPDATEWOUNDPARTICLES )
UpdateParticles();
#endif
}
@ -389,11 +394,19 @@ void idAFAttachment::Damage( idEntity *inflictor, idEntity *attacker, const idVe
idAFAttachment::AddDamageEffect
================
*/
#ifdef _DENTONMOD
void idAFAttachment::AddDamageEffect( const trace_t &collision, const idVec3 &velocity, const char *damageDefName, idEntity *soundEnt ) {
#else
void idAFAttachment::AddDamageEffect( const trace_t &collision, const idVec3 &velocity, const char *damageDefName ) {
#endif
if ( body ) {
trace_t c = collision;
c.c.id = JOINT_HANDLE_TO_CLIPMODEL_ID( attachJoint );
#ifdef _DENTONMOD
body->AddDamageEffect( c, velocity, damageDefName, soundEnt );
#else
body->AddDamageEffect( c, velocity, damageDefName );
#endif
}
}
@ -454,9 +467,13 @@ idAfAttachment::Think
*/
void idAFAttachment::Think( void ) {
idAnimatedEntity::Think();
#ifndef _DENTONMOD
// This has been taken care of by idAnimatedEntity, so we wont need it now
if ( thinkFlags & TH_UPDATEPARTICLES ) {
UpdateDamageEffects();
}
#endif
}
/*
@ -634,6 +651,10 @@ void idAFEntity_Base::Think( void ) {
Present();
LinkCombat();
}
#ifdef _DENTONMOD
if (thinkFlags & TH_UPDATEWOUNDPARTICLES)
UpdateDamageEffects();
#endif
}
/*
@ -1092,7 +1113,13 @@ void idAFEntity_Gibbable::Damage( idEntity *inflictor, idEntity *attacker, const
return;
}
idAFEntity_Base::Damage( inflictor, attacker, dir, damageDefName, damageScale, location );
if ( health < -20 && spawnArgs.GetBool( "gib" ) ) {
// New Gibbing System By Clone JCD
int healthToGib = spawnArgs.GetInt ("gibHealth"); // GibHealth is suppossed to be declared in entityDef
if (healthToGib == 0) // If its not there, set it to default value
healthToGib = -20 ;
if ( health < healthToGib && spawnArgs.GetBool( "gib" ) ) {
Gib( dir, damageDefName );
}
}

4
game/AFEntity.h
View file

@ -124,7 +124,11 @@ public:
virtual void AddForce( idEntity *ent, int id, const idVec3 &point, const idVec3 &force );
virtual void Damage( idEntity *inflictor, idEntity *attacker, const idVec3 &dir, const char *damageDefName, const float damageScale, const int location );
#ifdef _DENTONMOD
virtual void AddDamageEffect( const trace_t &collision, const idVec3 &velocity, const char *damageDefName, idEntity *soundEnt=NULL );
#else
virtual void AddDamageEffect( const trace_t &collision, const idVec3 &velocity, const char *damageDefName );
#endif
void SetCombatModel( void );
idClipModel * GetCombatModel( void ) const;

17
game/Actor.cpp
View file

@ -2180,7 +2180,12 @@ void idActor::Damage( idEntity *inflictor, idEntity *attacker, const idVec3 &dir
}
int damage = damageDef->GetInt( "damage" ) * damageScale;
damage = GetDamageForLocation( damage, location );
// By Clone JCD For Improved damage behaviour
if (health > 0){ // Make sure that an actor is alive when we go for Damage location
damage = GetDamageForLocation( damage, location );
// gameLocal.Printf(" \n damage applied: %d", damage );
}
// inform the attacker that they hit someone
attacker->DamageFeedback( this, inflictor, damage );
@ -2191,7 +2196,15 @@ void idActor::Damage( idEntity *inflictor, idEntity *attacker, const idVec3 &dir
health = -999;
}
Killed( inflictor, attacker, damage, dir, location );
if ( ( health < -20 ) && spawnArgs.GetBool( "gib" ) && damageDef->GetBool( "gib" ) ) {
//Improved Gibbing System by Clone JC Denton
int healthToGib = spawnArgs.GetInt ("gibHealth"); // GibHealth is suppossed to be declared in entityDef
if (healthToGib == 0) // If its not there, set it to default value
healthToGib = -20 ;
if ( ( health < healthToGib ) && spawnArgs.GetBool( "gib" ) && damageDef->GetBool( "gib" ) ) {
Gib( dir, damageDefName );
}
} else {

90
game/BrittleFracture.cpp
View file

@ -626,6 +626,11 @@ void idBrittleFracture::Think( void ) {
RunPhysics();
Present();
#ifdef _DENTONMOD_ENTITY_CPP
if ( thinkFlags & TH_UPDATEWOUNDPARTICLES )
UpdateParticles();
#endif
}
/*
@ -669,7 +674,11 @@ void idBrittleFracture::AddForce( idEntity *ent, int id, const idVec3 &point, co
idBrittleFracture::ProjectDecal
================
*/
#ifdef _DENTONMOD
void idBrittleFracture::ProjectDecal( const idVec3 &point, const idVec3 &dir, const int time, const char *damageDefName, idEntity *soundEnt ) {
#else
void idBrittleFracture::ProjectDecal( const idVec3 &point, const idVec3 &dir, const int time, const char *damageDefName ) {
#endif
int i, j, bits, clipBits;
float a, c, s;
idVec2 st[MAX_POINTS_ON_WINDING];
@ -696,10 +705,34 @@ void idBrittleFracture::ProjectDecal( const idVec3 &point, const idVec3 &dir, co
// try to get the sound from the damage def
const idDeclEntityDef *damageDef = NULL;
const idSoundShader *sndShader = NULL;
if ( damageDefName ) {
damageDef = gameLocal.FindEntityDef( damageDefName, false );
if ( damageDef ) {
if (damageDef) {
#ifdef _DENTONMOD
const char *sound = damageDef->dict.GetString( "snd_shatter" );
if( *sound == '\0' ) {
sound = damageDef->dict.GetString( "snd_glass" );
}
if ( *sound != '\0' ) {
if( soundEnt == NULL ) {
StartSoundShader( declManager->FindSound( sound ), SND_CHANNEL_ANY, 0, false, NULL );
} else {
soundEnt->StartSoundShader( declManager->FindSound( sound ), SND_CHANNEL_ANY, 0, false, NULL );
}
} else {
StartSound( "snd_bullethole", SND_CHANNEL_ANY, 0, false, NULL );
}
}
}
#else// Above code means the same as below but strangely enough the code written below doesnt work.
sndShader = declManager->FindSound( damageDef->dict.GetString( "snd_shatter", "" ) );
if( !sndShader ) {
sndShader = declManager->FindSound( damageDef->dict.GetString( "snd_glass", "" ) );
}
}
}
@ -708,6 +741,7 @@ void idBrittleFracture::ProjectDecal( const idVec3 &point, const idVec3 &dir, co
} else {
StartSound( "snd_bullethole", SND_CHANNEL_ANY, 0, false, NULL );
}
#endif
}
a = gameLocal.random.RandomFloat() * idMath::TWO_PI;
@ -997,10 +1031,64 @@ void idBrittleFracture::Killed( idEntity *inflictor, idEntity *attacker, int dam
idBrittleFracture::AddDamageEffect
================
*/
#ifdef _DENTONMOD
void idBrittleFracture::AddDamageEffect( const trace_t &collision, const idVec3 &velocity, const char *damageDefName, idEntity *soundEnt ) {
#else
void idBrittleFracture::AddDamageEffect( const trace_t &collision, const idVec3 &velocity, const char *damageDefName ) {
if ( !disableFracture ) {
ProjectDecal( collision.c.point, collision.c.normal, gameLocal.time, damageDefName );
}
#endif
#ifdef _DENTONMOD
if ( !disableFracture ) {
ProjectDecal( collision.c.point, collision.c.normal, gameLocal.time, damageDefName, soundEnt );
}
// a damage effect is added -By Clone JC Denton
const idDeclEntityDef *def = gameLocal.FindEntityDef( damageDefName, false );
if ( def == NULL ) {
return;
}
if (disableFracture) { //play sound only when the flag is set, otherwise idBrittleFracture::ProjectDecal will take care of playing the sound
const char *sound = def->dict.GetString( "snd_shatter" );
if( *sound == '\0' ) {
sound = def->dict.GetString( "snd_glass" );
}
if ( *sound != '\0' ) {
if( soundEnt == NULL ) {
StartSoundShader( declManager->FindSound( sound ), SND_CHANNEL_ANY, 0, false, NULL );
} else {
soundEnt->StartSoundShader( declManager->FindSound( sound ), SND_CHANNEL_ANY, 0, false, NULL );
}
} else {
StartSound( "snd_bullethole", SND_CHANNEL_ANY, 0, false, NULL );
}
}
const char *bleed = def->dict.GetString( "smoke_wound_glass" );
if ( *bleed != '\0' ) {
entDamageEffect_t *de = new entDamageEffect_t;
de->next = this->entDamageEffects;
this->entDamageEffects = de;
de->origin = (collision.c.point - renderEntity.origin) * renderEntity.axis.Transpose();
de->dir = collision.c.normal * renderEntity.axis.Transpose();
de->type = static_cast<const idDeclParticle *>( declManager->FindType( DECL_PARTICLE, bleed ) );
de->time = -1; // We use this as a flag initially, idEntity::UpdateParticles() will actually set it to proper value.
if (!(thinkFlags & TH_UPDATEWOUNDPARTICLES)) {// if flag was not set before set it now
BecomeActive( TH_UPDATEWOUNDPARTICLES );
}
}
#endif
}
/*

7
game/BrittleFracture.h
View file

@ -73,10 +73,15 @@ public:
virtual void Think( void );
virtual void ApplyImpulse( idEntity *ent, int id, const idVec3 &point, const idVec3 &impulse );
virtual void AddForce( idEntity *ent, int id, const idVec3 &point, const idVec3 &force );
#ifdef _DENTONMOD
virtual void AddDamageEffect( const trace_t &collision, const idVec3 &velocity, const char *damageDefName, idEntity *soundEnt=NULL );
void ProjectDecal( const idVec3 &point, const idVec3 &dir, const int time, const char *damageDefName, idEntity *soundEnt=NULL );
#else
virtual void AddDamageEffect( const trace_t &collision, const idVec3 &velocity, const char *damageDefName );
void ProjectDecal( const idVec3 &point, const idVec3 &dir, const int time, const char *damageDefName );
#endif
virtual void Killed( idEntity *inflictor, idEntity *attacker, int damage, const idVec3 &dir, int location );
void ProjectDecal( const idVec3 &point, const idVec3 &dir, const int time, const char *damageDefName );
bool IsBroken( void ) const;
enum {

325
game/Entity.cpp
View file

@ -424,6 +424,10 @@ idEntity::idEntity() {
teamChain = NULL;
signals = NULL;
#ifdef _DENTONMOD_ENTITY_CPP
entDamageEffects = NULL;
#endif
memset( PVSAreas, 0, sizeof( PVSAreas ) );
numPVSAreas = -1;
@ -603,6 +607,15 @@ idEntity::~idEntity( void ) {
// specific physics object might be an entity variable and as such could already be destroyed.
SetPhysics( NULL );
#ifdef _DENTONMOD_ENTITY_CPP
for ( entDamageEffect_t *de = entDamageEffects; de; de = entDamageEffects ) {
entDamageEffects = de->next; // Clear damage effects if any
delete de;
}
#endif
// remove any entities that are bound to me
RemoveBinds();
@ -632,6 +645,9 @@ idEntity::Save
void idEntity::Save( idSaveGame *savefile ) const {
int i, j;
#ifdef _DENTONMOD_ENTITY_CPP
// Wounds are very temporary, ignored at this time
#endif
savefile->WriteInt( entityNumber );
savefile->WriteInt( entityDefNumber );
@ -837,6 +853,11 @@ idEntity::Think
void idEntity::Think( void ) {
RunPhysics();
Present();
#ifdef _DENTONMOD_ENTITY_CPP
if ( thinkFlags & TH_UPDATEWOUNDPARTICLES )
UpdateParticles();
#endif
}
/*
@ -2672,6 +2693,56 @@ bool idEntity::RunPhysics( void ) {
return true;
}
#ifdef _DENTONMOD_ENTITY_CPP
/*
==============
idEntity::UpdateParticles
==============
*/
void idEntity::UpdateParticles( void ) {
entDamageEffect_t *de, **prev;
// free any that have timed out
prev = &this->entDamageEffects;
while ( *prev ) {
de = *prev;
if ( de->time == 0 ) { // FIXME:SMOKE
*prev = de->next;
delete de;
} else {
prev = &de->next;
}
}
if ( !g_bloodEffects.GetBool() ) {
return;
}
if ( !this->entDamageEffects ) { // If no more particles left...
if ( thinkFlags & TH_UPDATEWOUNDPARTICLES )
BecomeInactive( TH_UPDATEWOUNDPARTICLES );
return;
}
// emit a particle for each bleeding wound
for ( de = this->entDamageEffects; de; de = de->next ) {
idVec3 origin;
idVec3 dir;
dir = de->dir * renderEntity.axis;
origin = renderEntity.origin + de->origin * renderEntity.axis;
if (de->time == -1) { // This key fixes an issue where some particles are not at all emitted
de->time = gameLocal.time;
}
if ( !gameLocal.smokeParticles->EmitSmoke( de->type, de->time, gameLocal.random.CRandomFloat(), origin, dir.ToMat3() ) ) {
de->time = 0;
}
}
}
#endif
/*
================
idEntity::UpdateFromPhysics
@ -3022,7 +3093,11 @@ void idEntity::Damage( idEntity *inflictor, idEntity *attacker, const idVec3 &di
idEntity::AddDamageEffect
================
*/
#ifdef _DENTONMOD
void idEntity::AddDamageEffect( const trace_t &collision, const idVec3 &velocity, const char *damageDefName, idEntity *soundEnt ) {
#else
void idEntity::AddDamageEffect( const trace_t &collision, const idVec3 &velocity, const char *damageDefName ) {
#endif
const char *sound, *decal, *key;
const idDeclEntityDef *def = gameLocal.FindEntityDef( damageDefName, false );
@ -3038,23 +3113,94 @@ void idEntity::AddDamageEffect( const trace_t &collision, const idVec3 &velocity
if ( *sound == '\0' ) {
sound = def->dict.GetString( key );
}
if ( *sound == '\0' ) {
sound = def->dict.GetString( "snd_metal" ); // default sound 1
}
if ( *sound == '\0' ) {
sound = def->dict.GetString( "snd_impact" ); // default sound 2
}
if ( *sound != '\0' ) {
#ifdef _DENTONMOD
if (soundEnt == NULL) {
StartSoundShader( declManager->FindSound( sound ), SND_CHANNEL_BODY, 0, false, NULL );
}
else {
soundEnt->StartSoundShader( declManager->FindSound( sound ), SND_CHANNEL_BODY, 0, false, NULL );
}
#else
StartSoundShader( declManager->FindSound( sound ), SND_CHANNEL_BODY, 0, false, NULL );
#endif
}
if ( g_decals.GetBool() ) {
// place a wound overlay on the model
if( g_debugDamage.GetBool() ) {
gameLocal.Printf("\n Collision Material Type- %s", materialType);
gameLocal.Printf("\n file :%s", collision.c.material->GetFileName());
gameLocal.Printf("\n Collision material:%s", collision.c.material->ImageName());
}
key = va( "mtr_wound_%s", materialType );
decal = spawnArgs.RandomPrefix( key, gameLocal.random );
if ( *decal == '\0' ) {
decal = def->dict.RandomPrefix( key, gameLocal.random );
}
if ( *decal == '\0' ) {
decal = def->dict.GetString( "mtr_wound" ); // Default decal
}
if ( *decal != '\0' ) {
float size;
idVec3 dir = velocity;
dir.Normalize();
ProjectOverlay( collision.c.point, dir, 20.0f, decal );
if ( !def->dict.GetFloat( va( "size_wound_%s", materialType ), "6.0", size ) ) { // If Material Specific decal size not found, look for default size
size = def->dict.GetFloat( "size_wound", "6.0" );
}
#ifdef _DENTONMOD_ENTITY_CPP
gameLocal.ProjectDecal( collision.c.point, -collision.c.normal, 8.0f, true, size, decal );
#else
ProjectOverlay( collision.c.point, dir, size, decal ); // added by Clone JCD
#endif // Modified for custom wound size
}
}
#ifdef _DENTONMOD_ENTITY_CPP
// a blood spurting wound is added -By Clone JC Denton
key = va( "smoke_wound_%s", materialType );
const char *bleed = spawnArgs.GetString( key );
if ( *bleed == '\0' ) {
bleed = def->dict.GetString( key );
if( *bleed == '\0' )
bleed = def->dict.GetString( "smoke_wound_metal" ); // play default smoke
if( *bleed == '\0' )
bleed = def->dict.GetString( "smoke_wound" ); // play default smoke
}
if ( *bleed != '\0' ) {
entDamageEffect_t *de = new entDamageEffect_t;
de->next = this->entDamageEffects;
this->entDamageEffects = de;
de->origin = (collision.c.point - renderEntity.origin) * renderEntity.axis.Transpose();
de->dir = collision.c.normal * renderEntity.axis.Transpose();
de->type = static_cast<const idDeclParticle *>( declManager->FindType( DECL_PARTICLE, bleed ) );
//de->isTimeInitialized = false;
de->time = -1; // -1 means this effect has just started, see idEntity::UpdateParticles()
if (!(thinkFlags & TH_UPDATEWOUNDPARTICLES)) {// if flag was not set before set it now
BecomeActive( TH_UPDATEWOUNDPARTICLES );
}
}
#endif
}
/*
@ -4894,6 +5040,7 @@ idAnimatedEntity::idAnimatedEntity
idAnimatedEntity::idAnimatedEntity() {
animator.SetEntity( this );
damageEffects = NULL;
nextBloodPoolTime = 0;
}
/*
@ -4966,7 +5113,11 @@ void idAnimatedEntity::Think( void ) {
RunPhysics();
UpdateAnimation();
Present();
UpdateDamageEffects();
#ifdef _DENTONMOD_ENTITY_CPP
if (thinkFlags & TH_UPDATEWOUNDPARTICLES)
#endif
UpdateDamageEffects();
}
/*
@ -5097,10 +5248,13 @@ idAnimatedEntity::AddDamageEffect
Dammage effects track the animating impact position, spitting out particles.
==============
*/
#ifdef _DENTONMOD
void idAnimatedEntity::AddDamageEffect( const trace_t &collision, const idVec3 &velocity, const char *damageDefName, idEntity *soundEnt = NULL ) {
#else
void idAnimatedEntity::AddDamageEffect( const trace_t &collision, const idVec3 &velocity, const char *damageDefName ) {
#endif
jointHandle_t jointNum;
idVec3 origin, dir, localDir, localOrigin, localNormal;
idMat3 axis;
idVec3 dir;
if ( !g_bloodEffects.GetBool() || renderEntity.joints == NULL ) {
return;
@ -5119,6 +5273,12 @@ void idAnimatedEntity::AddDamageEffect( const trace_t &collision, const idVec3 &
dir = velocity;
dir.Normalize();
#ifdef _DENTONMOD_ENTITY_CPP
AddLocalDamageEffect( jointNum, collision.c.point, collision.c.normal, dir, def, collision.c.material, soundEnt );
#else
idVec3 origin, localDir, localOrigin, localNormal;
idMat3 axis;
axis = renderEntity.joints[jointNum].ToMat3() * renderEntity.axis;
origin = renderEntity.origin + renderEntity.joints[jointNum].ToVec3() * renderEntity.axis;
@ -5127,6 +5287,8 @@ void idAnimatedEntity::AddDamageEffect( const trace_t &collision, const idVec3 &
localDir = dir * axis.Transpose();
AddLocalDamageEffect( jointNum, localOrigin, localNormal, localDir, def, collision.c.material );
#endif
if ( gameLocal.isServer ) {
idBitMsg msg;
@ -5135,11 +5297,21 @@ void idAnimatedEntity::AddDamageEffect( const trace_t &collision, const idVec3 &
msg.Init( msgBuf, sizeof( msgBuf ) );
msg.BeginWriting();
msg.WriteShort( (int)jointNum );
#ifdef _DENTONMOD_ENTITY_CPP
msg.WriteFloat( collision.c.point[0] );
msg.WriteFloat( collision.c.point[1] );
msg.WriteFloat( collision.c.point[2] );
msg.WriteDir( collision.c.normal, 24 );
msg.WriteDir( dir, 24 );
#else
msg.WriteFloat( localOrigin[0] );
msg.WriteFloat( localOrigin[1] );
msg.WriteFloat( localOrigin[2] );
msg.WriteDir( localNormal, 24 );
msg.WriteDir( localDir, 24 );
#endif
msg.WriteInt( gameLocal.ServerRemapDecl( -1, DECL_ENTITYDEF, def->Index() ) );
msg.WriteInt( gameLocal.ServerRemapDecl( -1, DECL_MATERIAL, collision.c.material->Index() ) );
ServerSendEvent( EVENT_ADD_DAMAGE_EFFECT, &msg, false, -1 );
@ -5160,17 +5332,25 @@ int idAnimatedEntity::GetDefaultSurfaceType( void ) const {
idAnimatedEntity::AddLocalDamageEffect
==============
*/
#ifdef _DENTONMOD_ENTITY_CPP
void idAnimatedEntity::AddLocalDamageEffect( jointHandle_t jointNum, const idVec3 &origin, const idVec3 &normal, const idVec3 &dir, const idDeclEntityDef *def, const idMaterial *collisionMaterial, idEntity *soundEnt ) {
#else
void idAnimatedEntity::AddLocalDamageEffect( jointHandle_t jointNum, const idVec3 &localOrigin, const idVec3 &localNormal, const idVec3 &localDir, const idDeclEntityDef *def, const idMaterial *collisionMaterial ) {
#endif
const char *sound, *splat, *decal, *bleed, *key;
damageEffect_t *de;
idVec3 origin, dir;
idMat3 axis;
idVec3 gravDir;
idPhysics *phys;
#ifndef _DENTONMOD_ENTITY_CPP
idMat3 axis;
idVec3 origin, dir;
axis = renderEntity.joints[jointNum].ToMat3() * renderEntity.axis;
origin = renderEntity.origin + renderEntity.joints[jointNum].ToVec3() * renderEntity.axis;
origin = origin + localOrigin * axis;
dir = localDir * axis;
#endif
int type = collisionMaterial->GetSurfaceType();
if ( type == SURFTYPE_NONE ) {
@ -5185,8 +5365,23 @@ void idAnimatedEntity::AddLocalDamageEffect( jointHandle_t jointNum, const idVec
if ( *sound == '\0' ) {
sound = def->dict.GetString( key );
}
if ( *sound == '\0' ) {
sound = def->dict.GetString( "snd_metal" ); // default sound 1
}
if ( *sound == '\0' ) {
sound = def->dict.GetString( "snd_impact" ); // default sound 2
}
if ( *sound != '\0' ) {
#ifdef _DENTONMOD
if( soundEnt == NULL ) {
StartSoundShader( declManager->FindSound( sound ), SND_CHANNEL_BODY, 0, false, NULL );
}
else {
soundEnt->StartSoundShader( declManager->FindSound( sound ), SND_CHANNEL_BODY, 0, false, NULL );
}
#else
StartSoundShader( declManager->FindSound( sound ), SND_CHANNEL_BODY, 0, false, NULL );
#endif
}
// blood splats are thrown onto nearby surfaces
@ -5199,16 +5394,70 @@ void idAnimatedEntity::AddLocalDamageEffect( jointHandle_t jointNum, const idVec
gameLocal.BloodSplat( origin, dir, 64.0f, splat );
}
// Create blood pools at feet, Only when alive - By Clone JCD
if (health > 0) {
int bloodpoolTime;
if( gameLocal.time > nextBloodPoolTime ) { // You can use this condition instead :- if (gameLocal.isNewFrame)
key = va( "mtr_bloodPool_%s", materialType );
splat = spawnArgs.RandomPrefix( key, gameLocal.random );
if ( *splat == '\0' ) {
splat = def->dict.RandomPrefix( key, gameLocal.random );
}
if ( *splat != '\0' ) {
phys = GetPhysics();
gravDir = phys->GetGravity();
gravDir.Normalize();
if( spawnArgs.GetBool("bloodPool_below_origin") ) {
gameLocal.BloodSplat( phys->GetOrigin(), gravDir, def->dict.GetFloat ( va ("size_bloodPool_%s", materialType), "64.0f"), splat );
}
else {
gameLocal.BloodSplat( origin, gravDir, def->dict.GetFloat ( va ("size_bloodPool_%s", materialType), "64.0f"), splat );
}
}
// This condition makes sure that we dont spawn overlapping bloodpools in a single frame.
if(!spawnArgs.GetInt( "next_bloodpool_time", "050", bloodpoolTime) ){
bloodpoolTime = def->dict.GetInt( "next_bloodpool_time", "050");
}
nextBloodPoolTime = gameLocal.time + bloodpoolTime; // This avoids excessive bloodpool overlapping
}
}
// can't see wounds on the player model in single player mode
if ( !( IsType( idPlayer::Type ) && !gameLocal.isMultiplayer ) ) {
// blood splats can be thrown on the body itself two - By Clone JC Denton
key = va( "mtr_splatSelf_%s", materialType );
splat = spawnArgs.RandomPrefix( key, gameLocal.random );
if ( *splat == '\0' ) {
splat = def->dict.RandomPrefix( key, gameLocal.random );
}
if ( *splat != '\0' ) {
ProjectOverlay( origin, dir, def->dict.GetFloat ( va ("size_splatSelf_%s", materialType), "15.0f"), splat );
}
// place a wound overlay on the model
if( g_debugDamage.GetBool() ) {
gameLocal.Printf("\nCollision Material Type: %s", materialType);
gameLocal.Printf("\n File: %s", collisionMaterial->GetFileName());
gameLocal.Printf("\n material: %s", collisionMaterial->ImageName());
}
key = va( "mtr_wound_%s", materialType );
decal = spawnArgs.RandomPrefix( key, gameLocal.random );
if ( *decal == '\0' ) {
decal = def->dict.RandomPrefix( key, gameLocal.random );
}
if ( *decal == '\0' ) {
decal = def->dict.GetString( "mtr_wound" ); // Default decal
}
if ( *decal != '\0' ) {
ProjectOverlay( origin, dir, 20.0f, decal );
float size;
if ( !def->dict.GetFloat( va( "size_wound_%s", materialType ), "6.0", size ) ) { // If Material Specific decal size not found, look for default size
size = def->dict.GetFloat( "size_wound", "6.0" );
}
ProjectOverlay( origin, dir, size, decal );
}
}
@ -5217,17 +5466,38 @@ void idAnimatedEntity::AddLocalDamageEffect( jointHandle_t jointNum, const idVec
bleed = spawnArgs.GetString( key );
if ( *bleed == '\0' ) {
bleed = def->dict.GetString( key );
if( *bleed == '\0' )
bleed = def->dict.GetString( "smoke_wound" ); // play default smoke
}
if ( *bleed != '\0' ) {
de = new damageEffect_t;
de->next = this->damageEffects;
this->damageEffects = de;
de->jointNum = jointNum;
de->localOrigin = localOrigin;
de->localNormal = localNormal;
de->type = static_cast<const idDeclParticle *>( declManager->FindType( DECL_PARTICLE, bleed ) );
de->time = gameLocal.time;
#ifdef _DENTONMOD_ENTITY_CPP
idVec3 boneOrigin;
idMat3 boneAxis;
boneAxis = renderEntity.joints[jointNum].ToMat3() * renderEntity.axis;
boneOrigin = renderEntity.origin + renderEntity.joints[jointNum].ToVec3() * renderEntity.axis;
de->localOrigin = ( origin - boneOrigin ) * boneAxis.Transpose();
de->localNormal = normal * boneAxis.Transpose();
de->time = -1; // used as flag, notifies UpdateDamageEffects that this effect is just started
if (!(thinkFlags & TH_UPDATEWOUNDPARTICLES)) // if flag was not set before set it now
BecomeActive( TH_UPDATEWOUNDPARTICLES );
#else
de->localOrigin = localOrigin;
de->localNormal = localNormal;
de->time = gameLocal.time;
#endif
}
}
@ -5239,6 +5509,7 @@ idAnimatedEntity::UpdateDamageEffects
void idAnimatedEntity::UpdateDamageEffects( void ) {
damageEffect_t *de, **prev;
// free any that have timed out
prev = &this->damageEffects;
while ( *prev ) {
@ -5255,8 +5526,40 @@ void idAnimatedEntity::UpdateDamageEffects( void ) {
return;
}
#ifdef _DENTONMOD_ENTITY_CPP
if ( !this->damageEffects ){ // If no more particles left...
if ( thinkFlags & TH_UPDATEWOUNDPARTICLES )
BecomeInactive( TH_UPDATEWOUNDPARTICLES );
return;
}
#endif
// emit a particle for each bleeding wound
for ( de = this->damageEffects; de; de = de->next ) {
#ifdef _DENTONMOD_ENTITY_CPP
idVec3 origin, dir;
idMat3 axis;
// Sometimes it happens that the original animated model is replace by a particle effect, e.g. on flying lost soul's death.
// In that case we wont be able to find any joints. So a proper check should be made.
if( renderEntity.numJoints <= 0 ) {
axis = renderEntity.axis;
origin = renderEntity.origin;
}
else {
axis = renderEntity.joints[de->jointNum].ToMat3() * renderEntity.axis;
origin = renderEntity.origin + renderEntity.joints[de->jointNum].ToVec3() * renderEntity.axis;
}
origin = origin + de->localOrigin * axis;
dir = de->localNormal * axis;
if ( de->time == -1 ) { // initialize start time just before passing it to emitSmoke
de->time = gameLocal.time;
}
if ( !gameLocal.smokeParticles->EmitSmoke( de->type, de->time, gameLocal.random.CRandomFloat(), origin, dir.ToMat3() ) ) {
#else
idVec3 origin, start;
idMat3 axis;
@ -5264,7 +5567,9 @@ void idAnimatedEntity::UpdateDamageEffects( void ) {
axis *= renderEntity.axis;
origin = renderEntity.origin + origin * renderEntity.axis;
start = origin + de->localOrigin * axis;
if ( !gameLocal.smokeParticles->EmitSmoke( de->type, de->time, gameLocal.random.CRandomFloat(), start, axis ) ) {
#endif
de->time = 0;
}
}

50
game/Entity.h
View file

@ -39,6 +39,11 @@ If you have questions concerning this license or the applicable additional terms
#include "gamesys/Event.h"
#include "Game_local.h"
#ifdef _DENTONMOD
#ifndef _DENTONMOD_ENTITY_CPP
#define _DENTONMOD_ENTITY_CPP
#endif
#endif
/*
===============================================================================
@ -76,7 +81,14 @@ enum {
TH_PHYSICS = 2, // run physics each frame
TH_ANIMATE = 4, // update animation each frame
TH_UPDATEVISUALS = 8, // update renderEntity
#ifdef _DENTONMOD_ENTITY_CPP
TH_UPDATEPARTICLES = 16, // This flag is used by various classes derived from entity in various situations
TH_UPDATEWOUNDPARTICLES = 32 // so create a new flag. By Clone JC Denton
#else
TH_UPDATEPARTICLES = 16
#endif
};
//
@ -113,6 +125,23 @@ public:
idList<signal_t> signal[ NUM_SIGNALS ];
};
#ifdef _DENTONMOD_ENTITY_CPP
//-----------------------------------------------------------------------------------------------
// enDamage effect holds information about wound effects being played on the entities
// - Clone JC Denton
//-----------------------------------------------------------------------------------------------
typedef struct entDamageEffect_s {
idVec3 origin;
idVec3 dir; //new
// idMat3 axis;
int time;
// bool isTimeInitialized; // New flag which sets time at right time.
const idDeclParticle* type;
struct entDamageEffect_s * next;
} entDamageEffect_t;
#endif
class idEntity : public idClass {
public:
@ -187,6 +216,9 @@ public:
void BecomeActive( int flags );
void BecomeInactive( int flags );
void UpdatePVSAreas( const idVec3 &pos );
#ifdef _DENTONMOD_ENTITY_CPP
void UpdateParticles ( void ); // damage particle effects - By Clone JCD
#endif
// visuals
virtual void Present( void );
@ -304,7 +336,12 @@ public:
// applies damage to this entity
virtual void Damage( idEntity *inflictor, idEntity *attacker, const idVec3 &dir, const char *damageDefName, const float damageScale, const int location );
// adds a damage effect like overlays, blood, sparks, debris etc.
#ifdef _DENTONMOD
//the soundEnt parameter helps unifying how sound is played upon projectile impact.
virtual void AddDamageEffect( const trace_t &collision, const idVec3 &velocity, const char *damageDefName, idEntity *soundEnt = NULL );
#else
virtual void AddDamageEffect( const trace_t &collision, const idVec3 &velocity, const char *damageDefName );
#endif
// callback function for when another entity received damage from this entity. damage can be adjusted and returned to the caller.
virtual void DamageFeedback( idEntity *victim, idEntity *inflictor, int &damage );
// notifies this entity that it is in pain
@ -365,6 +402,9 @@ protected:
renderEntity_t renderEntity; // used to present a model to the renderer
int modelDefHandle; // handle to static renderer model
refSound_t refSound; // used to present sound to the audio engine
#ifdef _DENTONMOD_ENTITY_CPP
entDamageEffect_t * entDamageEffects; // We are going to add damage effect to every entity.
#endif
private:
idPhysics_Static defaultPhysicsObj; // default physics object
@ -480,10 +520,12 @@ typedef struct damageEffect_s {
idVec3 localOrigin;
idVec3 localNormal;
int time;
const idDeclParticle* type;
struct damageEffect_s * next;
} damageEffect_t;
class idAnimatedEntity : public idEntity {
public:
CLASS_PROTOTYPE( idAnimatedEntity );
@ -506,8 +548,13 @@ public:
bool GetJointTransformForAnim( jointHandle_t jointHandle, int animNum, int currentTime, idVec3 &offset, idMat3 &axis ) const;
virtual int GetDefaultSurfaceType( void ) const;
#ifdef _DENTONMOD
virtual void AddDamageEffect( const trace_t &collision, const idVec3 &velocity, const char *damageDefName, idEntity *soundEnt );
void AddLocalDamageEffect( jointHandle_t jointNum, const idVec3 &localPoint, const idVec3 &localNormal, const idVec3 &localDir, const idDeclEntityDef *def, const idMaterial *collisionMaterial, idEntity *soundEnt = NULL );
#else
virtual void AddDamageEffect( const trace_t &collision, const idVec3 &velocity, const char *damageDefName );
void AddLocalDamageEffect( jointHandle_t jointNum, const idVec3 &localPoint, const idVec3 &localNormal, const idVec3 &localDir, const idDeclEntityDef *def, const idMaterial *collisionMaterial );
#endif
void UpdateDamageEffects( void );
virtual bool ClientReceiveEvent( int event, int time, const idBitMsg &msg );
@ -519,9 +566,12 @@ public:
protected:
idAnimator animator;
damageEffect_t * damageEffects;
private:
int nextBloodPoolTime;
void Event_GetJointHandle( const char *jointname );
void Event_ClearAllJoints( void );
void Event_ClearJoint( jointHandle_t jointnum );

66
game/Game_local.cpp
View file

@ -252,6 +252,11 @@ void idGameLocal::Clear( void ) {
savedEventQueue.Init();
memset( lagometer, 0, sizeof( lagometer ) );
#ifdef _PORTALSKY
portalSkyEnt = NULL;
portalSkyActive = false;
#endif
}
/*
@ -536,6 +541,11 @@ void idGameLocal::SaveGame( idFile *f ) {
savegame.WriteBool( isNewFrame );
savegame.WriteFloat( clientSmoothing );
#ifdef _PORTALSKY
portalSkyEnt.Save( &savegame );
savegame.WriteBool( portalSkyActive );
#endif
savegame.WriteBool( mapCycleLoaded );
savegame.WriteInt( spawnCount );
@ -713,7 +723,6 @@ void idGameLocal::Error( const char *fmt, ... ) const {
common->Error( "%s", text );
}
}
/*
===============
gameError
@ -906,6 +915,11 @@ void idGameLocal::LoadMap( const char *mapName, int randseed ) {
sessionCommand = "";
nextGibTime = 0;
#ifdef _PORTALSKY
portalSkyEnt = NULL;
portalSkyActive = false;
#endif
vacuumAreaNum = -1; // if an info_vacuum is spawned, it will set this
if ( !editEntities ) {
@ -1353,6 +1367,11 @@ bool idGameLocal::InitFromSaveGame( const char *mapName, idRenderWorld *renderWo
savegame.ReadBool( isNewFrame );
savegame.ReadFloat( clientSmoothing );
#ifdef _PORTALSKY
portalSkyEnt.Restore( &savegame );
savegame.ReadBool( portalSkyActive );
#endif
savegame.ReadBool( mapCycleLoaded );
savegame.ReadInt( spawnCount );
@ -1998,6 +2017,25 @@ void idGameLocal::SetupPlayerPVS( void ) {
pvs.FreeCurrentPVS( playerConnectedAreas );
pvs.FreeCurrentPVS( otherPVS );
playerConnectedAreas = newPVS;
#ifdef _PORTALSKY
// if portalSky is preset, then merge into pvs so we get rotating brushes, etc
if ( portalSkyEnt.GetEntity() ) {
idEntity *skyEnt = portalSkyEnt.GetEntity();
otherPVS = pvs.SetupCurrentPVS( skyEnt->GetPVSAreas(), skyEnt->GetNumPVSAreas() );
newPVS = pvs.MergeCurrentPVS( playerPVS, otherPVS );
pvs.FreeCurrentPVS( playerPVS );
pvs.FreeCurrentPVS( otherPVS );
playerPVS = newPVS;
otherPVS = pvs.SetupCurrentPVS( skyEnt->GetPVSAreas(), skyEnt->GetNumPVSAreas() );
newPVS = pvs.MergeCurrentPVS( playerConnectedAreas, otherPVS );
pvs.FreeCurrentPVS( playerConnectedAreas );
pvs.FreeCurrentPVS( otherPVS );
playerConnectedAreas = newPVS;
}
#endif
}
}
}
@ -3706,7 +3744,11 @@ void idGameLocal::RadiusPush( const idVec3 &origin, const float radius, const fl
// scale the push for the inflictor
if ( ent == inflictor || ( ent->IsType( idAFAttachment::Type ) && static_cast<idAFAttachment*>(ent)->GetBody() == inflictor ) ) {
scale = inflictorScale;
} else {
}
else if ( ent->IsType (idAFEntity_Base::Type) && static_cast<idAFEntity_Base*>(ent)->IsActiveAF()) { // Only scale push when ragdoll is active - BY Clone JCD
scale = ent->spawnArgs.GetFloat ("ragdoll_push_scale", "1.0"); // Scales down ragdoll push based on def's value
}
else {
scale = 1.0f;
}
@ -4275,6 +4317,26 @@ void idGameLocal::ThrottleUserInfo( void ) {
mpGame.ThrottleUserInfo();
}
#ifdef _PORTALSKY
/*
=================
idGameLocal::SetPortalSkyEnt
=================
*/
void idGameLocal::SetPortalSkyEnt( idEntity *ent ) {
portalSkyEnt = ent;
}
/*
=================
idGameLocal::IsPortalSkyAcive
=================
*/
bool idGameLocal::IsPortalSkyAcive() {
return portalSkyActive;
}
#endif
/*
===========
idGameLocal::SelectTimeGroup

11
game/Game_local.h
View file

@ -294,6 +294,13 @@ public:
idEntityPtr<idEntity> lastGUIEnt; // last entity with a GUI, used by Cmd_NextGUI_f
int lastGUI; // last GUI on the lastGUIEnt
#ifdef _PORTALSKY
idEntityPtr<idEntity> portalSkyEnt;
bool portalSkyActive;
void SetPortalSkyEnt( idEntity *ent );
bool IsPortalSkyAcive();
#endif
// ---------------------- Public idGame Interface -------------------
idGameLocal();
@ -387,6 +394,10 @@ public:
bool InPlayerPVS( idEntity *ent ) const;
bool InPlayerConnectedArea( idEntity *ent ) const;
#ifdef _PORTALSKY
pvsHandle_t GetPlayerPVS() { return playerPVS; };
#endif
void SetCamera( idCamera *cam );
idCamera * GetCamera( void ) const;
bool SkipCinematic( void );

53
game/Item.cpp
View file

@ -76,6 +76,9 @@ idItem::idItem() {
orgOrigin.Zero();
canPickUp = true;
fl.networkSync = true;
/*#ifdef _DENTONMOD
entDamageEffects = NULL;
#endif*/
}
/*
@ -236,6 +239,11 @@ void idItem::Think( void ) {
}
Present();
#ifdef _DENTONMOD
if ( thinkFlags & TH_UPDATEWOUNDPARTICLES )
UpdateParticles();
#endif
}
/*
@ -712,6 +720,43 @@ void idObjective::Event_CamShot( ) {
renderView_t fullView = *view;
fullView.width = SCREEN_WIDTH;
fullView.height = SCREEN_HEIGHT;
#ifdef _PORTALSKY
// HACK : always draw sky-portal view if there is one in the map, this isn't real-time
if ( gameLocal.portalSkyEnt.GetEntity() && g_enablePortalSky.GetBool() ) {
renderView_t portalView = fullView;
portalView.vieworg = gameLocal.portalSkyEnt.GetEntity()->GetPhysics()->GetOrigin();
// setup global fixup projection vars
if ( 1 ) {
int vidWidth, vidHeight;
idVec2 shiftScale;
renderSystem->GetGLSettings( vidWidth, vidHeight );
float pot;
int temp;
int w = vidWidth;
for (temp = 1 ; temp < w ; temp<<=1) {
}
pot = (float)temp;
shiftScale.x = (float)w / pot;
int h = vidHeight;
for (temp = 1 ; temp < h ; temp<<=1) {
}
pot = (float)temp;
shiftScale.y = (float)h / pot;
fullView.shaderParms[4] = shiftScale.x;
fullView.shaderParms[5] = shiftScale.y;
}
gameRenderWorld->RenderScene( &portalView );
renderSystem->CaptureRenderToImage( "_currentRender" );
}
#endif
// draw a view to a texture
renderSystem->CropRenderSize( 256, 256, true );
gameRenderWorld->RenderScene( &fullView );
@ -870,6 +915,9 @@ idMoveableItem::idMoveableItem() {
trigger = NULL;
smoke = NULL;
smokeTime = 0;
/*#ifdef _DENTONMOD
entDamageEffects = NULL;
#endif*/
}
/*
@ -998,6 +1046,11 @@ void idMoveableItem::Think( void ) {
}
Present();
#ifdef _DENTONMOD
if ( thinkFlags & TH_UPDATEWOUNDPARTICLES )
UpdateParticles();
#endif
}
/*

63
game/Misc.cpp
View file

@ -3156,3 +3156,66 @@ void idPhantomObjects::Think( void ) {
BecomeInactive( TH_THINK );
}
}
#ifdef _PORTALSKY
/*
===============================================================================
idPortalSky
===============================================================================
*/
CLASS_DECLARATION( idEntity, idPortalSky )
EVENT( EV_PostSpawn, idPortalSky::Event_PostSpawn )
EVENT( EV_Activate, idPortalSky::Event_Activate )
END_CLASS
/*
===============
idPortalSky::idPortalSky
===============
*/
idPortalSky::idPortalSky( void ) {
}
/*
===============
idPortalSky::~idPortalSky
===============
*/
idPortalSky::~idPortalSky( void ) {
}
/*
===============
idPortalSky::Spawn
===============
*/
void idPortalSky::Spawn( void ) {
if ( !spawnArgs.GetBool( "triggered" ) ) {
PostEventMS( &EV_PostSpawn, 1 );
}
}
/*
================
idPortalSky::Event_PostSpawn
================
*/
void idPortalSky::Event_PostSpawn() {
gameLocal.SetPortalSkyEnt( this );
}
/*
================
idPortalSky::Event_Activate
================
*/
void idPortalSky::Event_Activate( idEntity *activator ) {
gameLocal.SetPortalSkyEnt( this );
}
#endif /* _PORTALSKY */

23
game/Misc.h
View file

@ -765,4 +765,27 @@ private:
idList<idVec3> lastTargetPos;
};
#ifdef _PORTALSKY
/*
===============================================================================
idPortalSky
===============================================================================
*/
class idPortalSky : public idEntity {
public:
CLASS_PROTOTYPE( idPortalSky );
idPortalSky();
~idPortalSky();
void Spawn( void );
void Event_PostSpawn();
void Event_Activate( idEntity *activator );
};
#endif /* _PORTALSKY */
#endif /* !__GAME_MISC_H__ */

71
game/Moveable.cpp
View file

@ -75,6 +75,10 @@ idMoveable::idMoveable( void ) {
unbindOnDeath = false;
allowStep = false;
canDamage = false;
/*#ifdef _DENTONMOD
entDamageEffects = NULL;
#endif*/
}
/*
@ -274,7 +278,7 @@ bool idMoveable::Collide( const trace_t &collision, const idVec3 &velocity ) {
v = -( velocity * collision.c.normal );
if ( v > BOUNCE_SOUND_MIN_VELOCITY && gameLocal.time > nextSoundTime ) {
f = v > BOUNCE_SOUND_MAX_VELOCITY ? 1.0f : idMath::Sqrt( v - BOUNCE_SOUND_MIN_VELOCITY ) * ( 1.0f / idMath::Sqrt( BOUNCE_SOUND_MAX_VELOCITY - BOUNCE_SOUND_MIN_VELOCITY ) );
if ( StartSound( "snd_bounce", SND_CHANNEL_ANY, 0, false, NULL ) ) {
if ( StartSound( "snd_bounce", SND_CHANNEL_BODY, 0, false, NULL ) ) {
// don't set the volume unless there is a bounce sound as it overrides the entire channel
// which causes footsteps on ai's to not honor their shader parms
SetSoundVolume( f );
@ -562,6 +566,9 @@ idBarrel::idBarrel() {
additionalRotation = 0.0f;
additionalAxis.Identity();
fl.networkSync = true;
/*#ifdef _DENTONMOD
entDamageEffects = NULL;
#endif*/
}
/*
@ -677,6 +684,11 @@ void idBarrel::Think( void ) {
}
BarrelThink();
#ifdef _DENTONMOD
if ( thinkFlags & TH_UPDATEWOUNDPARTICLES )
UpdateParticles();
#endif
}
/*
@ -840,6 +852,11 @@ idExplodingBarrel::Think
void idExplodingBarrel::Think( void ) {
idBarrel::BarrelThink();
#ifdef _DENTONMOD
if ( thinkFlags & TH_UPDATEWOUNDPARTICLES )
UpdateParticles();
#endif
if ( lightDefHandle >= 0 ){
if ( state == BURNING ) {
// ramp the color up over 250 ms
@ -868,10 +885,17 @@ void idExplodingBarrel::Think( void ) {
return;
}
// This condition fixes the problem where particleRenderEntity is used for explosion effect
// and it still tries to track the physics origin even after physics is put to rest.
#ifdef _DENTONMOD
if ( particleModelDefHandle >= 0 && state == BURNING ){
#else
if ( particleModelDefHandle >= 0 ){
#endif
particleRenderEntity.origin = physicsObj.GetAbsBounds().GetCenter();
particleRenderEntity.axis = mat3_identity;
gameRenderWorld->UpdateEntityDef( particleModelDefHandle, &particleRenderEntity );
}
}
@ -952,11 +976,6 @@ void idExplodingBarrel::ExplodingEffects( void ) {
Show();
}
temp = spawnArgs.GetString( "model_detonate" );
if ( *temp != '\0' ) {
AddParticles( temp, false );
}
temp = spawnArgs.GetString( "mtr_lightexplode" );
if ( *temp != '\0' ) {
AddLight( temp, false );
@ -966,6 +985,11 @@ void idExplodingBarrel::ExplodingEffects( void ) {
if ( *temp != '\0' ) {
gameLocal.ProjectDecal( GetPhysics()->GetOrigin(), GetPhysics()->GetGravity(), 128.0f, true, 96.0f, temp );
}
// put the explosion particle effect to the end -- By Clone JCD
temp = spawnArgs.GetString( "model_detonate" );
if ( *temp != '\0' ) {
AddParticles( temp, false );
}
}
/*
@ -975,18 +999,36 @@ idExplodingBarrel::Killed
*/
void idExplodingBarrel::Killed( idEntity *inflictor, idEntity *attacker, int damage, const idVec3 &dir, int location ) {
// This simple condition causes a barrel to explode when shot while burning
#ifdef _DENTONMOD
if ( IsHidden() || state == EXPLODING ) {
#else
if ( IsHidden() || state == EXPLODING || state == BURNING ) {
#endif
return;
}
float f = spawnArgs.GetFloat( "burn" );
#ifdef _DENTONMOD
int explodeHealth = spawnArgs.GetInt( "explode_health" );
if ( f > 0.0f && state == NORMAL && health > explodeHealth ) {
#else
if ( f > 0.0f && state == NORMAL ) {
#endif
state = BURNING;
PostEventSec( &EV_Explode, f );
StartSound( "snd_burn", SND_CHANNEL_ANY, 0, false, NULL );
AddParticles( spawnArgs.GetString ( "model_burn", "" ), true );
return;
} else {
#ifdef _DENTONMOD
if( state == BURNING && health > explodeHealth ) {
return;
}
#endif
state = EXPLODING;
if ( gameLocal.isServer ) {
idBitMsg msg;
@ -1000,8 +1042,12 @@ void idExplodingBarrel::Killed( idEntity *inflictor, idEntity *attacker, int dam
// do this before applying radius damage so the ent can trace to any damagable ents nearby
Hide();
physicsObj.SetContents( 0 );
#ifdef _DENTONMOD
BecomeInactive(TH_PHYSICS); // This causes the physics not to update after explosion
#else
physicsObj.SetContents( 0 ); // Set physics content 0 after spawining debris.
#endif
const char *splash = spawnArgs.GetString( "def_splash_damage", "damage_explosion" );
if ( splash && *splash ) {
gameLocal.RadiusDamage( GetPhysics()->GetOrigin(), this, attacker, this, this, splash );
@ -1042,8 +1088,12 @@ void idExplodingBarrel::Killed( idEntity *inflictor, idEntity *attacker, int dam
}
kv = spawnArgs.MatchPrefix( "def_debris", kv );
}
#ifdef _DENTONMOD
physicsObj.SetContents( 0 );
#endif
physicsObj.PutToRest();
CancelEvents( &EV_Explode );
CancelEvents( &EV_Activate );
@ -1071,11 +1121,16 @@ void idExplodingBarrel::Damage( idEntity *inflictor, idEntity *attacker, const i
if ( !damageDef ) {
gameLocal.Error( "Unknown damageDef '%s'\n", damageDefName );
}
#ifndef _DENTONMOD // Following condition means, if inflictor's got a radius damage then explode immediately,
// which could cause explosions when barrel's health is greater than 0 so I am disabling it.
if ( damageDef->FindKey( "radius" ) && GetPhysics()->GetContents() != 0 && GetBindMaster() == NULL ) {
PostEventMS( &EV_Explode, 400 );
} else {
#endif
idEntity::Damage( inflictor, attacker, dir, damageDefName, damageScale, location );
#ifndef _DENTONMOD
}
#endif
}
/*

431
game/Player.cpp
View file

@ -92,6 +92,9 @@ const idEventDef EV_Player_LevelTrigger( "levelTrigger" );
const idEventDef EV_SpectatorTouch( "spectatorTouch", "et" );
const idEventDef EV_Player_GetIdealWeapon( "getIdealWeapon", NULL, 's' );
const idEventDef EV_Player_WeaponAvailable( "weaponAvailable", "s", 'd');//
const idEventDef EV_Player_GetImpulseKey( "getImpulseKey", NULL, 'd' ); // Added By Clone JC Denton
CLASS_DECLARATION( idActor, idPlayer )
EVENT( EV_Player_GetButtons, idPlayer::Event_GetButtons )
EVENT( EV_Player_GetMove, idPlayer::Event_GetMove )
@ -110,6 +113,8 @@ CLASS_DECLARATION( idActor, idPlayer )
EVENT( EV_Player_HideTip, idPlayer::Event_HideTip )
EVENT( EV_Player_LevelTrigger, idPlayer::Event_LevelTrigger )
EVENT( EV_Gibbed, idPlayer::Event_Gibbed )
EVENT( EV_Player_WeaponAvailable, idPlayer::Event_WeaponAvailable )//
EVENT( EV_Player_GetImpulseKey, idPlayer::Event_GetImpulseKey ) // Added By Clone JCD
EVENT( EV_Player_GetIdealWeapon, idPlayer::Event_GetIdealWeapon )
END_CLASS
@ -249,6 +254,10 @@ void idInventory::GetPersistantData( idDict &dict ) {
}
}
//Save the clip data
for( i = 0; i < MAX_WEAPONS; i++ ) { //new
dict.SetInt( va("clip%i", i), clip[ i ] );
}
// items
num = 0;
for( i = 0; i < items.Num(); i++ ) {
@ -346,6 +355,10 @@ void idInventory::RestoreInventory( idPlayer *owner, const idDict &dict ) {
}
}
//Restore the clip data
for( i = 0; i < MAX_WEAPONS; i++ ) {//new
clip[i] = dict.GetInt(va("clip%i", i), "-1");
}
// items
num = dict.GetInt( "items" );
items.SetNum( num );
@ -709,7 +722,8 @@ ammo_t idInventory::AmmoIndexForWeaponClass( const char *weapon_classname, int *
idInventory::AddPickupName
==============
*/
void idInventory::AddPickupName( const char *name, const char *icon ) {
//void idInventory::AddPickupName( const char *name, const char *icon ) {
void idInventory::AddPickupName( const char *name, const char *icon, idPlayer* owner ) { //New, Dont know what it does
int num;
num = pickupItemNames.Num();
@ -722,6 +736,14 @@ void idInventory::AddPickupName( const char *name, const char *icon ) {
info.name = name;
}
info.icon = icon;
if ( gameLocal.isServer ) {
idBitMsg msg;
byte msgBuf[MAX_EVENT_PARAM_SIZE];
msg.Init( msgBuf, sizeof( msgBuf ) );
msg.WriteString( name, MAX_EVENT_PARAM_SIZE );
owner->ServerSendEvent( idPlayer::EVENT_PICKUPNAME, &msg, false, -1 );
}
}
}
@ -759,7 +781,7 @@ bool idInventory::Give( idPlayer *owner, const idDict &spawnArgs, const char *st
name = AmmoPickupNameForIndex( i );
if ( idStr::Length( name ) ) {
AddPickupName( name, "" );
AddPickupName( name, "", owner ); //new _D3XP
}
}
} else if ( !idStr::Icmp( statname, "armor" ) ) {
@ -779,7 +801,7 @@ bool idInventory::Give( idPlayer *owner, const idDict &spawnArgs, const char *st
i = WeaponIndexForAmmoClass( spawnArgs, statname + 7 );
if ( i != -1 ) {
// set, don't add. not going over the clip size limit.
clip[ i ] = atoi( value );
// clip[ i ] = atoi( value ); // FIXME: what about this?
}
} else if ( !idStr::Icmp( statname, "berserk" ) ) {
GivePowerUp( owner, BERSERK, SEC2MS( atof( value ) ) );
@ -806,7 +828,8 @@ bool idInventory::Give( idPlayer *owner, const idDict &spawnArgs, const char *st
}
if ( i >= MAX_WEAPONS ) {
gameLocal.Error( "Unknown weapon '%s'", weaponName.c_str() );
gameLocal.Warning( "Unknown weapon '%s'", weaponName.c_str() );
continue;
}
// cache the media for this weapon
@ -821,10 +844,6 @@ bool idInventory::Give( idPlayer *owner, const idDict &spawnArgs, const char *st
if ( !gameLocal.world->spawnArgs.GetBool( "no_Weapons" ) || ( weaponName == "weapon_fists" ) || ( weaponName == "weapon_soulcube" ) ) {
if ( ( weapons & ( 1 << i ) ) == 0 || gameLocal.isMultiplayer ) {
if ( owner->GetUserInfo()->GetBool( "ui_autoSwitch" ) && idealWeapon ) {
assert( !gameLocal.isClient );
*idealWeapon = i;
}
if ( owner->hud && updateHud && lastGiveTime + 1000 < gameLocal.time ) {
owner->hud->SetStateInt( "newWeapon", i );
owner->hud->HandleNamedEvent( "newWeapon" );
@ -903,10 +922,15 @@ int idInventory::HasAmmo( ammo_t type, int amount ) {
idInventory::HasAmmo
===============
*/
int idInventory::HasAmmo( const char *weapon_classname ) {
int idInventory::HasAmmo( const char *weapon_classname, bool includeClip, idPlayer* owner ) { //_D3XP
int ammoRequired;
ammo_t ammo_i = AmmoIndexForWeaponClass( weapon_classname, &ammoRequired );
return HasAmmo( ammo_i, ammoRequired );
int ammoCount = HasAmmo( ammo_i, ammoRequired );
if(includeClip && owner) {
ammoCount += clip[owner->SlotForWeapon(weapon_classname)];
}
return ammoCount;
}
/*
@ -1032,6 +1056,7 @@ idPlayer::idPlayer() {
currentWeapon = -1;
idealWeapon = -1;
previousWeapon = -1;
quickWeapon = -1; //new
weaponSwitchTime = 0;
weaponEnabled = true;
weapon_soulcube = -1;
@ -1133,6 +1158,11 @@ idPlayer::idPlayer() {
isChatting = false;
selfSmooth = false;
#ifdef _DENTONMOD_PLAYER_CPP
memset( &weaponZoom, 0, sizeof( weaponZoom ) ); // New
memset( projectileType, 0, sizeof(projectileType) );
#endif //_DENTONMOD_PLAYER_CPP
}
/*
@ -1206,9 +1236,14 @@ void idPlayer::Init( void ) {
oldButtons = 0;
oldFlags = 0;
#ifdef _DENTONMOD_PLAYER_CPP
memset( &weaponZoom, 0, sizeof( weaponZoom ) ); // New
#endif //_DENTONMOD_PLAYER_CPP
currentWeapon = -1;
idealWeapon = -1;
previousWeapon = -1;
quickWeapon = -1; //new
weaponSwitchTime = 0;
weaponEnabled = true;
weapon_soulcube = SlotForWeapon( "weapon_soulcube" );
@ -1268,6 +1303,7 @@ void idPlayer::Init( void ) {
SetupWeaponEntity();
currentWeapon = -1;
previousWeapon = -1;
quickWeapon = -1; //new
heartRate = BASE_HEARTRATE;
AdjustHeartRate( BASE_HEARTRATE, 0.0f, 0.0f, true );
@ -1592,6 +1628,36 @@ void idPlayer::Spawn( void ) {
}
}
}
//Setup the weapon toggle lists //NEW
const idKeyValue *kv;
kv = spawnArgs.MatchPrefix( "weapontoggle", NULL );
while( kv ) {
WeaponToggle_t newToggle;
strcpy(newToggle.name, kv->GetKey().c_str());
idStr toggleData = kv->GetValue();
idLexer src;
idToken token;
src.LoadMemory(toggleData, toggleData.Length(), "toggleData");
while(1) {
if(!src.ReadToken(&token)) {
break;
}
int index = atoi(token.c_str());
newToggle.toggleList.Append(index);
//Skip the ,
src.ReadToken(&token);
}
weaponToggles.Set(newToggle.name, newToggle);
kv = spawnArgs.MatchPrefix( "weapontoggle", kv );
}
#ifdef _DENTONMOD_PLAYER_CPP
memset( projectileType, 0, sizeof(projectileType) );
#endif
}
/*
@ -1728,6 +1794,7 @@ void idPlayer::Save( idSaveGame *savefile ) const {
savefile->WriteInt( currentWeapon );
savefile->WriteInt( idealWeapon );
savefile->WriteInt( previousWeapon );
savefile->WriteInt( quickWeapon ); //new
savefile->WriteInt( weaponSwitchTime );
savefile->WriteBool( weaponEnabled );
savefile->WriteBool( showWeaponViewModel );
@ -1747,6 +1814,17 @@ void idPlayer::Save( idSaveGame *savefile ) const {
savefile->WriteBool( gibsLaunched );
savefile->WriteVec3( gibsDir );
//Remeber the order of saving this info... cause last time I did a stupid mistake....
#ifdef _DENTONMOD_PLAYER_CPP
weaponZoom_s flags = weaponZoom; // Save the weapon Zoom Info
LittleBitField( &flags, sizeof( flags ) );
savefile->Write( &flags, sizeof( flags ) );
for( i = 0; i < MAX_WEAPONS; i++ ) {
savefile->WriteByte( projectileType[ i ] );
}
#endif //_DENTONMOD_PLAYER_CPP
savefile->WriteFloat( zoomFov.GetStartTime() );
savefile->WriteFloat( zoomFov.GetDuration() );
savefile->WriteFloat( zoomFov.GetStartValue() );
@ -1815,6 +1893,15 @@ void idPlayer::Save( idSaveGame *savefile ) const {
hud->SetStateString( "message", common->GetLanguageDict()->GetString( "#str_02916" ) );
hud->HandleNamedEvent( "Message" );
}
savefile->WriteInt(weaponToggles.Num()); //new, all lines from here
for(i = 0; i < weaponToggles.Num(); i++) {
WeaponToggle_t* weaponToggle = weaponToggles.GetIndex(i);
savefile->WriteString(weaponToggle->name);
savefile->WriteInt(weaponToggle->toggleList.Num());
for(int j = 0; j < weaponToggle->toggleList.Num(); j++) {
savefile->WriteInt(weaponToggle->toggleList[j]);
}
}
}
/*
@ -1960,6 +2047,7 @@ void idPlayer::Restore( idRestoreGame *savefile ) {
savefile->ReadInt( currentWeapon );
savefile->ReadInt( idealWeapon );
savefile->ReadInt( previousWeapon );
savefile->ReadInt( quickWeapon ); //new
savefile->ReadInt( weaponSwitchTime );
savefile->ReadBool( weaponEnabled );
savefile->ReadBool( showWeaponViewModel );
@ -1979,6 +2067,16 @@ void idPlayer::Restore( idRestoreGame *savefile ) {
savefile->ReadBool( gibsLaunched );
savefile->ReadVec3( gibsDir );
#ifdef _DENTONMOD_PLAYER_CPP
// Remember the order of saving this info...
savefile->Read( &weaponZoom, sizeof( weaponZoom ) );
LittleBitField( &weaponZoom, sizeof( weaponZoom ) );
for( i = 0; i < MAX_WEAPONS; i++ ) {
savefile->ReadByte( projectileType[ i ] );
}
#endif //_DENTONMOD_PLAYER_CPP
savefile->ReadFloat( set );
zoomFov.SetStartTime( set );
savefile->ReadFloat( set );
@ -2063,6 +2161,25 @@ void idPlayer::Restore( idRestoreGame *savefile ) {
// create combat collision hull for exact collision detection
SetCombatModel();
int weaponToggleCount; //new all lines from here
savefile->ReadInt(weaponToggleCount);
for(i = 0; i < weaponToggleCount; i++) {
WeaponToggle_t newToggle;
memset(&newToggle, 0, sizeof(newToggle));
idStr name;
savefile->ReadString(name);
strcpy(newToggle.name, name.c_str());
int indexCount;
savefile->ReadInt(indexCount);
for(int j = 0; j < indexCount; j++) {
int temp;
savefile->ReadInt(temp);
newToggle.toggleList.Append(temp);
}
weaponToggles.Set(newToggle.name, newToggle);
}
}
/*
@ -2488,15 +2605,17 @@ void idPlayer::UpdateHudAmmo( idUserInterface *_hud ) {
_hud->SetStateString( "player_totalammo", "" );
} else {
// show remaining ammo
_hud->SetStateString( "player_totalammo", va( "%i", ammoamount - inclip ) );
_hud->SetStateString( "player_totalammo", va( "%i", ammoamount ) ); //new
_hud->SetStateString( "player_ammo", weapon.GetEntity()->ClipSize() ? va( "%i", inclip ) : "--" ); // how much in the current clip
_hud->SetStateString( "player_clips", weapon.GetEntity()->ClipSize() ? va( "%i", ammoamount / weapon.GetEntity()->ClipSize() ) : "--" );
_hud->SetStateString( "player_allammo", va( "%i/%i", inclip, ammoamount - inclip ) );
_hud->SetStateString( "player_allammo", va( "%i/%i", inclip, ammoamount ) ); //new
}
_hud->SetStateBool( "player_ammo_empty", ( ammoamount == 0 ) );
_hud->SetStateBool( "player_clip_empty", ( weapon.GetEntity()->ClipSize() ? inclip == 0 : false ) );
_hud->SetStateBool( "player_clip_low", ( weapon.GetEntity()->ClipSize() ? inclip <= weapon.GetEntity()->LowAmmo() : false ) );
// Let the HUD know the total amount of ammo regardless of the ammo required value
_hud->SetStateString( "player_ammo_count", va("%i", weapon.GetEntity()->AmmoCount())); // new
_hud->HandleNamedEvent( "updateAmmo" );
}
@ -2787,15 +2906,30 @@ void idPlayer::FireWeapon( void ) {
}
if ( !hiddenWeapon && weapon.GetEntity()->IsReady() ) {
#ifdef _DENTONMOD
if ( ( weapon_soulcube >= 0 ) && ( currentWeapon == weapon_soulcube ) && currentWeapon == idealWeapon ) {
if ( hud ) {
hud->HandleNamedEvent( "soulCubeNotReady" );
}
quickWeapon = weapon_soulcube;
SelectWeapon( previousWeapon, false );
}
if ( weapon.GetEntity()->AmmoInClip() || weapon.GetEntity()->AmmoAvailable() ) {
AI_ATTACK_HELD = true;
weapon.GetEntity()->BeginAttack();
#else
if ( weapon.GetEntity()->AmmoInClip() || weapon.GetEntity()->AmmoAvailable() ) {
AI_ATTACK_HELD = true;
weapon.GetEntity()->BeginAttack();
if ( ( weapon_soulcube >= 0 ) && ( currentWeapon == weapon_soulcube ) ) {
if ( hud ) {
hud->HandleNamedEvent( "soulCubeNotReady" );
}
SelectWeapon( previousWeapon, false );
}
#endif
} else {
NextBestWeapon();
}
@ -2958,7 +3092,9 @@ bool idPlayer::GiveItem( idItem *item ) {
// display the pickup feedback on the hud
if ( gave && ( numPickup == inventory.pickupItemNames.Num() ) ) {
inventory.AddPickupName( item->spawnArgs.GetString( "inv_name" ), item->spawnArgs.GetString( "inv_icon" ) );
// inventory.AddPickupName( item->spawnArgs.GetString( "inv_name" ), item->spawnArgs.GetString( "inv_icon" ) );
inventory.AddPickupName( item->spawnArgs.GetString( "inv_name" ), item->spawnArgs.GetString( "inv_icon" ), this ); //New _D3XP
}
return gave;
@ -3486,6 +3622,27 @@ void idPlayer::Reload( void ) {
weapon.GetEntity()->Reload();
}
}
/*
===============
idPlayer::WeaponSpecialFunction
Weapon special function- Added by Clone JC Denton
===============
*/
void idPlayer::WeaponSpecialFunction( bool keyTapped ) {
if ( gameLocal.isClient ) {
return;
}
if ( spectating || gameLocal.inCinematic || influenceActive ) {
return;
}
if ( !hiddenWeapon && weapon.GetEntity() && weapon.GetEntity()->IsLinked() ) {
weapon.GetEntity()->BeginSpecialFunction( keyTapped );
}
}
/*
===============
@ -3496,14 +3653,19 @@ void idPlayer::NextBestWeapon( void ) {
const char *weap;
int w = MAX_WEAPONS;
#ifdef _DENTONMOD
if ( gameLocal.isClient || !weaponEnabled || currentWeapon != idealWeapon ) {
#else
if ( gameLocal.isClient || !weaponEnabled ) {
#endif
return;
}
while ( w > 0 ) {
w--;
weap = spawnArgs.GetString( va( "def_weapon%d", w ) );
if ( !weap[ 0 ] || ( ( inventory.weapons & ( 1 << w ) ) == 0 ) || ( !inventory.HasAmmo( weap ) ) ) {
if ( !weap[ 0 ] || ( ( inventory.weapons & ( 1 << w ) ) == 0 ) || ( !inventory.HasAmmo( weap, true, this ) ) ) { //new
//if ( !weap[ 0 ] || ( ( inventory.weapons & ( 1 << w ) ) == 0 ) || ( !inventory.HasAmmo( weap ) ) ) {
continue;
}
if ( !spawnArgs.GetBool( va( "weapon%d_best", w ) ) ) {
@ -3511,6 +3673,11 @@ void idPlayer::NextBestWeapon( void ) {
}
break;
}
#ifdef _DENTONMOD
if( w != idealWeapon ) {
quickWeapon = idealWeapon;
}
#endif
idealWeapon = w;
weaponSwitchTime = gameLocal.time + WEAPON_SWITCH_DELAY;
UpdateHudWeapon();
@ -3554,7 +3721,8 @@ void idPlayer::NextWeapon( void ) {
if ( ( inventory.weapons & ( 1 << w ) ) == 0 ) {
continue;
}
if ( inventory.HasAmmo( weap ) ) {
if ( inventory.HasAmmo( weap, true, this ) ) {//new
// if ( inventory.HasAmmo( weap ) ) {
break;
}
}
@ -3604,7 +3772,8 @@ void idPlayer::PrevWeapon( void ) {
if ( ( inventory.weapons & ( 1 << w ) ) == 0 ) {
continue;
}
if ( inventory.HasAmmo( weap ) ) {
if ( inventory.HasAmmo( weap, true, this ) ) { //new
//if ( inventory.HasAmmo( weap ) ) {
break;
}
}
@ -3621,7 +3790,7 @@ void idPlayer::PrevWeapon( void ) {
idPlayer::SelectWeapon
===============
*/
void idPlayer::SelectWeapon( int num, bool force ) {
void idPlayer::SelectWeapon( int num, bool force, const bool toggleWeapons ) {
const char *weap;
if ( !weaponEnabled || spectating || gameLocal.inCinematic || health < 0 ) {
@ -3652,13 +3821,59 @@ void idPlayer::SelectWeapon( int num, bool force ) {
return;
}
WeaponToggle_t* weaponToggle;
//Is the weapon a toggle weapon & player is trying to select it.
if(weaponToggles.Get(va("weapontoggle%d", num), &weaponToggle) && toggleWeapons ) {
int weaponToggleIndex = 0;
//Find the current Weapon in the list
int currentIndex = -1;
for(int i = 0; i < weaponToggle->toggleList.Num(); i++) {
if(weaponToggle->toggleList[i] == idealWeapon) {
currentIndex = i;
break;
}
}
if(currentIndex == -1) {
//Didn't find the current weapon so select the first item
weaponToggleIndex = 0;
} else {
//Roll to the next available item in the list
weaponToggleIndex = currentIndex;
weaponToggleIndex++;
if(weaponToggleIndex >= weaponToggle->toggleList.Num()) {
weaponToggleIndex = 0;
}
}
for(int i = 0; i < weaponToggle->toggleList.Num(); i++) {
//Is it available
if(inventory.weapons & ( 1 << weaponToggle->toggleList[weaponToggleIndex])) {
break;
}
weaponToggleIndex++;
if(weaponToggleIndex >= weaponToggle->toggleList.Num()) {
weaponToggleIndex = 0;
}
}
num = weaponToggle->toggleList[weaponToggleIndex];
}
if ( force || ( inventory.weapons & ( 1 << num ) ) ) {
if ( !inventory.HasAmmo( weap ) && !spawnArgs.GetBool( va( "weapon%d_allowempty", num ) ) ) {
if ( !inventory.HasAmmo( weap, true, this ) && !spawnArgs.GetBool( va( "weapon%d_allowempty", num ) ) ) {
return;
}
if ( ( previousWeapon >= 0 ) && ( idealWeapon == num ) && ( spawnArgs.GetBool( va( "weapon%d_toggle", num ) ) ) ) {
weap = spawnArgs.GetString( va( "def_weapon%d", previousWeapon ) );
if ( !inventory.HasAmmo( weap ) && !spawnArgs.GetBool( va( "weapon%d_allowempty", previousWeapon ) ) ) {
if ( !inventory.HasAmmo( weap, true, this ) && !spawnArgs.GetBool( va( "weapon%d_allowempty", previousWeapon ) ) ) {
return;
}
idealWeapon = previousWeapon;
@ -3699,6 +3914,7 @@ void idPlayer::DropWeapon( bool died ) {
if ( !idStr::Icmp( idWeapon::GetAmmoNameForNum( weapon.GetEntity()->GetAmmoType() ), "ammo_grenades" ) && ( ammoavailable - inclip <= 0 ) ) {
return;
}
ammoavailable += inclip; //new
// expect an ammo setup that makes sense before doing any dropping
// ammoavailable is -1 for infinite ammo, and weapons like chainsaw
@ -3725,6 +3941,7 @@ void idPlayer::DropWeapon( bool died ) {
item->spawnArgs.SetInt( keyval->GetKey(), ammoavailable );
idStr inclipKey = keyval->GetKey();
inclipKey.Insert( "inclip_", 4 );
inclipKey.Insert( va("%.2d", currentWeapon), 11);//new
item->spawnArgs.SetInt( inclipKey, inclip );
}
if ( !died ) {
@ -3764,6 +3981,9 @@ void idPlayer::StealWeapon( idPlayer *player ) {
assert( weapon_classname );
int ammoavailable = player->weapon.GetEntity()->AmmoAvailable();
int inclip = player->weapon.GetEntity()->AmmoInClip();
ammoavailable += inclip; //new
if ( ( ammoavailable != -1 ) && ( ammoavailable - inclip < 0 ) ) {
// see DropWeapon
common->DPrintf( "idPlayer::StealWeapon: bad ammo setup\n" );
@ -3871,8 +4091,21 @@ void idPlayer::Weapon_Combat( void ) {
weaponGone = false; // if you drop and re-get weap, you may miss the = false above
if ( weapon.GetEntity()->IsHolstered() ) {
if ( !weapon.GetEntity()->AmmoAvailable() ) {
#ifdef _DENTONMOD // If weapon with no ammo is soulcube, switch to previous weapon
if ( ( weapon_soulcube >= 0 ) && ( currentWeapon == weapon_soulcube ) && currentWeapon == idealWeapon ) {
if ( hud ) {
hud->HandleNamedEvent( "soulCubeNotReady" );
}
quickWeapon = weapon_soulcube;
SelectWeapon( previousWeapon, false );
} else {
// weapons can switch automatically if they have no more ammo
NextBestWeapon();
}
#else
// weapons can switch automatically if they have no more ammo
NextBestWeapon();
#endif
} else {
weapon.GetEntity()->Raise();
state = GetScriptFunction( "RaiseWeapon" );
@ -3892,6 +4125,13 @@ void idPlayer::Weapon_Combat( void ) {
AI_ATTACK_HELD = false;
weapon.GetEntity()->EndAttack();
}
// check for Weapon special function, new
if ( ( usercmd.buttons & BUTTON_5 ) && !weaponGone ) { // BUTTON_5 is being used for weapon special function
WeaponSpecialFunction( !(oldButtons & BUTTON_5) ); // The condition holds True when key is being tapped rather than held
} else if ( oldButtons & BUTTON_5 ) {
weapon.GetEntity()->EndSpecialFunction();
}
}
// update our ammo clip in our inventory
@ -5537,6 +5777,7 @@ idPlayer::PerformImpulse
==============
*/
void idPlayer::PerformImpulse( int impulse ) {
int prevIdealWeap;
if ( gameLocal.isClient ) {
idBitMsg msg;
@ -5549,22 +5790,65 @@ void idPlayer::PerformImpulse( int impulse ) {
ClientSendEvent( EVENT_IMPULSE, &msg );
}
if ( impulse >= IMPULSE_0 && impulse <= IMPULSE_12 ) {
SelectWeapon( impulse, false );
if ( impulse == IMPULSE_21 || (impulse >= IMPULSE_23 && impulse <= IMPULSE_27) ) {
int weap;
if ( spawnArgs.GetInt ( va("impulse%d", impulse), "0", weap ) ) {
prevIdealWeap = idealWeapon;
SelectWeapon( weap, false);
if( idealWeapon != prevIdealWeap ) {
quickWeapon = prevIdealWeap;
}
}
return;
}
if ( impulse >= IMPULSE_0 && impulse <= IMPULSE_12 ) {
WeaponToggle_t* weaponToggle;
// This loop works as a small bug fix for toggle weapons -By Clone JC Denton
// It simply increments the impulse value if there are multiple weapons under one weapon slot.
for (int i=0; i<impulse; i++) {
if (weaponToggles.Get(va("weapontoggle%d", i), &weaponToggle))
impulse += weaponToggle->toggleList.Num() - 1;
}
prevIdealWeap = idealWeapon;
SelectWeapon( impulse, false, true);
if( idealWeapon != prevIdealWeap ) {
quickWeapon = prevIdealWeap;
}
return;
}
switch( impulse ) {
case IMPULSE_13: {
Reload();
break;
}
case IMPULSE_14: {
prevIdealWeap = idealWeapon;
NextWeapon();
if( idealWeapon != prevIdealWeap ) {
quickWeapon = prevIdealWeap;
}
break;
}
case IMPULSE_15: {
prevIdealWeap = idealWeapon;
PrevWeapon();
if( idealWeapon != prevIdealWeap ) {
quickWeapon = prevIdealWeap;
}
break;
}
case IMPULSE_16: { // New, for half-life style quick weapon
if ( quickWeapon == -1 ) {
return;
}
prevIdealWeap = idealWeapon;
SelectWeapon( quickWeapon, false );
quickWeapon = prevIdealWeap;
break;
}
case IMPULSE_17: {
@ -5613,6 +5897,10 @@ void idPlayer::PerformImpulse( int impulse ) {
}
break;
}
/* case IMPULSE_30: {
WeaponSpecialFunction ();
break;
}*/
case IMPULSE_40: {
UseVehicle();
break;
@ -6249,6 +6537,19 @@ void idPlayer::Think( void ) {
}
}
#ifdef _DENTONMOD_PLAYER_CPP
// zooming, initiated by weapon script
if ( ( weaponZoom.oldZoomStatus ^ weaponZoom.startZoom ) ) {
if ( weaponZoom.startZoom && weapon.GetEntity() ) {
weaponZoom.oldZoomStatus = true;
zoomFov.Init( gameLocal.time, 200.0f, CalcFov( false ), weapon.GetEntity()->GetZoomFov() );
} else {
weaponZoom.oldZoomStatus = false;
zoomFov.Init( gameLocal.time, 200.0f, zoomFov.GetCurrentValue( gameLocal.time ), DefaultFov() );
}
}
#endif //_DENTONMOD_PLAYER_CPP
// if we have an active gui, we will unrotate the view angles as
// we turn the mouse movements into gui events
idUserInterface *gui = ActiveGui();
@ -6394,6 +6695,10 @@ void idPlayer::Think( void ) {
}
gameLocal.Printf( "%d: enemies\n", num );
}
#ifdef _PORTALSKY
// determine if portal sky is in pvs
gameLocal.portalSkyActive = gameLocal.pvs.CheckAreasForPortalSky( gameLocal.GetPlayerPVS(), GetPhysics()->GetOrigin() );
#endif
}
/*
@ -6961,8 +7266,13 @@ float idPlayer::CalcFov( bool honorZoom ) {
return influenceFov;
}
#ifdef _DENTONMOD_PLAYER_CPP
if ( zoomFov.IsDone( gameLocal.time ) ) {
fov = ( honorZoom && usercmd.buttons & BUTTON_ZOOM ) && weapon.GetEntity() ? weapon.GetEntity()->GetZoomFov() : DefaultFov();
fov = ( honorZoom && ((usercmd.buttons & BUTTON_ZOOM) || weaponZoom.startZoom )) && weapon.GetEntity() ? weapon.GetEntity()->GetZoomFov() : DefaultFov(); // Updated By Clone JCD
#else
if ( zoomFov.IsDone( gameLocal.time ) ) {
fov = ( honorZoom && (usercmd.buttons & BUTTON_ZOOM)) && weapon.GetEntity() ? weapon.GetEntity()->GetZoomFov() : DefaultFov(); // Updated By Clone JCD
#endif// _DENTONMOD_PLAYER_CPP
} else {
fov = zoomFov.GetCurrentValue( gameLocal.time );
}
@ -7665,7 +7975,11 @@ void idPlayer::Event_SelectWeapon( const char *weaponName ) {
}
if ( hiddenWeapon && gameLocal.world->spawnArgs.GetBool( "no_Weapons" ) ) {
#ifdef _DENTONMOD
idealWeapon = quickWeapon = weapon_fists;
#else
idealWeapon = weapon_fists;
#endif
weapon.GetEntity()->HideWeapon();
return;
}
@ -7687,7 +8001,13 @@ void idPlayer::Event_SelectWeapon( const char *weaponName ) {
}
hiddenWeapon = false;
#ifdef _DENTONMOD
if( idealWeapon != weaponNum ) {
quickWeapon = idealWeapon;
}
idealWeapon = weaponNum;
#endif
UpdateHudWeapon();
}
@ -7923,6 +8243,13 @@ void idPlayer::ClientPredictionThink( void ) {
if ( gameLocal.isNewFrame && entityNumber == gameLocal.localClientNum ) {
playerView.CalculateShake();
}
#ifdef _PORTALSKY
// determine if portal sky is in pvs
pvsHandle_t clientPVS = gameLocal.pvs.SetupCurrentPVS( GetPVSAreas(), GetNumPVSAreas() );
gameLocal.portalSkyActive = gameLocal.pvs.CheckAreasForPortalSky( clientPVS, GetPhysics()->GetOrigin() );
gameLocal.pvs.FreeCurrentPVS( clientPVS );
#endif
}
/*
@ -8161,7 +8488,8 @@ void idPlayer::WritePlayerStateToSnapshot( idBitMsgDelta &msg ) const {
msg.WriteByte( bobCycle );
msg.WriteInt( stepUpTime );
msg.WriteFloat( stepUpDelta );
msg.WriteShort( inventory.weapons );
msg.WriteInt( inventory.weapons );//new
// msg.WriteShort( inventory.weapons );
msg.WriteByte( inventory.armor );
for( i = 0; i < AMMO_NUMTYPES; i++ ) {
@ -8183,7 +8511,8 @@ void idPlayer::ReadPlayerStateFromSnapshot( const idBitMsgDelta &msg ) {
bobCycle = msg.ReadByte();
stepUpTime = msg.ReadInt();
stepUpDelta = msg.ReadFloat();
inventory.weapons = msg.ReadShort();
inventory.weapons = msg.ReadInt();//new
// inventory.weapons = msg.ReadShort();
inventory.armor = msg.ReadByte();
for( i = 0; i < AMMO_NUMTYPES; i++ ) {
@ -8246,6 +8575,12 @@ bool idPlayer::ClientReceiveEvent( int event, int time, const idBitMsg &msg ) {
}
return true;
}
case EVENT_PICKUPNAME: { //New, Not so sure what it does
char buf[MAX_EVENT_PARAM_SIZE];
msg.ReadString(buf, MAX_EVENT_PARAM_SIZE);
inventory.AddPickupName(buf, "", this); //New from_D3XP
return true;
}
case EVENT_SPECTATE: {
bool spectate = ( msg.ReadBits( 1 ) != 0 );
Spectate( spectate );
@ -8520,3 +8855,51 @@ bool idPlayer::NeedsIcon( void ) {
// local clients don't render their own icons... they're only info for other clients
return entityNumber != gameLocal.localClientNum && ( isLagged || isChatting );
}
/*
==================
idPlayer::Event_WeaponAvailable
==================
*/
void idPlayer::Event_WeaponAvailable( const char* name ) {
idThread::ReturnInt( WeaponAvailable(name) ? 1 : 0 );
}
/*
==================
idPlayer::Event_GetImpulseKey
==================
*/
void idPlayer::Event_GetImpulseKey( void ) {
idThread::ReturnInt( usercmd.impulse );
}
bool idPlayer::WeaponAvailable( const char* name ) {
for( int i = 0; i < MAX_WEAPONS; i++ ) {
if ( inventory.weapons & ( 1 << i ) ) {
const char *weap = spawnArgs.GetString( va( "def_weapon%d", i ) );
if ( !idStr::Cmp( weap, name ) ) {
return true;
}
}
}
return false;
}
/*
=================
idPlayer::GetCurrentWeapon //New
=================
idStr idPlayer::GetCurrentWeapon() {
const char *weapon;
if ( currentWeapon >= 0 ) {
weapon = spawnArgs.GetString( va( "def_weapon%d", currentWeapon ) );
return weapon;
} else {
return "";
}
}
*/

73
game/Player.h
View file

@ -41,6 +41,10 @@ If you have questions concerning this license or the applicable additional terms
class idAI;
#ifndef _DENTONMOD_PLAYER_CPP
#define _DENTONMOD_PLAYER_CPP
#endif
/*
===============================================================================
@ -64,7 +68,7 @@ const int LAND_RETURN_TIME = 300;
const int FOCUS_TIME = 300;
const int FOCUS_GUI_TIME = 500;
const int MAX_WEAPONS = 16;
const int MAX_WEAPONS = 32; //16
const int DEAD_HEARTRATE = 0; // fall to as you die
const int LOWHEALTH_HEARTRATE_ADJ = 20; //
@ -122,6 +126,11 @@ enum {
INFLUENCE_LEVEL3, // slow player movement
};
typedef struct {
char name[64];
idList<int> toggleList;
} WeaponToggle_t;
class idInventory {
public:
int maxHealth;
@ -181,11 +190,13 @@ public:
int WeaponIndexForAmmoClass( const idDict & spawnArgs, const char *ammo_classname ) const;
ammo_t AmmoIndexForWeaponClass( const char *weapon_classname, int *ammoRequired );
const char * AmmoPickupNameForIndex( ammo_t ammonum ) const;
void AddPickupName( const char *name, const char *icon );
// void AddPickupName( const char *name, const char *icon );
void AddPickupName( const char *name, const char *icon, idPlayer* owner ); //new, dont know what it does.
int HasAmmo( ammo_t type, int amount );
bool UseAmmo( ammo_t type, int amount );
int HasAmmo( const char *weapon_classname ); // looks up the ammo information for the weapon class first
int HasAmmo( const char *weapon_classname, bool includeClip = false, idPlayer* owner = NULL ); //new _D3XP
//int HasAmmo( const char *weapon_classname ); // looks up the ammo information for the weapon class first
void UpdateArmor( void );
@ -214,6 +225,7 @@ public:
EVENT_ABORT_TELEPORTER,
EVENT_POWERUP,
EVENT_SPECTATE,
EVENT_PICKUPNAME, //new, for use with inventory::AddPickupName
EVENT_MAXEVENTS
};
@ -433,7 +445,7 @@ public:
void NextWeapon( void );
void NextBestWeapon( void );
void PrevWeapon( void );
void SelectWeapon( int num, bool force );
void SelectWeapon( int num, bool force , const bool toggleWeapons=false );
void DropWeapon( bool died ) ;
void StealWeapon( idPlayer *player );
void AddProjectilesFired( int count );
@ -500,6 +512,13 @@ public:
bool IsRespawning( void );
bool IsInTeleport( void );
// New------------------
#ifdef _DENTONMOD_PLAYER_CPP
void SetWeaponZoom( bool Status );
void SetProjectileType( int type );
int GetProjectileType( void );
#endif// _DENTONMOD_PLAYER_CPP
idEntity *GetInfluenceEntity( void ) { return influenceEntity; };
const idMaterial *GetInfluenceMaterial( void ) { return influenceMaterial; };
float GetInfluenceRadius( void ) { return influenceRadius; };
@ -521,6 +540,8 @@ public:
virtual void HidePlayerIcons( void );
bool NeedsIcon( void );
//idStr GetCurrentWeapon(); // new
bool SelfSmooth( void );
void SetSelfSmooth( bool b );
@ -552,6 +573,7 @@ private:
int currentWeapon;
int idealWeapon;
int previousWeapon;
int quickWeapon; // Since previousWeapon does not work in a best way for quick swap - Clone JCD
int weaponSwitchTime;
bool weaponEnabled;
bool showWeaponViewModel;
@ -618,6 +640,7 @@ private:
idVec3 smoothedOrigin;
idAngles smoothedAngles;
idHashTable<WeaponToggle_t> weaponToggles; // new
// mp
bool ready; // from userInfo
bool respawning; // set to true while in SpawnToPoint for telefrag checks
@ -633,6 +656,15 @@ private:
bool MPAimHighlight;
bool isTelefragged; // proper obituaries
#ifdef _DENTONMOD_PLAYER_CPP
struct weaponZoom_s {
bool oldZoomStatus : 1;
bool startZoom : 1;
} weaponZoom;
byte projectileType[ MAX_WEAPONS ];
#endif //_DENTONMOD_PLAYER_CPP
idPlayerIcon playerIcon;
bool selfSmooth;
@ -641,6 +673,7 @@ private:
void StopFiring( void );
void FireWeapon( void );
void WeaponSpecialFunction( bool keyTapped ); // New
void Weapon_Combat( void );
void Weapon_NPC( void );
void Weapon_GUI( void );
@ -675,8 +708,13 @@ private:
void ExtractEmailInfo( const idStr &email, const char *scan, idStr &out );
void UpdateObjectiveInfo( void );
bool WeaponAvailable( const char* name ); //new
void UseVehicle( void );
void Event_WeaponAvailable( const char* name ); // new
void Event_GetImpulseKey( void ); // new
void Event_GetButtons( void );
void Event_GetMove( void );
void Event_GetViewAngles( void );
@ -697,6 +735,33 @@ private:
void Event_GetIdealWeapon( void );
};
// New------------------
#ifdef _DENTONMOD_PLAYER_CPP
/*
==================
idPlayer::setZoom
Called By Weapon script, used for weapon zooming
==================
*/
ID_INLINE void idPlayer::SetWeaponZoom( bool status ) {
weaponZoom.startZoom = status;
}
ID_INLINE void idPlayer::SetProjectileType( int type ) {
projectileType[ currentWeapon ] = type;
}
ID_INLINE int idPlayer::GetProjectileType( void ) {
return projectileType[ currentWeapon ];
}
// New------------------
#endif // _DENTONMOD_PLAYER_CPP
ID_INLINE bool idPlayer::IsReady( void ) {
return ready || forcedReady;
}

237
game/PlayerView.cpp
View file

@ -36,7 +36,18 @@ If you have questions concerning this license or the applicable additional terms
#include "PlayerView.h"
static int MakePowerOfTwo( int num ) {
int pot;
for (pot = 1 ; pot < num ; pot<<=1) {
}
return pot;
}
const int IMPULSE_DELAY = 150;
const char *blurxMaterial[5] = { "textures/fsfx/blurx64", "textures/fsfx/blurx128", "textures/fsfx/blurx256", "textures/fsfx/blurx512", "textures/fsfx/blurx1024" };
const char *bluryMaterial[5] = { "textures/fsfx/blury32", "textures/fsfx/blury64", "textures/fsfx/blury128", "textures/fsfx/blury256", "textures/fsfx/blury512" };
/*
==============
idPlayerView::idPlayerView
@ -55,6 +66,11 @@ idPlayerView::idPlayerView() {
bfgMaterial = declManager->FindMaterial( "textures/decals/bfgvision" );
lagoMaterial = declManager->FindMaterial( LAGO_MATERIAL, false );
bfgVision = false;
#ifdef _DENTONMOD
//initWeights = false;
shiftSensitivityDelay = 0;
screenHeight = screenWidth = 0;
#endif
dvFinishTime = 0;
kickFinishTime = 0;
kickAngles.Zero();
@ -452,6 +468,39 @@ void idPlayerView::SingleView( idUserInterface *hud, const renderView_t *view )
renderView_t hackedView = *view;
hackedView.viewaxis = hackedView.viewaxis * ShakeAxis();
#ifdef _PORTALSKY
if ( gameLocal.portalSkyEnt.GetEntity() && gameLocal.IsPortalSkyAcive() && g_enablePortalSky.GetBool() ) {
renderView_t portalView = hackedView;
portalView.vieworg = gameLocal.portalSkyEnt.GetEntity()->GetPhysics()->GetOrigin();
// setup global fixup projection vars
if ( 1 ) {
int vidWidth, vidHeight;
idVec2 shiftScale;
renderSystem->GetGLSettings( vidWidth, vidHeight );
float pot;
int w = vidWidth;
pot = MakePowerOfTwo( w );
shiftScale.x = (float)w / pot;
int h = vidHeight;
pot = MakePowerOfTwo( h );
shiftScale.y = (float)h / pot;
hackedView.shaderParms[4] = shiftScale.x;
hackedView.shaderParms[5] = shiftScale.y;
}
gameRenderWorld->RenderScene( &portalView );
renderSystem->CaptureRenderToImage( "_currentRender" );
hackedView.forceUpdate = true; // FIX: for smoke particles not drawing when portalSky present
}
#endif // _PORTALSKY
gameRenderWorld->RenderScene( &hackedView );
if ( player->spectating ) {
@ -477,7 +526,8 @@ void idPlayerView::SingleView( idUserInterface *hud, const renderView_t *view )
renderSystem->DrawStretchPic( blob->x, blob->y, blob->w, blob->h,blob->s1, blob->t1, blob->s2, blob->t2, blob->material );
}
}
player->DrawHUD( hud );
/* player->DrawHUD( hud );*/
// armor impulse feedback
float armorPulse = ( gameLocal.time - player->lastArmorPulse ) / 250.0f;
@ -707,6 +757,27 @@ void idPlayerView::RenderPlayerView( idUserInterface *hud ) {
if ( g_skipViewEffects.GetBool() ) {
SingleView( hud, view );
} else {
#ifdef _DENTONMOD
// This condition makes sure that, the 2 loops inside run once only when resolution changes or map starts.
if( screenHeight != renderSystem->GetScreenHeight() || screenWidth !=renderSystem->GetScreenWidth() ) {
int width = 1, height = 1;
screenHeight = renderSystem->GetScreenHeight();
screenWidth = renderSystem->GetScreenWidth();
while( width < screenWidth ) {
width <<= 1;
}
while( height < screenHeight ) {
height <<= 1;
}
shiftScale_x = screenWidth / (float)width;
shiftScale_y = screenHeight / (float)height;
}
#endif
/* Render the standard view */
if ( player->GetInfluenceMaterial() || player->GetInfluenceEntity() ) {
InfluenceVision( hud, view );
} else if ( gameLocal.time < dvFinishTime ) {
@ -716,7 +787,169 @@ void idPlayerView::RenderPlayerView( idUserInterface *hud ) {
} else {
SingleView( hud, view );
}
ScreenFade();
#ifdef _DENTONMOD
/* Render bloom */
int bloomType = r_bloom.GetInteger();
if (bloomType != 0 && !player->objectiveSystemOpen) {
float blur_str, blur_cut, src_str, src_cut;
renderSystem->CaptureRenderToImage( "_currentRender" );
//------------------------------------------------
// Maha_x's Shift Sensitivity - Modified for compatibilty by Clone JCDenton
//------------------------------------------------
bool disableShiftSensitivity = ( r_bloom_shiftSensitivity_delay.GetInteger() == -1 );
if( !disableShiftSensitivity && (bloomType == 1 || bloomType == 2) && gameLocal.time > shiftSensitivityDelay ) {
renderSystem->CropRenderSize(2, 2, true, true);
shiftSensitivityDelay = gameLocal.time + r_bloom_shiftSensitivity_delay.GetInteger();
renderSystem->DrawStretchPic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 1, 1, 0, declManager->FindMaterial( "textures/AFX/AFXweight" ) );
renderSystem->CaptureRenderToImage( "_afxweight" );
renderSystem->UnCrop();
}
//------------------------------------------------
//-------------------------------------------------
// User configurable buffer size - By Clone JC Denton
//-------------------------------------------------
int bufferMult = 5 - r_bloom_buffer.GetInteger();
int blurMtrIndex;
if( bufferMult < 5 ) {
if( bufferMult <= 0 ) {
bufferMult = 1;
blurMtrIndex = 4;
}
else {
blurMtrIndex = 4 - bufferMult;
bufferMult = 1<<bufferMult;
}
renderSystem->CropRenderSize(1024/bufferMult, 512/bufferMult, true, true);
}
else {
renderSystem->CropRenderSize(512, 256, true, true);
blurMtrIndex = 3;
}
//-------------------------------------------------
//renderSystem->CropRenderSize(256, 128, true, true);
renderSystem->SetColor4( 1.0f, 1.0f, 1.0f, 1.0f );
renderSystem->DrawStretchPic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, shiftScale_y, shiftScale_x, 0, declManager->FindMaterial( "_currentRender" ) );
int bloomContrast = r_bloom_contrast.GetInteger();
if( bloomType == 2 && bloomContrast > 0 ) {
renderSystem->CaptureRenderToImage( "_fsfx_input" );
if( !disableShiftSensitivity ) {
renderSystem->SetColor4( r_bloom_contrast_mult.GetFloat(), r_bloom_contrast_min.GetFloat(), 1.0f, 1.0f );
} else {
renderSystem->SetColor4( r_bloom_contrast_mult.GetFloat(), r_bloom_contrast_mult.GetFloat(), 1.0f, 1.0f );
}
renderSystem->DrawStretchPic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 1, 1, 0, declManager->FindMaterial( "textures/AFX/AFXmodulate" ) );
}
else if( bloomType > 2 ) {
blur_str = r_bloom_blur_mult.GetFloat();
blur_cut = blur_str - (int)blur_str;
src_str = r_bloom_src_mult.GetFloat();
src_cut = src_str - (int)src_str;
if( bloomContrast == 1) {
renderSystem->CaptureRenderToImage( "_fsfx_input" );
renderSystem->DrawStretchPic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 1, 1, 0, declManager->FindMaterial( "textures/fsfx/blend_modulate_2x" ) );
} else if( bloomContrast == 2 ) {
renderSystem->DrawStretchPic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 1, 1, 0, declManager->FindMaterial( "textures/fsfx/invert_dst" ) );
renderSystem->SetColor4( 0.1f, 0.1f, 0.1f, 1.0f);
renderSystem->DrawStretchPic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 1, 1, 0, declManager->FindMaterial( "textures/fsfx/add_color" ) );
renderSystem->SetColor4( 1.0f, 1.0f, 1.0f, 1.0f);
renderSystem->DrawStretchPic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 1, 1, 0, declManager->FindMaterial( "textures/fsfx/invert_dst" ) );
renderSystem->CaptureRenderToImage( "_fsfx_input" );
renderSystem->DrawStretchPic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 1, 1, 0, declManager->FindMaterial( "textures/fsfx/blend_add" ) );
}
}
if( bloomType == 1 && bloomContrast > 0 ) {
//Unlike other bloomType, we are using the blurred image for obtaining bloom contrast.
renderSystem->CaptureRenderToImage( "_fsfx_input" );
renderSystem->DrawStretchPic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 1, 1, 0, declManager->FindMaterial( blurxMaterial[blurMtrIndex] ) );
renderSystem->CaptureRenderToImage( "_fsfx_input" );
renderSystem->DrawStretchPic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 1, 1, 0, declManager->FindMaterial( bluryMaterial[blurMtrIndex] ) );
renderSystem->CaptureRenderToImage( "_fsfx_input" );
if( !disableShiftSensitivity ) {
renderSystem->SetColor4(r_bloom_contrast_mult.GetFloat(), r_bloom_contrast_min.GetFloat(), 1, 1);
} else {
renderSystem->SetColor4(r_bloom_contrast_mult.GetFloat(), r_bloom_contrast_mult.GetFloat(), 1, 1);
}
renderSystem->DrawStretchPic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 1, 1, 0, declManager->FindMaterial( "textures/AFX/AFXmodulate" ) );
}
for( int i=0; i < r_bloom_blurIterations.GetInteger(); i++ ) {
// Two pass gaussian filter
renderSystem->CaptureRenderToImage( "_fsfx_input" );
renderSystem->DrawStretchPic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 1, 1, 0, declManager->FindMaterial( blurxMaterial[blurMtrIndex] ) );
renderSystem->CaptureRenderToImage( "_fsfx_input" );
renderSystem->DrawStretchPic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 1, 1, 0, declManager->FindMaterial( bluryMaterial[blurMtrIndex] ) );
}
if( bloomType > 2 ) {
if ((blur_str == 0.0f) || (blur_cut > 0.0f)) {
renderSystem->SetColor4( 0, 0, 0, 1.0f - blur_cut);
renderSystem->DrawStretchPic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, 1, 1, declManager->FindMaterial( "_white" ) );
blur_str -= blur_cut;
} else {
blur_str -= 1.0f;
}
renderSystem->SetColor4( 1.0f, 1.0f, 1.0f, 1.0f );
if( blur_str >= 1.0f ) { // two new lines, minor fix by Clone JCD
renderSystem->CaptureRenderToImage( "_fsfx_input" ); // Need to capture the current image before drawing blend_add
while (blur_str >= 1.0f) {
renderSystem->DrawStretchPic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 1, 1, 0, declManager->FindMaterial( "textures/fsfx/blend_add" ) );
blur_str -= 1.0f;
}
}
}
renderSystem->CaptureRenderToImage( "_fsfx_input" );
renderSystem->UnCrop();
if( bloomType <= 2) {
renderSystem->SetColor4( r_bloom_blur_mult.GetFloat(), r_bloom_src_mult.GetFloat(), 1.0f, 1.0f );
renderSystem->DrawStretchPic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 1, 1, 0, declManager->FindMaterial( "textures/AFX/AFXadd" ) );
}
else {
if ((src_str == 0.0f) || (src_cut > 0.0f)) {
renderSystem->SetColor4( src_cut, src_cut, src_cut, 1.0f);
src_str -= src_cut;
} else {
src_str -= 1.0f;
}
renderSystem->DrawStretchPic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, shiftScale_y, shiftScale_x, 0, declManager->FindMaterial( "_currentRender" ) );
renderSystem->SetColor4( 1.0f, 1.0f, 1.0f, 1.0f );
while (src_str >= 1.0f) {
renderSystem->DrawStretchPic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, shiftScale_y, shiftScale_x, 0, declManager->FindMaterial( "textures/fsfx/current_blend_add" ) );
src_str -= 1.0f;
}
renderSystem->DrawStretchPic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 1, 1, 0, declManager->FindMaterial( "textures/fsfx/blend_add" ) );
}
}
#endif
ScreenFade();
}
/* Render the hud on top of everything */
if ( !pm_thirdPerson.GetBool() && !g_skipViewEffects.GetBool() && !player->objectiveSystemOpen && !player->spectating ) {
player->DrawHUD( hud );
}
if ( net_clientLagOMeter.GetBool() && lagoMaterial && gameLocal.isClient ) {

8
game/PlayerView.h
View file

@ -110,6 +110,14 @@ private:
bool bfgVision; //
#ifdef _DENTONMOD
int shiftSensitivityDelay;
int screenHeight;
int screenWidth;
float shiftScale_x;
float shiftScale_y;
#endif
const idMaterial * tunnelMaterial; // health tunnel vision
const idMaterial * armorMaterial; // armor damage view effect
const idMaterial * berserkMaterial; // berserk effect

364
game/Projectile.cpp
View file

@ -35,9 +35,15 @@ If you have questions concerning this license or the applicable additional terms
#include "Player.h"
#include "Mover.h"
#include "SmokeParticles.h"
#include "framework/DeclEntityDef.h"
#include "Projectile.h"
#ifdef _DENTONMOD
#include "BrittleFracture.h"
#include "Moveable.h"
#endif
/*
===============================================================================
@ -48,8 +54,8 @@ If you have questions concerning this license or the applicable additional terms
static const int BFG_DAMAGE_FREQUENCY = 333;
static const float BOUNCE_SOUND_MIN_VELOCITY = 200.0f;
static const float BOUNCE_SOUND_MAX_VELOCITY = 400.0f;
static const float BOUNCE_SOUND_MIN_VELOCITY = 100.0f; //200
static const float BOUNCE_SOUND_MAX_VELOCITY = 600.0f;//400
const idEventDef EV_Explode( "<explode>", NULL );
const idEventDef EV_Fizzle( "<fizzle>", NULL );
@ -83,9 +89,15 @@ idProjectile::idProjectile( void ) {
lightColor = vec3_zero;
state = SPAWNED;
damagePower = 1.0f;
damageDef = NULL; // new
memset( &projectileFlags, 0, sizeof( projectileFlags ) );
memset( &renderLight, 0, sizeof( renderLight ) );
#ifdef _DENTONMOD
tracerEffect = NULL;
#endif
// note: for net_instanthit projectiles, we will force this back to false at spawn time
fl.networkSync = true;
@ -181,6 +193,11 @@ void idProjectile::Restore( idRestoreGame *savefile ) {
dir.NormalizeFast();
gameLocal.smokeParticles->EmitSmoke( smokeFly, gameLocal.time, gameLocal.random.RandomFloat(), GetPhysics()->GetOrigin(), GetPhysics()->GetAxis() );
}
//Reinitialize the damage Def--- By Clone JC Denton
damageDef = gameLocal.FindEntityDef( spawnArgs.GetString( "def_damage" ) );
}
/*
@ -201,7 +218,7 @@ void idProjectile::Create( idEntity *owner, const idVec3 &start, const idVec3 &d
idDict args;
idStr shaderName;
idVec3 light_color;
idVec3 light_offset;
// idVec3 light_offset; // was delcared unnecessarily, removed by Clone JC Denton
idVec3 tmp;
idMat3 axis;
@ -242,6 +259,7 @@ void idProjectile::Create( idEntity *owner, const idVec3 &start, const idVec3 &d
smokeFlyTime = 0;
damagePower = 1.0f;
damageDef = NULL; // New
UpdateVisuals();
@ -260,6 +278,12 @@ idProjectile::~idProjectile
idProjectile::~idProjectile() {
StopSound( SND_CHANNEL_ANY, false );
FreeLightDef();
#ifdef _DENTONMOD
if( tracerEffect ) {
delete tracerEffect;
}
#endif
}
/*
@ -363,10 +387,7 @@ void idProjectile::Launch( const idVec3 &start, const idVec3 &dir, const idVec3
}
// don't do tracers on client, we don't know origin and direction
if ( spawnArgs.GetBool( "tracers" ) && gameLocal.random.RandomFloat() > 0.5f ) {
SetModel( spawnArgs.GetString( "model_tracer" ) );
projectileFlags.isTracer = true;
}
// if ( spawnArgs.GetBool( "tracers" ) && gameLocal.random.RandomFloat() > 0.5f ) {
physicsObj.SetMass( mass );
physicsObj.SetFriction( linear_friction, angular_friction, contact_friction );
@ -384,6 +405,10 @@ void idProjectile::Launch( const idVec3 &start, const idVec3 &dir, const idVec3
thruster.SetPosition( &physicsObj, 0, idVec3( GetPhysics()->GetBounds()[ 0 ].x, 0, 0 ) );
// Find and store the damage def only once- --- New
// place this line before checking the fuse- for beam weapons
damageDef = gameLocal.FindEntityDef( spawnArgs.GetString( "def_damage" ) );
if ( !gameLocal.isClient ) {
if ( fuse <= 0 ) {
// run physics for 1 second
@ -404,12 +429,39 @@ void idProjectile::Launch( const idVec3 &start, const idVec3 &dir, const idVec3
}
}
if ( projectileFlags.isTracer ) {
StartSound( "snd_tracer", SND_CHANNEL_BODY, 0, false, NULL );
const idDict *damageDict = damageDef != NULL ? &damageDef->dict : &spawnArgs;
idStr sound;
if ( spawnArgs.GetBool( "tracers" ) ) {
if( !damageDict->GetString( "snd_tracer", "", sound ) ){
spawnArgs.GetString( "snd_tracer", "", sound );
}
#ifdef _DENTONMOD
if( spawnArgs.GetBool( "launchFromBarrel") ) {
idStr tracerModel;
if( spawnArgs.GetString( "beam_skin", NULL ) != NULL ) { // See if there's a beam_skin
tracerEffect = new dnBarrelLaunchedBeamTracer( this );
}
else if ( tracerEffect == NULL && spawnArgs.GetString( "model_tracer", "", tracerModel ) ){
SetModel( tracerModel );
}
}
#else
idStr tracerModel;
if ( spawnArgs.GetString( "model_tracer", "", tracerModel ) ){
SetModel( tracerModel );
}
#endif
} else {
StartSound( "snd_fly", SND_CHANNEL_BODY, 0, false, NULL );
if( !damageDict->GetString( "snd_fly", "", sound ) ){
spawnArgs.GetString( "snd_fly", "", sound );
}
}
StartSoundShader(declManager->FindSound( sound ), SND_CHANNEL_BODY, 0, false, NULL );
//StartSoundShader( declManager->FindSound( sound ), SND_CHANNEL_BODY, 0, false, NULL );
smokeFlyTime = 0;
const char *smokeName = spawnArgs.GetString( "smoke_fly" );
if ( *smokeName != '\0' ) {
@ -436,17 +488,27 @@ idProjectile::Think
*/
void idProjectile::Think( void ) {
if ( thinkFlags & TH_THINK ) {
if ( thrust && ( gameLocal.time < thrust_end ) ) {
// evaluate force
thruster.SetForce( GetPhysics()->GetAxis()[ 0 ] * thrust );
thruster.Evaluate( gameLocal.time );
#ifdef _DENTONMOD
if( state != EXPLODED ) { // update & run physics until projectile is not exploded. -Clone JC Denton
#endif
if( thinkFlags & TH_THINK ) {
if ( thrust && ( gameLocal.time < thrust_end ) ) {
// evaluate force
thruster.SetForce( GetPhysics()->GetAxis()[ 0 ] * thrust );
thruster.Evaluate( gameLocal.time );
}
}
// run physics until projectile is not exploded. -Clone JC Denton
RunPhysics();
#ifdef _DENTONMOD
}
// run physics
RunPhysics();
if( tracerEffect ) {
tracerEffect->Think();
}
#endif
Present();
// add the particles
@ -492,6 +554,14 @@ bool idProjectile::Collide( const trace_t &collision, const idVec3 &velocity ) {
idVec3 dir;
float push;
float damageScale;
/*idDict &damageArgs;
if ( damageDef != NULL ) {
damageArgs = damageDef->dict;
}
else {
damageArgs = spawnArgs;
}*/
if ( state == EXPLODED || state == FIZZLED ) {
return true;
@ -499,13 +569,19 @@ bool idProjectile::Collide( const trace_t &collision, const idVec3 &velocity ) {
// predict the explosion
if ( gameLocal.isClient ) {
if ( ClientPredictionCollide( this, spawnArgs, collision, velocity, !spawnArgs.GetBool( "net_instanthit" ) ) ) {
if ( ClientPredictionCollide( this, damageDef!=NULL ? damageDef->dict: spawnArgs, collision, velocity, !spawnArgs.GetBool( "net_instanthit" ) ) ) {
Explode( collision, NULL );
return true;
}
return false;
}
#ifdef _DENTONMOD
if( tracerEffect!= NULL && tracerEffect->IsType( dnRailBeam::Type() ) ) {
static_cast<dnRailBeam *>( tracerEffect )->Create( collision.c.point );
}
#endif
// remove projectile when a 'noimpact' surface is hit
if ( ( collision.c.material != NULL ) && ( collision.c.material->GetSurfaceFlags() & SURF_NOIMPACT ) ) {
PostEventMS( &EV_Remove, 0 );
@ -563,10 +639,40 @@ bool idProjectile::Collide( const trace_t &collision, const idVec3 &velocity ) {
// unlink the clip model because we no longer need it
GetPhysics()->UnlinkClip();
damageDefName = spawnArgs.GetString( "def_damage" );
// damageDefName = spawnArgs.GetString( "def_damage" );
if (damageDef != NULL) {
damageDefName = damageDef->GetName();
}
else {
damageDefName = NULL;
}
ignore = NULL;
// if the projectile causes a damage effect
// The Damage effects were previously applied after applying damage but we are applying before it
// because we wanted it so in idAnimatedEntity::AddLocalDamageEffect - By Clone JCD
if ( spawnArgs.GetBool( "impact_damage_effect" ) ) {
// if the hit entity has a special damage effect
#ifdef _DENTONMOD
StopSound( SND_CHANNEL_BODY, false ); // stop projectile flying sound upon impact, useful when is a looping sound.
// FIXME: need to restart this sound when projectile is bouncing off of surfaces
if ( (ent->IsType(idBrittleFracture::Type) || ent->IsType(idAnimatedEntity::Type) || ent->IsType(idMoveable::Type) || ent->IsType(idMoveableItem::Type)) && ent->spawnArgs.GetBool( "bleed", "1" ) ) { // This ensures that if an entity does not have bleed key defined, it will be considered true by default
projectileFlags.impact_fx_played = true;
ent->AddDamageEffect( collision, velocity, damageDefName, this );
#else
if ( ent->spawnArgs.GetBool( "bleed" ) ) {
ent->AddDamageEffect( collision, velocity, damageDefName );
#endif
} else {
AddDefaultDamageEffect( collision, velocity );
}
}
// if the hit entity takes damage
if ( ent->fl.takedamage ) {
if ( damagePower ) {
@ -587,17 +693,9 @@ bool idProjectile::Collide( const trace_t &collision, const idVec3 &velocity ) {
if ( damageDefName[0] != '\0' ) {
ent->Damage( this, owner.GetEntity(), dir, damageDefName, damageScale, CLIPMODEL_ID_TO_JOINT_HANDLE( collision.c.id ) );
ignore = ent;
}
}
// if the projectile causes a damage effect
if ( spawnArgs.GetBool( "impact_damage_effect" ) ) {
// if the hit entity has a special damage effect
if ( ent->spawnArgs.GetBool( "bleed" ) ) {
ent->AddDamageEffect( collision, velocity, damageDefName );
} else {
AddDefaultDamageEffect( collision, velocity );
if ( spawnArgs.GetBool ("ignore_splash_damage", "1") ) { // Added by Clone JCD for letting projectile def decide the ignore behaviour.
ignore = ent;
}
}
}
@ -637,12 +735,26 @@ void idProjectile::DefaultDamageEffect( idEntity *soundEnt, const idDict &projec
}
// project decal
decal = projectileDef.GetString( va( "mtr_detonate_%s", typeName ) );
if ( *decal == '\0' ) {
decal = projectileDef.GetString( "mtr_detonate" );
// Note that decal info is taken from projectile def, as projectDecal and projectOverlay work differently.
decal =projectileDef.GetString( va( "mtr_wound_%s", typeName ) );
if ( g_debugDamage.GetBool() && collision.c.material != NULL ) { // If this check is not performed game may crash at ocassions
gameLocal.Printf("\n Collision Material Type: %s", typeName);
gameLocal.Printf("\n File: %s", collision.c.material->GetFileName ());
gameLocal.Printf("\n Collision material: %s", collision.c.material->ImageName());
}
if ( *decal == '\0' ) {
decal = projectileDef.GetString( "mtr_wound" ); // Default decal
}
if ( *decal != '\0' ) {
gameLocal.ProjectDecal( collision.c.point, -collision.c.normal, 8.0f, true, projectileDef.GetFloat( "decal_size", "6.0" ), decal );
float size;
if ( !projectileDef.GetFloat( va( "size_wound_%s", typeName ), "6.0", size ) ) { // If Material Specific decal size not found, look for default size
size = projectileDef.GetFloat( "size_wound", "6.0" );
}
gameLocal.ProjectDecal( collision.c.point, -collision.c.normal, 8.0f, true, size, decal );
}
}
@ -653,7 +765,12 @@ idProjectile::AddDefaultDamageEffect
*/
void idProjectile::AddDefaultDamageEffect( const trace_t &collision, const idVec3 &velocity ) {
#ifdef _DENTONMOD
DefaultDamageEffect( this, damageDef!=NULL? damageDef->dict : spawnArgs, collision, velocity );
#else
DefaultDamageEffect( this, spawnArgs, collision, velocity );
#endif
if ( gameLocal.isServer && fl.networkSync ) {
idBitMsg msg;
@ -732,6 +849,9 @@ void idProjectile::Fizzle( void ) {
physicsObj.SetContents( 0 );
physicsObj.GetClipModel()->Unlink();
physicsObj.PutToRest();
#ifdef _DENTONMOD
BecomeInactive(TH_PHYSICS); // This causes the physics not to update when it's fizzled
#endif
Hide();
FreeLightDef();
@ -806,7 +926,12 @@ void idProjectile::Explode( const trace_t &collision, idEntity *ignore ) {
if ( spawnArgs.GetVector( "detonation_axis", "", normal ) ) {
GetPhysics()->SetAxis( normal.ToMat3() );
}
GetPhysics()->SetOrigin( collision.endpos + 2.0f * collision.c.normal );
else { //Added by Clone JCD for setting proper direction of fx.
GetPhysics()->SetAxis( collision.c.normal.ToMat3() );
}
// GetPhysics()->SetOrigin( collision.endpos + 2.0f * collision.c.normal ); // Actual effect starts a little away object.
GetPhysics()->SetOrigin( collision.endpos + 0.5f * collision.c.normal );// By Clone JC Denton
// default remove time
removeTime = spawnArgs.GetInt( "remove_time", "1500" );
@ -819,18 +944,36 @@ void idProjectile::Explode( const trace_t &collision, idEntity *ignore ) {
fxname = spawnArgs.GetString( "model_detonate" );
}
int surfaceType = collision.c.material != NULL ? collision.c.material->GetSurfaceType() : SURFTYPE_METAL;
if ( !( fxname && *fxname ) ) {
if ( ( surfaceType == SURFTYPE_NONE ) || ( surfaceType == SURFTYPE_METAL ) || ( surfaceType == SURFTYPE_STONE ) ) {
fxname = spawnArgs.GetString( "model_smokespark" );
} else if ( surfaceType == SURFTYPE_RICOCHET ) {
fxname = spawnArgs.GetString( "model_ricochet" );
} else {
fxname = spawnArgs.GetString( "model_smoke" );
if (!projectileFlags.impact_fx_played) { // New flag added by Clone JCD,this wont play damage effects when model_detonate key is in place.
// which is esp. useful for exploding projectiles like rockets, grenades etc.
if ( !( fxname && *fxname ) ) {
// fx shall be played from def from now on------- By Clone JCD
if (damageDef != NULL) {
int type = collision.c.material != NULL ? collision.c.material->GetSurfaceType() : SURFTYPE_METAL;
if ( type == SURFTYPE_NONE ) {
type = SURFTYPE_METAL;
}
const char *materialType = gameLocal.sufaceTypeNames[ type ];
fxname = damageDef->dict.GetString( va( "smoke_wound_%s", materialType ) );
if ( *fxname == '\0' ) {
fxname = damageDef->dict.GetString( "smoke_wound" );
}
}
}
}
if ( fxname && *fxname ) {
#ifdef _DENTONMOD
if( tracerEffect!= NULL && tracerEffect->IsType( dnBeamTracer::Type() ) ){ // check whether we used beam model as tracer
memset( &renderEntity, 0, sizeof(renderEntity) );
}
#endif
SetModel( fxname );
renderEntity.shaderParms[SHADERPARM_RED] =
renderEntity.shaderParms[SHADERPARM_GREEN] =
@ -866,6 +1009,19 @@ void idProjectile::Explode( const trace_t &collision, idEntity *ignore ) {
physicsObj.SetContents( 0 );
physicsObj.PutToRest();
#ifdef _DENTONMOD
if ( tracerEffect )
{
if ( tracerEffect->IsType( dnSpeedTracer::Type() ) && !static_cast<dnSpeedTracer *>(tracerEffect)->IsDead() ) {
BecomeActive( TH_UPDATEPARTICLES );
}
else if( !tracerEffect->IsType( dnRailBeam::Type() ) ) {
delete tracerEffect;
tracerEffect = NULL;
}
}
#endif
state = EXPLODED;
if ( gameLocal.isClient ) {
@ -896,7 +1052,8 @@ void idProjectile::Explode( const trace_t &collision, idEntity *ignore ) {
// spawn debris entities
int fxdebris = spawnArgs.GetInt( "debris_count" );
if ( fxdebris ) {
const idDict *debris = gameLocal.FindEntityDefDict( "projectile_debris", false );
// const idDict *debris = gameLocal.FindEntityDefDict( "projectile_debris", false );
const idDict *debris = gameLocal.FindEntityDefDict( spawnArgs.GetString("def_debris"), false );
if ( debris ) {
int amount = gameLocal.random.RandomInt( fxdebris );
for ( int i = 0; i < amount; i++ ) {
@ -917,7 +1074,9 @@ void idProjectile::Explode( const trace_t &collision, idEntity *ignore ) {
debris->Launch();
}
}
debris = gameLocal.FindEntityDefDict( "projectile_shrapnel", false );
// debris = gameLocal.FindEntityDefDict( "projectile_shrapnel", false );
debris = gameLocal.FindEntityDefDict( spawnArgs.GetString("def_shrapnel"), false );
if ( debris ) {
int amount = gameLocal.random.RandomInt( fxdebris );
for ( int i = 0; i < amount; i++ ) {
@ -1207,7 +1366,8 @@ bool idProjectile::ClientReceiveEvent( int event, int time, const idBitMsg &msg
velocity[0] = msg.ReadFloat( 5, 10 );
velocity[1] = msg.ReadFloat( 5, 10 );
velocity[2] = msg.ReadFloat( 5, 10 );
DefaultDamageEffect( this, spawnArgs, collision, velocity );
// DefaultDamageEffect( this, spawnArgs, collision, velocity );
DefaultDamageEffect( this, damageDef!=NULL? damageDef->dict: spawnArgs, collision, velocity ); // new
return true;
}
default:
@ -2029,9 +2189,9 @@ void idBFGProjectile::Explode( const trace_t &collision, idEntity *ignore ) {
secondModelDefHandle = -1;
}
if ( ignore == NULL ) {
/* if ( ignore == NULL ) { // This causes trouble like splash damage not working at all
projectileFlags.noSplashDamage = true;
}
}*/
if ( !gameLocal.isClient ) {
if ( ignore != NULL ) {
@ -2067,6 +2227,8 @@ void idDebris::Spawn( void ) {
owner = NULL;
smokeFly = NULL;
smokeFlyTime = 0;
nextSoundTime = 0; // BY Clone JCD
soundTimeDifference = 0; //
}
/*
@ -2082,6 +2244,8 @@ void idDebris::Create( idEntity *owner, const idVec3 &start, const idMat3 &axis
this->owner = owner;
smokeFly = NULL;
smokeFlyTime = 0;
nextSoundTime = 0; // BY Clone JCD
soundTimeDifference = 0; //
sndBounce = NULL;
UpdateVisuals();
}
@ -2096,6 +2260,8 @@ idDebris::idDebris( void ) {
smokeFly = NULL;
smokeFlyTime = 0;
sndBounce = NULL;
nextSoundTime = 0; // BY Clone JCD
soundTimeDifference = 0; //
}
/*
@ -2118,6 +2284,8 @@ void idDebris::Save( idSaveGame *savefile ) const {
savefile->WriteParticle( smokeFly );
savefile->WriteInt( smokeFlyTime );
// savefile->WriteInt( nextSoundTime ); // No need to store this value, BY Clone JCD
savefile->WriteInt( soundTimeDifference ); //
savefile->WriteSoundShader( sndBounce );
}
@ -2134,6 +2302,8 @@ void idDebris::Restore( idRestoreGame *savefile ) {
savefile->ReadParticle( smokeFly );
savefile->ReadInt( smokeFlyTime );
//savefile->ReadInt( nextSoundTime ); // No need to store this value, BY Clone JCD
savefile->ReadInt( soundTimeDifference ); //
savefile->ReadSoundShader( sndBounce );
}
@ -2145,7 +2315,11 @@ idDebris::Launch
void idDebris::Launch( void ) {
float fuse;
idVec3 velocity;
#ifdef _DENTONMOD
idVec3 angular_velocity_vect;
#else
idAngles angular_velocity;
#endif
float linear_friction;
float angular_friction;
float contact_friction;
@ -2159,7 +2333,11 @@ void idDebris::Launch( void ) {
renderEntity.shaderParms[ SHADERPARM_TIMEOFFSET ] = -MS2SEC( gameLocal.time );
spawnArgs.GetVector( "velocity", "0 0 0", velocity );
#ifdef _DENTONMOD
angular_velocity_vect = spawnArgs.GetAngles( "angular_velocity", "0 0 0").ToAngularVelocity();
#else
spawnArgs.GetAngles( "angular_velocity", "0 0 0", angular_velocity );
#endif
linear_friction = spawnArgs.GetFloat( "linear_friction" );
angular_friction = spawnArgs.GetFloat( "angular_friction" );
@ -2169,15 +2347,35 @@ void idDebris::Launch( void ) {
gravity = spawnArgs.GetFloat( "gravity" );
fuse = spawnArgs.GetFloat( "fuse" );
randomVelocity = spawnArgs.GetBool ( "random_velocity" );
continuousSmoke = spawnArgs.GetBool ( "smoke_continuous" );
if ( mass <= 0 ) {
gameLocal.Error( "Invalid mass on '%s'\n", GetEntityDefName() );
}
if ( randomVelocity ) {
#ifdef _DENTONMOD
float rand = spawnArgs.GetFloat("linear_velocity_rand", "0.35");
// sets velocity randomly between ((1-rand)*100)% and ((1+rand)*100)%
// e.g.1: if rand = 0.2, velocity will be randomly set between 80% and 120%
// e.g.2: if rand = 0.3, velocity will be randomly set between 70% and 130%
// and so on.
velocity.x *= gameLocal.random.RandomFloat()*rand*2.0 + 1.0 - rand;
velocity.y *= gameLocal.random.RandomFloat()*rand*2.0 + 1.0 - rand;
velocity.z *= gameLocal.random.RandomFloat()*rand*2.0 + 1.0 - rand;
// do not perform following calculations unless there's key in decl that says so.
if( spawnArgs.GetFloat( "angular_velocity_rand", "0.0", rand) && rand > 0.0f ) {
angular_velocity_vect.x *= gameLocal.random.RandomFloat()*rand*2.0 + 1.0 - rand;
angular_velocity_vect.y *= gameLocal.random.RandomFloat()*rand*2.0 + 1.0 - rand;
angular_velocity_vect.z *= gameLocal.random.RandomFloat()*rand*2.0 + 1.0 - rand;
}
#else
velocity.x *= gameLocal.random.RandomFloat() + 0.5f;
velocity.y *= gameLocal.random.RandomFloat() + 0.5f;
velocity.z *= gameLocal.random.RandomFloat() + 0.5f;
#endif
}
if ( health ) {
@ -2218,8 +2416,21 @@ void idDebris::Launch( void ) {
physicsObj.SetGravity( gravVec * gravity );
physicsObj.SetContents( 0 );
physicsObj.SetClipMask( MASK_SOLID | CONTENTS_MOVEABLECLIP );
#ifdef _DENTONMOD
// Make sure that the linear velocity is added with
// owner's linear velocity for more accurate physics simulation.
idEntity *ownerEnt = owner.GetEntity();
if( ownerEnt != NULL ) {
physicsObj.SetLinearVelocity( (axis[ 0 ] * velocity[ 0 ] + axis[ 1 ] * velocity[ 1 ] + axis[ 2 ] * velocity[ 2 ]) + ownerEnt->GetPhysics()->GetLinearVelocity());
}
else {
physicsObj.SetLinearVelocity( axis[ 0 ] * velocity[ 0 ] + axis[ 1 ] * velocity[ 1 ] + axis[ 2 ] * velocity[ 2 ] );
}
physicsObj.SetAngularVelocity( angular_velocity_vect * axis );
#else
physicsObj.SetLinearVelocity( axis[ 0 ] * velocity[ 0 ] + axis[ 1 ] * velocity[ 1 ] + axis[ 2 ] * velocity[ 2 ] );
physicsObj.SetAngularVelocity( angular_velocity.ToAngularVelocity() * axis );
#endif
physicsObj.SetOrigin( GetPhysics()->GetOrigin() );
physicsObj.SetAxis( axis );
SetPhysics( &physicsObj );
@ -2255,6 +2466,10 @@ void idDebris::Launch( void ) {
}
const char *sndName = spawnArgs.GetString( "snd_bounce" );
nextSoundTime = 0; // BY Clone JCD
soundTimeDifference = spawnArgs.GetInt ( "next_sound_time" ); //
if ( *sndName != '\0' ) {
sndBounce = declManager->FindSound( sndName );
}
@ -2273,9 +2488,17 @@ void idDebris::Think( void ) {
RunPhysics();
Present();
if ( smokeFly && smokeFlyTime ) {
if ( !gameLocal.smokeParticles->EmitSmoke( smokeFly, smokeFlyTime, gameLocal.random.CRandomFloat(), GetPhysics()->GetOrigin(), GetPhysics()->GetAxis() ) ) {
smokeFlyTime = 0;
if ( smokeFly && smokeFlyTime && !IsHidden()) { // Emit particles only when visible
idVec3 dir = -GetPhysics()->GetLinearVelocity();
dir.Normalize();
if ( !gameLocal.smokeParticles->EmitSmoke( smokeFly, smokeFlyTime, gameLocal.random.CRandomFloat(), GetPhysics()->GetOrigin(), dir.ToMat3() ) ) {
if( continuousSmoke ) {
smokeFlyTime = gameLocal.time; // Emit particles continuously - Clone JC Denton
}
else {
smokeFlyTime = 0;
}
}
}
}
@ -2299,10 +2522,34 @@ idDebris::Collide
=================
*/
bool idDebris::Collide( const trace_t &collision, const idVec3 &velocity ) {
if ( sndBounce != NULL ) {
StartSoundShader( sndBounce, SND_CHANNEL_BODY, 0, false, NULL );
if (sndBounce != NULL ){
if ( !soundTimeDifference ) {
StartSoundShader( sndBounce, SND_CHANNEL_BODY, 0, false, NULL );
sndBounce = NULL;
return false;
}
if ( gameLocal.time > nextSoundTime ){
float v = -( velocity * collision.c.normal );
if ( v > BOUNCE_SOUND_MIN_VELOCITY ) {
float f = v > BOUNCE_SOUND_MAX_VELOCITY ? 1.0f : idMath::Sqrt( v - BOUNCE_SOUND_MIN_VELOCITY ) * ( 1.0f / idMath::Sqrt( BOUNCE_SOUND_MAX_VELOCITY - BOUNCE_SOUND_MIN_VELOCITY ) );
if ( StartSoundShader( sndBounce, SND_CHANNEL_BODY, 0, false, NULL ) )
SetSoundVolume( f );
}
else {
float f = ( 0.5f / idMath::Sqrt( BOUNCE_SOUND_MAX_VELOCITY - BOUNCE_SOUND_MIN_VELOCITY ) );
if ( StartSoundShader( sndBounce, SND_CHANNEL_BODY, 0, false, NULL ) )
SetSoundVolume( f );
sndBounce = NULL;
return false;
}
nextSoundTime = gameLocal.time + soundTimeDifference;
}
}
sndBounce = NULL;
return false;
}
@ -2332,7 +2579,9 @@ void idDebris::Fizzle( void ) {
fl.takedamage = false;
physicsObj.SetContents( 0 );
physicsObj.PutToRest();
#ifdef _DENTONMOD
BecomeInactive(TH_PHYSICS); // This causes the physics not to update after explosion
#endif
Hide();
if ( gameLocal.isClient ) {
@ -2372,6 +2621,9 @@ void idDebris::Explode( void ) {
fl.takedamage = false;
physicsObj.SetContents( 0 );
physicsObj.PutToRest();
#ifdef _DENTONMOD
BecomeInactive(TH_PHYSICS); // This causes the physics not to update after explosion
#endif
CancelEvents( &EV_Explode );
PostEventMS( &EV_Remove, 0 );

19
game/Projectile.h
View file

@ -33,6 +33,7 @@ If you have questions concerning this license or the applicable additional terms
#include "physics/Force_Constant.h"
#include "Entity.h"
#include "tracer.h"
/*
===============================================================================
@ -82,6 +83,9 @@ public :
virtual void ReadFromSnapshot( const idBitMsgDelta &msg );
virtual bool ClientReceiveEvent( int event, int time, const idBitMsg &msg );
#ifdef _DENTONMOD
void setTracerEffect( dnTracerEffect *effect) { tracerEffect = effect; }
#endif
protected:
idEntityPtr<idEntity> owner;
@ -89,10 +93,16 @@ protected:
bool detonate_on_world : 1;
bool detonate_on_actor : 1;
bool randomShaderSpin : 1;
bool isTracer : 1;
bool noSplashDamage : 1;
// bool isTracer : 1; // what about this?
// bool noSplashDamage : 1; // and this?
bool noSplashDamage : 1;
bool impact_fx_played : 1; // keeps track of fx played on collided body - BY JCD
} projectileFlags;
#ifdef _DENTONMOD
dnTracerEffect *tracerEffect;
#endif
float thrust;
int thrust_end;
float damagePower;
@ -123,6 +133,7 @@ protected:
private:
bool netSyncPhysics;
const idDeclEntityDef *damageDef; // stores Damage Def -- By Clone JCD
void AddDefaultDamageEffect( const trace_t &collision, const idVec3 &velocity );
@ -263,7 +274,11 @@ private:
idPhysics_RigidBody physicsObj;
const idDeclParticle * smokeFly;
int smokeFlyTime;
int nextSoundTime; // BY Clone JCD
int soundTimeDifference; // BY Clone JCD
bool continuousSmoke; //By Clone JCD
const idSoundShader * sndBounce;
const idSoundShader * sndRest;
void Event_Explode( void );

34
game/Pvs.cpp
View file

@ -1420,3 +1420,37 @@ void idPVS::ReadPVS( const pvsHandle_t handle, const idBitMsg &msg ) {
}
#endif
#ifdef _PORTALSKY
/*
================
idPVS::CheckAreasForPortalSky
================
*/
bool idPVS::CheckAreasForPortalSky( const pvsHandle_t handle, const idVec3 &origin ) {
int j, sourceArea;
if ( handle.i < 0 || handle.i >= MAX_CURRENT_PVS || handle.h != currentPVS[handle.i].handle.h ) {
return false;
}
sourceArea = gameRenderWorld->PointInArea( origin );
if ( sourceArea == -1 ) {
return false;
}
for ( j = 0; j < numAreas; j++ ) {
if ( !( currentPVS[handle.i].pvs[j>>3] & (1 << (j&7)) ) ) {
continue;
}
if ( gameRenderWorld->CheckAreaForPortalSky( j ) ) {
return true;
}
}
return false;
}
#endif

4
game/Pvs.h
View file

@ -97,6 +97,10 @@ public:
void ReadPVS( const pvsHandle_t handle, const idBitMsg &msg );
#endif
#ifdef _PORTALSKY
bool CheckAreasForPortalSky( const pvsHandle_t handle, const idVec3 &origin );
#endif
private:
int numAreas;
int numPortals;

1080
game/Weapon.cpp
View file

File diff suppressed because it is too large Load diff

94
game/Weapon.h
View file

@ -61,6 +61,60 @@ static const int LIGHTID_VIEW_MUZZLE_FLASH = 100;
class idMoveableItem;
//---------------------------------------- New Particle and light support
#ifdef _DENTONMOD
struct particleFlags_s {
bool isActive : 1; // Is the particle active
bool isSmoke : 1; // Is this a smoke particle
bool isContinuous : 1; // Is the effect continuous
bool isOffset : 1; // Is new Offset needed
bool isDir : 1; // Is new Direction needed
bool isOnWorldModel : 1; // Is this effect intended for world model only
bool isUpdateJoint : 1;
};
typedef struct {
char name[64];
char particlename[128];
int startTime;
idVec3 offset; //Sometimes you cant find proper joint, then use offset along with muzzle bone
idVec3 dir;
jointHandle_t joint; //The joint on which to attach the particle
particleFlags_s particleFlags; // flags
const idDeclParticle* particle; //Used for smoke particles
renderEntity_t renderEntity;
qhandle_t modelDefHandle;
//idFuncEmitter* emitter; //Used for non-smoke particles
} WeaponParticle_t;
struct lightFlags_s {
bool isActive : 1; // Is the particle active
bool isAlwaysOn : 1; // Is this light always on
bool isOffset : 1; // Is new Offset needed
bool isDir : 1; // Is new Direction needed
bool isOnWorldModel : 1; // Is this light intended for world model only
};
typedef struct {
char name[64];
int startTime;
int endTime;
int lightHandle;
idVec3 offset; //If weapons does not have bones in proper places for some effect use this
idVec3 dir; //If the desired bone is not pointing in proper direction use this to fix it.
// Note that the dir should be vector representing X-axis of the bone.
lightFlags_s lightFlags;
jointHandle_t joint;
renderLight_t light;
} WeaponLight_t;
//----------------------------------------------
#endif
class idWeapon : public idAnimatedEntity {
public:
CLASS_PROTOTYPE( idWeapon );
@ -109,6 +163,8 @@ public:
void OwnerDied( void );
void BeginAttack( void );
void EndAttack( void );
void BeginSpecialFunction( bool ); // Added by Clone JCD
void EndSpecialFunction( void ); // Added by Clone JCD
bool IsReady( void ) const;
bool IsReloading( void ) const;
bool IsHolstered( void ) const;
@ -145,6 +201,8 @@ public:
int LowAmmo( void ) const;
int AmmoRequired( void ) const;
int AmmoCount() const; //new
virtual void WriteToSnapshot( idBitMsgDelta &msg ) const;
virtual void ReadFromSnapshot( const idBitMsgDelta &msg );
@ -162,6 +220,8 @@ private:
// script control
idScriptBool WEAPON_ATTACK;
idScriptBool WEAPON_RELOAD;
idScriptBool WEAPON_SPECIAL; // For weapon special function, added by clone JCD
idScriptBool WEAPON_SPECIAL_HOLD; // For weapon special function, added by clone JCD idScriptBool WEAPON_RELOAD;
idScriptBool WEAPON_NETRELOAD;
idScriptBool WEAPON_NETENDRELOAD;
idScriptBool WEAPON_NETFIRING;
@ -273,6 +333,21 @@ private:
jointHandle_t barrelJointWorld;
jointHandle_t ejectJointWorld;
#ifdef _DENTONMOD
/* typedef struct {
char name[64];
jointHandle_t joint;
}WeaponJoint_t;
idHashTable<WeaponJoint_t> weaponJoints;
*/
idHashTable<WeaponParticle_t> weaponParticles;
idHashTable<WeaponLight_t> weaponLights;
#endif //_DENTONMOD
// sound
const idSoundShader * sndHum;
@ -313,13 +388,21 @@ private:
void MuzzleFlashLight( void );
void MuzzleRise( idVec3 &origin, idMat3 &axis );
void UpdateNozzleFx( void );
#ifdef _DENTONMOD
void InitWeaponFx( void );
void StopWeaponFx( void );
void UpdateWeaponFx( void );
bool ChangeProjectileDef( int number );// New
#endif
void UpdateFlashPosition( void );
// script events
void Event_Clear( void );
void Event_GetOwner( void );
void Event_WeaponState( const char *statename, int blendFrames );
void Event_SetWeaponStatus( float newStatus );
// void Event_SetWeaponStatus( float newStatus ); // FIXME: what about this?
void Event_WeaponReady( void );
void Event_WeaponOutOfAmmo( void );
void Event_WeaponReloading( void );
@ -353,6 +436,15 @@ private:
void Event_NetReload( void );
void Event_IsInvisible( void );
void Event_NetEndReload( void );
void Event_SetZoom( int status ); //New
void Event_GetProjectileType( void );// New
void Event_ChangeProjectileDef( int number );// New
void Event_StartWeaponParticle( const char* name ); // New
void Event_StopWeaponParticle( const char* name );// New
void Event_StartWeaponLight( const char* name );// New
void Event_StopWeaponLight( const char* name );// New
};
ID_INLINE bool idWeapon::IsLinked( void ) {

4
game/gamesys/SysCmds.cpp
View file

@ -326,6 +326,10 @@ void Cmd_Give_f( const idCmdArgs &args ) {
}
if ( give_all || idStr::Icmp( name, "weapons" ) == 0 ) {
// this causes a "warning: left shift count >= width of type"
// because MAX_WEAPONS is 32 - but it works as intended anyway
// (=> all bits are set afterwards, because BITS(32) == 0 ; 0 - 1 == -1 => all bits set.
// that's a bit ugly but more flexible when redefining MAX_WEAPONS
player->inventory.weapons = BIT( MAX_WEAPONS ) - 1;
player->CacheWeapons();

16
game/gamesys/SysCvar.cpp
View file

@ -149,6 +149,10 @@ idCVar g_showEnemies( "g_showEnemies", "0", CVAR_GAME | CVAR_BOOL, "draws
idCVar g_frametime( "g_frametime", "0", CVAR_GAME | CVAR_BOOL, "displays timing information for each game frame" );
idCVar g_timeentities( "g_timeEntities", "0", CVAR_GAME | CVAR_FLOAT, "when non-zero, shows entities whose think functions exceeded the # of milliseconds specified" );
#ifdef _PORTALSKY
idCVar g_enablePortalSky( "g_enablePortalSky", "1", CVAR_GAME | CVAR_BOOL, "enables the portal sky" );
#endif
idCVar ai_debugScript( "ai_debugScript", "-1", CVAR_GAME | CVAR_INTEGER, "displays script calls for the specified monster entity number" );
idCVar ai_debugMove( "ai_debugMove", "0", CVAR_GAME | CVAR_BOOL, "draws movement information for monsters" );
idCVar ai_debugTrajectory( "ai_debugTrajectory", "0", CVAR_GAME | CVAR_BOOL, "draws trajectory tests for monsters" );
@ -335,3 +339,15 @@ idCVar mod_validSkins( "mod_validSkins", "skins/characters/player/marine_mp
idCVar net_serverDownload( "net_serverDownload", "0", CVAR_GAME | CVAR_INTEGER | CVAR_ARCHIVE, "enable server download redirects. 0: off 1: redirect to si_serverURL 2: use builtin download. see net_serverDl cvars for configuration" );
idCVar net_serverDlBaseURL( "net_serverDlBaseURL", "", CVAR_GAME | CVAR_ARCHIVE, "base URL for the download redirection" );
idCVar net_serverDlTable( "net_serverDlTable", "", CVAR_GAME | CVAR_ARCHIVE, "pak names for which download is provided, separated by ;" );
idCVar r_bloom( "r_bloom", "1", CVAR_GAME | CVAR_INTEGER, "activates bloom with gaussian blur ( Requires DX9 compliant Hardware ). \n 1: Bloom with shift sensitivity and variable blurring \n 2: Bloom with shift sensitivity \n 3: Normal Bloom ");
idCVar r_bloom_blur_mult( "r_bloom_blur_mult", "0.5", CVAR_GAME | CVAR_FLOAT, "blurred image multiplier for bloom");
idCVar r_bloom_src_mult( "r_bloom_src_mult", "1.0", CVAR_GAME | CVAR_FLOAT, "source image multiplier for bloom");
idCVar r_bloom_contrast( "r_bloom_contrast", "1", CVAR_GAME | CVAR_INTEGER, "contrast type. 0: no contrast 1: modulate 2x 2: minus 0.1");
idCVar r_bloom_buffer( "r_bloom_buffer", "4", CVAR_GAME | CVAR_INTEGER, "Bloom buffer image size. \n 1:64x32, 2:128x64, 3:256x128, 4:512x256(default), 5:1024x512"); // New by Clone JCD
idCVar r_bloom_contrast_mult( "r_bloom_contrast_mult", "1.55", CVAR_GAME | CVAR_FLOAT, "Contrast multiplier. \nWorks only with bloom type 1 and bloom type 2.");
idCVar r_bloom_contrast_min( "r_bloom_contrast_min", "0.1", CVAR_GAME | CVAR_FLOAT, "This is the minimum contrast value when (shift sensitivity based)bloom drops; works only for bloom type 1 and bloom type 2. \nWhen shift sensitivty is turned on bloom contrast varies from (constrast_image x r_bloom_contrast_min) to (constrast_image x r_bloom_contrast_mult).");
idCVar r_bloom_shiftSensitivity_delay( "r_bloom_shiftSensitivity_delay", "130", CVAR_GAME | CVAR_INTEGER, "Delay in millisecs for shifting the bloom sensitivity. \n0 : No shift sensitivity delay, sensitvity shifts immediately. \n-1 : Disables sensitivity shifting"); // New by Clone JCD
idCVar r_bloom_blurIterations( "r_bloom_blurIterations", "1", CVAR_GAME | CVAR_INTEGER, "Blur iterations for bloom"); // New by Clone JCD

13
game/gamesys/SysCvar.h
View file

@ -119,6 +119,10 @@ extern idCVar g_vehicleSuspensionKCompress;
extern idCVar g_vehicleSuspensionDamping;
extern idCVar g_vehicleTireFriction;
#ifdef _PORTALSKY
extern idCVar g_enablePortalSky;
#endif
extern idCVar ik_enable;
extern idCVar ik_debug;
@ -254,4 +258,13 @@ extern const char *si_gameTypeArgs[];
extern const char *ui_skinArgs[];
extern idCVar r_bloom;
extern idCVar r_bloom_blur_mult;
extern idCVar r_bloom_src_mult;
extern idCVar r_bloom_contrast;
extern idCVar r_bloom_contrast_mult; // clone_jc_denton
extern idCVar r_bloom_contrast_min; // clone_jc_denton
extern idCVar r_bloom_shiftSensitivity_delay; // clone_jc_denton
extern idCVar r_bloom_blurIterations; // clone_jc_denton
extern idCVar r_bloom_buffer; // clone_jc_denton
#endif /* !__SYS_CVAR_H__ */

582
game/tracer.cpp Normal file
View file

@ -0,0 +1,582 @@
#ifdef _DENTONMOD
/*
===============================================================================
dnTracer:
A kind of tracer effect that starts from weapon's barrel and ends at collision point,
while the actual projectile starts from the view origin. This tracer travels in parallel
with the projectile.
===============================================================================
*/
#include "tracer.h"
#include "renderer/ModelManager.h"
#include "SmokeParticles.h"
static const char *TRACER_WIDTH = "1.7f";
static const char *TRACER_LENGTH = "170.0f";
/*
================
dnTracer::dnTracer
================
*/
dnTracer::dnTracer( idEntity *owner, const float distanceRatio, const idVec3 &viewOrigin, const idVec3 &muzzleOrigin, const idMat3 &tracerAxis ) : dnTracerEffect( owner ) {
SetType( TR_TYPE_TRACER );// We must set type in the beginning of every constructor.
const char *modelName = owner->spawnArgs.GetString( "model_tracer" );
if ( modelName[0] == '\0' ) {
return;
}
this->distanceRatio = distanceRatio;
this->weaponMuzzleOrigin = muzzleOrigin;
this->playerViewOrigin = viewOrigin;
// align z-axis of model with the direction
this->axis[0] = tracerAxis[2];
this->axis[2] = tracerAxis[0];
this->axis[1] = tracerAxis[1];
owner->SetModel( modelName );
}
/*
================
dnTracer::Think
================
*/
void dnTracer::Think( void ) {
const float projectileDist = ( owner->GetPhysics()->GetOrigin() - playerViewOrigin ).LengthSqr() * distanceRatio;
owner->GetRenderEntity()->axis = axis;
//owner->GetRenderEntity()->origin = weaponMuzzleOrigin + idMath::Sqrt(projectileDist) * owner->GetRenderEntity()->.axis[2];
owner->GetRenderEntity()->origin = weaponMuzzleOrigin + projectileDist * idMath::RSqrt(projectileDist) * owner->GetRenderEntity()->axis[2]; // this is faster than commented line above
}
/*
=======================================================================================
dnBeamTracer:
Same effect as that of dnTracer. The only difference is, dnTracer uses a model or particle
effect to represent the tracer, where as, this one uses _beam model. This tracer is pretty
fast to draw than dnTracer.
=======================================================================================
*/
/*
================
dnBeamTracer::dnBeamTracer
================
*/
dnBeamTracer::dnBeamTracer( idEntity *owner, const float distanceRatio, const idVec3 &viewOrigin, const idVec3 &muzzleOrigin, const idMat3 &tracerAxis ) : dnTracer( owner ) {
SetType( TR_TYPE_BEAMTRACER );// We must set type in the beginning of every constructor.
const char *skinName = owner->spawnArgs.GetString( "beam_skin" );
if ( skinName[0] == '\0' ) {
return;
}
this->distanceRatio = distanceRatio;
this->weaponMuzzleOrigin = muzzleOrigin;
this->playerViewOrigin = viewOrigin;
// align z-axis of model with the direction
this->axis[0] = tracerAxis[2];
this->axis[2] = tracerAxis[0];
this->axis[1] = tracerAxis[1];
length = owner->spawnArgs.GetFloat( "beam_length", TRACER_LENGTH);
renderEntity_t *renderEntity = owner->GetRenderEntity();
idVec4 tracerColor = owner->spawnArgs.GetVec4( "beam_color", "1.0 1.0 1.0 1.0" );
renderEntity->origin = muzzleOrigin;
renderEntity->shaderParms[ SHADERPARM_RED ] = tracerColor[0];
renderEntity->shaderParms[ SHADERPARM_GREEN ] = tracerColor[1];
renderEntity->shaderParms[ SHADERPARM_BLUE ] = tracerColor[2];
renderEntity->shaderParms[ SHADERPARM_ALPHA ] = tracerColor[3];
renderEntity->shaderParms[ SHADERPARM_BEAM_WIDTH ] = owner->spawnArgs.GetFloat( "beam_width", TRACER_WIDTH );
idVec3 endPos;
if( length == 0.0f ) { //if the length is 0 then keep endPos to muzzleorigin constantly.
endPos = muzzleOrigin;
}
else {
endPos = renderEntity->origin - renderEntity->axis[2] * length;
}
renderEntity->shaderParms[ SHADERPARM_BEAM_END_X ] = endPos[0];
renderEntity->shaderParms[ SHADERPARM_BEAM_END_Y ] = endPos[1];
renderEntity->shaderParms[ SHADERPARM_BEAM_END_Z ] = endPos[2];
owner->SetModel( "_beam" );
owner->SetSkin( declManager->FindSkin( skinName ) );
}
/*
================
dnBeamTracer::Think
================
*/
void dnBeamTracer::Think( void ) {
dnTracer::Think();
renderEntity_t *renderEntity = owner->GetRenderEntity();
idVec3 endPos;
if( length == 0.0f ) {
endPos = weaponMuzzleOrigin;
}
else {
endPos = renderEntity->origin - renderEntity->axis[2] * length;
if( (renderEntity->origin - endPos).LengthSqr() > (renderEntity->origin - weaponMuzzleOrigin).LengthSqr() ) {
endPos = weaponMuzzleOrigin;
}
}
renderEntity->shaderParms[ SHADERPARM_BEAM_END_X ] = endPos[0];
renderEntity->shaderParms[ SHADERPARM_BEAM_END_Y ] = endPos[1];
renderEntity->shaderParms[ SHADERPARM_BEAM_END_Z ] = endPos[2];
}
/*
=======================================================================================
dnBarrelLaunchedBeamTracer:
Same effect as that of dnTracer. The only difference is, dnTracer uses a model or particle
effect to represent the tracer, where as, this one uses _beam model. This tracer is pretty
fast to draw than dnTracer.
=======================================================================================
*/
/*
================
dnBarrelLaunchedBeamTracer::dnBarrelLaunchedBeamTracer
================
*/
dnBarrelLaunchedBeamTracer::dnBarrelLaunchedBeamTracer( idEntity *owner ) : dnTracerEffect( owner ) {
SetType( TR_TYPE_BEAMTRACER );// We must set type in the beginning of every constructor.
const char *skinName = owner->spawnArgs.GetString( "beam_skin" );
if ( skinName[0] == '\0' ) {
return;
}
length = owner->spawnArgs.GetFloat( "beam_length", TRACER_LENGTH);
renderEntity_t *renderEntity = owner->GetRenderEntity();
weaponMuzzleOrigin = renderEntity->origin;
idVec4 tracerColor = owner->spawnArgs.GetVec4( "beam_color", "1.0 1.0 1.0 1.0" );
renderEntity->shaderParms[ SHADERPARM_RED ] = tracerColor[0];
renderEntity->shaderParms[ SHADERPARM_GREEN ] = tracerColor[1];
renderEntity->shaderParms[ SHADERPARM_BLUE ] = tracerColor[2];
renderEntity->shaderParms[ SHADERPARM_ALPHA ] = tracerColor[3];
renderEntity->shaderParms[ SHADERPARM_BEAM_WIDTH ] = owner->spawnArgs.GetFloat( "beam_width", TRACER_WIDTH );
idVec3 endPos = renderEntity->origin - renderEntity->axis[2] * length;
renderEntity->shaderParms[ SHADERPARM_BEAM_END_X ] = endPos[0];
renderEntity->shaderParms[ SHADERPARM_BEAM_END_Y ] = endPos[1];
renderEntity->shaderParms[ SHADERPARM_BEAM_END_Z ] = endPos[2];
owner->SetModel( "_beam" );
owner->SetSkin( declManager->FindSkin( skinName ) );
}
/*
================
dnBarrelLaunchedBeamTracer::Think
================
*/
void dnBarrelLaunchedBeamTracer::Think( void ) {
renderEntity_t *renderEntity = owner->GetRenderEntity();
idVec3 endPos = renderEntity->origin - renderEntity->axis[2] * length;
if( (renderEntity->origin - endPos).LengthSqr() > (renderEntity->origin - weaponMuzzleOrigin).LengthSqr() ) {
endPos = weaponMuzzleOrigin;
}
renderEntity->shaderParms[ SHADERPARM_BEAM_END_X ] = endPos[0];
renderEntity->shaderParms[ SHADERPARM_BEAM_END_Y ] = endPos[1];
renderEntity->shaderParms[ SHADERPARM_BEAM_END_Z ] = endPos[2];
}
/*
===============================================================================
dnSpeedTracer:
Same effect as that of dnTracer only the difference is, this effect travels with user
defined speed (speed taken from projectile.def). It involves less calculations than
dnTracer and dnBeamTracer.
===============================================================================
*/
/*
================
dnSpeedTracer::dnSpeedTracer
================
*/
dnSpeedTracer::dnSpeedTracer( idEntity *owner, const float speed, const float distance, const idVec3 &muzzleOrigin, const idMat3 &tracerAxis ) : dnTracerEffect( owner ) {
SetType( TR_TYPE_SPEEDTRACER ); // We must set type info in the beginning of every constructor.
const char *modelName = owner->spawnArgs.GetString( "model_tracer" );
if ( modelName[0] == '\0' ) {
modelDefHandle = -1;
return;
}
const float offset = owner->spawnArgs.GetFloat( "tracer_offset","0.0f" );
owner->SetModel( "" );
this->distance = distance - offset;
this->lastPos = muzzleOrigin + tracerAxis[0] * offset;
this->flyTime = gameLocal.time;
this->speed = speed/1000.0f;
memset( &renderEntity, 0, sizeof ( renderEntity ) );
// align z-axis of model with the direction
renderEntity.axis[0] = tracerAxis[2];
renderEntity.axis[2] = tracerAxis[0];
renderEntity.axis[1] = tracerAxis[1];
renderEntity.origin = lastPos;
// SetModel( modelName );
const idDeclModelDef *modelDef = static_cast<const idDeclModelDef *>( declManager->FindType( DECL_MODELDEF, modelName ) );
if( modelDef ) {
renderEntity.hModel = modelDef->ModelHandle();
renderEntity.shaderParms[ SHADERPARM_RED ] = 1.0f;
renderEntity.shaderParms[ SHADERPARM_GREEN ] = 1.0f;
renderEntity.shaderParms[ SHADERPARM_BLUE ] = 1.0f;
renderEntity.shaderParms[ SHADERPARM_ALPHA ] = 1.0f;
renderEntity.hModel = renderModelManager->FindModel( modelName );
modelDefHandle = gameRenderWorld->AddEntityDef( &renderEntity );
}
else {
modelDefHandle = -1;
}
}
/*
================
dnSpeedTracer::UpdatePosition
================
*/
bool dnSpeedTracer::UpdatePosition( void ) {
const float tracerTravelDist = (gameLocal.time - flyTime )* speed ;
if ( tracerTravelDist > distance ) { // if travelled all the distance, stop doing tracers.
if ( owner->thinkFlags & TH_UPDATEPARTICLES ) {
owner->BecomeInactive( TH_UPDATEPARTICLES );
}
gameRenderWorld->FreeEntityDef( modelDefHandle );
modelDefHandle = -1;
return false;
}
renderEntity.origin = lastPos + renderEntity.axis[2] * tracerTravelDist;
lastPos = renderEntity.origin;
flyTime = gameLocal.time;
distance -= tracerTravelDist;
return true;
}
/*
================
dnSpeedTracer::Think
================
*/
void dnSpeedTracer::Think( void ) {
if ( modelDefHandle < 0 ){
return;
}
if( UpdatePosition() ){
gameRenderWorld->UpdateEntityDef( modelDefHandle, &renderEntity );
}
}
/*
===============================================================================
dnBeamSpeedTracer:
Same effect as that of dnTracer only the difference is, this effect travels with user
defined speed (found in projectile.def). The only difference is, dnTracer uses a model or
particle effect to represent the tracer, where as, this one uses _beam model. This tracer is
pretty fast to draw than dnTracer.
===============================================================================
*/
dnBeamSpeedTracer::dnBeamSpeedTracer( idEntity *owner, const float speed, const float distance, const idVec3 &muzzleOrigin, const idMat3 &tracerAxis )
: dnSpeedTracer( owner ) {
SetType( TR_TYPE_SPEEDTRACER ); // We must set type in the beginning of every constructor.
const char *skinName = owner->spawnArgs.GetString( "beam_skin" );
if ( skinName[0] == '\0' ) {
modelDefHandle = -1;
return;
}
const float offset = owner->spawnArgs.GetFloat( "tracer_offset","0.0f" );
owner->SetModel( "" );
this->distance = distance - offset;
this->lastPos = muzzleOrigin + tracerAxis[0] * offset;
this->flyTime = gameLocal.time;
this->speed = speed/1000.0f;
memset( &renderEntity, 0, sizeof ( renderEntity ) );
// align z-axis of model with the direction
renderEntity.axis[0] = tracerAxis[2];
renderEntity.axis[2] = tracerAxis[0];
renderEntity.axis[1] = tracerAxis[1];
length = owner->spawnArgs.GetFloat( "beam_length", TRACER_LENGTH );
this->muzzleOrigin = lastPos;
idVec4 tracerColor = owner->spawnArgs.GetVec4( "beam_color", "1.0 1.0 1.0 1.0" );
renderEntity.origin = lastPos;
renderEntity.shaderParms[ SHADERPARM_RED ] = tracerColor[0];
renderEntity.shaderParms[ SHADERPARM_GREEN ] = tracerColor[1];
renderEntity.shaderParms[ SHADERPARM_BLUE ] = tracerColor[2];
renderEntity.shaderParms[ SHADERPARM_ALPHA ] = tracerColor[3];
renderEntity.shaderParms[ SHADERPARM_BEAM_WIDTH ] = owner->spawnArgs.GetFloat( "beam_width", TRACER_WIDTH );
idVec3 endPos = renderEntity.origin - renderEntity.axis[2] * length;
renderEntity.shaderParms[ SHADERPARM_BEAM_END_X ] = endPos[0];
renderEntity.shaderParms[ SHADERPARM_BEAM_END_Y ] = endPos[1];
renderEntity.shaderParms[ SHADERPARM_BEAM_END_Z ] = endPos[2];
renderEntity.hModel = renderModelManager->FindModel( "_beam" );
renderEntity.customSkin = declManager->FindSkin( skinName );
modelDefHandle = gameRenderWorld->AddEntityDef( &renderEntity );
}
/*
================
dnBeamSpeedTracer::Think
================
*/
void dnBeamSpeedTracer::Think( void ) {
if ( modelDefHandle < 0 ){
return;
}
if( UpdatePosition() ){
idVec3 endPos = renderEntity.origin - renderEntity.axis[2] * length;
if( (renderEntity.origin - endPos).LengthSqr() > (renderEntity.origin - muzzleOrigin).LengthSqr() ) {
endPos = muzzleOrigin;
}
renderEntity.shaderParms[ SHADERPARM_BEAM_END_X ] = endPos[0];
renderEntity.shaderParms[ SHADERPARM_BEAM_END_Y ] = endPos[1];
renderEntity.shaderParms[ SHADERPARM_BEAM_END_Z ] = endPos[2];
gameRenderWorld->UpdateEntityDef( modelDefHandle, &renderEntity );
}
}
/*
===============================================================================
dnRailBeam
===============================================================================
*/
dnRailBeam::dnRailBeam( idEntity *owner, const idVec3 &beamStart )
: dnTracerEffect( owner ) {
SetType( TR_TYPE_RAILBEAM ); // We must set type in the beginning of every constructor.
const char *skinName = owner->spawnArgs.GetString( "beam_skin" );
if ( skinName[0] == '\0' ) {
modelDefHandle = -1;
return;
}
offset = owner->spawnArgs.GetFloat( "beam_offset","0.0f" );
smokeOffset[0] = owner->spawnArgs.GetFloat( "beam_smoke_offset","0.0f" );
owner->SetModel( "" );
this->time = SEC2MS( owner->spawnArgs.GetFloat( "beam_time", "2.0f") );
this->fadeOut = owner->spawnArgs.GetFloat( "beam_fadeout", "0.0f") * time; // percentage of time the beam fades out
idVec4 beamColor = owner->spawnArgs.GetVec4( "beam_color", "1.0 1.0 1.0 1.0" );
this->fadeColor = owner->spawnArgs.GetVec4( "beamfade_color", "0.0 0.0 0.0 0.0" );
if( fadeOut > 0 ) {
this->fadeOutIntervals = (beamColor - fadeColor) / fadeOut;
}
memset( &renderEntity, 0, sizeof ( renderEntity ) );
renderEntity.origin = beamStart;
renderEntity.shaderParms[ SHADERPARM_RED ] = beamColor[0];
renderEntity.shaderParms[ SHADERPARM_GREEN ] = beamColor[1];
renderEntity.shaderParms[ SHADERPARM_BLUE ] = beamColor[2];
renderEntity.shaderParms[ SHADERPARM_ALPHA ] = beamColor[3];
renderEntity.shaderParms[ SHADERPARM_BEAM_WIDTH ] = owner->spawnArgs.GetFloat( "beam_width", TRACER_WIDTH );
if( owner->spawnArgs.GetFloat( "beam_end_width", TRACER_WIDTH, beamEndWidth ) && time > 0 ){
deltaWidthPerMsec = (beamEndWidth - renderEntity.shaderParms[ SHADERPARM_BEAM_WIDTH ]) / time;
}
else {
deltaWidthPerMsec = 0.0f;
}
renderEntity.hModel = renderModelManager->FindModel( "_beam" );
renderEntity.customSkin = declManager->FindSkin( skinName );
modelDefHandle = -1;
smokeParticle = static_cast<const idDeclParticle *>( declManager->FindType( DECL_PARTICLE, owner->spawnArgs.GetString("beam_smoke"), false ) );
smokeLength = owner->spawnArgs.GetFloat( "beam_smoke_length", "10" );
}
/*
================
dnBeamSpeedTracer::Think
================
*/
void dnRailBeam::Create( const idVec3 &beamEnd ) {
time += gameLocal.time;
previousTime = gameLocal.time;
fadeOut = time - fadeOut; //use same fadeOut var as a fadeOut time Offset
renderEntity.shaderParms[ SHADERPARM_BEAM_END_X ] = beamEnd[0];
renderEntity.shaderParms[ SHADERPARM_BEAM_END_Y ] = beamEnd[1];
renderEntity.shaderParms[ SHADERPARM_BEAM_END_Z ] = beamEnd[2];
if( offset != 0.0f ) {
idVec3 dir = beamEnd - renderEntity.origin;
dir.Normalize();
renderEntity.origin += offset * dir;
smokeOffset = renderEntity.origin + smokeOffset[0] * dir;
}
modelDefHandle = gameRenderWorld->AddEntityDef( &renderEntity );
if( smokeParticle != NULL ) {
// idVec3 length = beamEnd - renderEntity.origin;
idVec3 length = beamEnd - smokeOffset;
smokeLength = smokeLength > 0.0f ? smokeLength : 10.0f; // make sure smokeLength is non-zero
nSmokeParticles = length.LengthFast()/smokeLength;
length.Normalize();
renderEntity.axis = length.ToMat3(); //For creating proper non random particle effect, we need to set the axis right
//test 1:swap(x-z)
idVec3 tmp = renderEntity.axis[0];
renderEntity.axis[0] = renderEntity.axis[2];
renderEntity.axis[2] = -tmp;
//-----------------
smokeStartTime = gameLocal.time;
}
else {
nSmokeParticles = 0;
renderEntity.axis = owner->GetPhysics()->GetAxis(); // we just need to set this to something.
}
owner->BecomeActive( TH_UPDATEPARTICLES );
}
/*
================
dnBeamSpeedTracer::Think
================
*/
void dnRailBeam::Think( void ) {
if ( modelDefHandle < 0 ){
return;
}
int deadSmokeCount = 0;
if( nSmokeParticles > 0 ){
for( int i=0; i < nSmokeParticles; i++ ) {
// if( !gameLocal.smokeParticles->EmitSmoke( smokeParticle, smokeStartTime, gameLocal.random.RandomFloat(), renderEntity.origin + smokeLength * (i+1) * renderEntity.axis[0], renderEntity.axis ) ) {
if( !gameLocal.smokeParticles->EmitSmoke( smokeParticle, smokeStartTime, gameLocal.random.RandomFloat(), smokeOffset - smokeLength * (i+1) * renderEntity.axis[2], renderEntity.axis ) ) {
deadSmokeCount++;
}
}
}
if( gameLocal.time >= time ) {
renderEntity.shaderParms[ SHADERPARM_RED ] = fadeColor[0];
renderEntity.shaderParms[ SHADERPARM_GREEN ] = fadeColor[1];
renderEntity.shaderParms[ SHADERPARM_BLUE ] = fadeColor[2];
renderEntity.shaderParms[ SHADERPARM_ALPHA ] = fadeColor[3];
if( deltaWidthPerMsec != 0.0f ) {
renderEntity.shaderParms[ SHADERPARM_BEAM_WIDTH ] = beamEndWidth;
}
if( deadSmokeCount == nSmokeParticles ) {
owner->BecomeInactive( TH_UPDATEPARTICLES );
}
}
else {
int delta = gameLocal.time - previousTime;
if( deltaWidthPerMsec != 0.0f ) {
renderEntity.shaderParms[ SHADERPARM_BEAM_WIDTH ] += deltaWidthPerMsec * delta;
}
if( fadeOut > 0 && gameLocal.time >= fadeOut ) {
idVec4 intervals = fadeOutIntervals * delta;
renderEntity.shaderParms[ SHADERPARM_RED ] -= intervals[0];
renderEntity.shaderParms[ SHADERPARM_GREEN ] -= intervals[1];
renderEntity.shaderParms[ SHADERPARM_BLUE ] -= intervals[2];
renderEntity.shaderParms[ SHADERPARM_ALPHA ] -= intervals[3];
}
previousTime = gameLocal.time;
}
gameRenderWorld->UpdateEntityDef( modelDefHandle, &renderEntity );
}
#endif /* !_DENTONMOD */

231
game/tracer.h Normal file
View file

@ -0,0 +1,231 @@
#ifdef _DENTONMOD
#ifndef __GAME_TRACER_H__
#define __GAME_TRACER_H__
#include "Entity.h"
#include "idlib/math/Vector.h"
// TypeInfo flags
enum {
TR_TYPE_TRACEREFFECT = 1, // dnTracerEffect Type
TR_TYPE_TRACER = 2, // dnTracer Type
TR_TYPE_SPEEDTRACER = 4, // dnSpeedTracer Type
TR_TYPE_BEAMTRACER = 8, // dnBeamTracer Type
TR_TYPE_BEAMSPEEDTRACER = 16, // dnBeamSpeedTracer Type
TR_TYPE_RAILBEAM = 32, // dnBeamSpeedTracer Type
TR_TYPE_BARRELLAUNCHEDTRACER = 64, // dnBarrelLaunchedBeamTracer Type
};
/*
===============================================================================
dnTracerEffect:
Abstract Base Class for all types of tracers
===============================================================================
*/
class idEntity;
class dnTracerEffect {
protected:
idEntity *owner;
public :
dnTracerEffect( idEntity *owner ); // a projectileEntity
virtual ~dnTracerEffect() { };
// virtual void Save( idSaveGame *savefile ) const; // tracers are not important enough to be saved
// virtual void Restore( idRestoreGame *savefile ); // Implement these if you wish to save the tracer data
virtual void Think( void ) = 0;
//-------------------------------------------------
// for simple and rather simulated RTTI, since we don't need
// to store hoards of type-info for a tracer effect.
//-------------------------------------------------
private:
int typeInfo;
protected:
void SetType( int typeFlag ) { typeInfo |= typeFlag; }
public:
static int Type( void ) { return TR_TYPE_TRACEREFFECT; }
bool IsType( int typeFlag ) const { return (typeInfo & typeFlag)? true:false; }
//-------------------------------------------------
};
ID_INLINE dnTracerEffect::dnTracerEffect( idEntity *owner ) {
this->owner = owner;
typeInfo = TR_TYPE_TRACEREFFECT;
}
/*
===============================================================================
dnTracer:
A simple tracer Effect that uses projectiles renderEntity rather than it's own.
===============================================================================
*/
class dnTracer : public dnTracerEffect {
protected:
idVec3 playerViewOrigin;
idVec3 weaponMuzzleOrigin;
idMat3 axis;
float distanceRatio;
public :
dnTracer ( idEntity *owner ) : dnTracerEffect(owner) { SetType( TR_TYPE_TRACER ); } // this constructor only used by derived classes
dnTracer ( idEntity *owner, const float distanceRatio, const idVec3 &viewOrigin, const idVec3 &muzzleOrigin, const idMat3 &tracerAxis );
virtual ~dnTracer () { }
virtual void Think( void );
static int Type( void ) { return TR_TYPE_TRACER; }
};
/*
===============================================================================
dnSpeedTracer:
For tracer effect with user defined speeds, uses it's own renderEntity model.
===============================================================================
*/
class dnSpeedTracer : public dnTracerEffect {
protected:
idVec3 lastPos;
float speed;
float flyTime;
float distance;
qhandle_t modelDefHandle;
renderEntity_t renderEntity;
public :
dnSpeedTracer ( idEntity *owner ):dnTracerEffect(owner) { SetType(TR_TYPE_SPEEDTRACER); }
dnSpeedTracer ( idEntity *owner, const float speed, const float distance, const idVec3 &muzzleOrigin, const idMat3 &tracerAxis );
virtual ~dnSpeedTracer ();
bool UpdatePosition( void );
bool IsDead( void ) { return (modelDefHandle==-1); }
virtual void Think( void ) ;
static int Type( void ) { return TR_TYPE_SPEEDTRACER; }
};
ID_INLINE dnSpeedTracer::~dnSpeedTracer() {
if ( modelDefHandle >= 0){
gameRenderWorld->FreeEntityDef( modelDefHandle );
}
}
/*
===============================================================================
dnBeamTracer:
Beam model based dnTracer
===============================================================================
*/
class dnBeamTracer : public dnTracer {
protected:
float length;
public :
dnBeamTracer( idEntity *owner, const float distanceRatio, const idVec3 &viewOrigin, const idVec3 &muzzleOrigin, const idMat3 &tracerAxis );
virtual ~dnBeamTracer(){};
void Think( void ) ;
static int Type( void ) { return TR_TYPE_BEAMTRACER; }
};
/*
===============================================================================
dnBarrelLaunchedBeamTracer:
Beam model based tracer for barrel launched projectiles.
===============================================================================
*/
class dnBarrelLaunchedBeamTracer : public dnTracerEffect {
protected:
idVec3 weaponMuzzleOrigin;
float length;
public :
dnBarrelLaunchedBeamTracer( idEntity *owner );
virtual ~dnBarrelLaunchedBeamTracer(){};
void Think( void ) ;
static int Type( void ) { return TR_TYPE_BARRELLAUNCHEDTRACER; }
};
/*
===============================================================================
dnBeamSpeedTracer:
Beam model based dnSpeedTracer
===============================================================================
*/
class dnBeamSpeedTracer : public dnSpeedTracer {
private:
idVec3 muzzleOrigin;
protected:
float length;
public :
dnBeamSpeedTracer( idEntity *owner, const float speed, const float distance, const idVec3 &muzzleOrigin, const idMat3 &tracerAxis );
virtual ~dnBeamSpeedTracer(){};
void Think( void ) ;
static int Type( void ) { return TR_TYPE_BEAMSPEEDTRACER; }
};
/*
===============================================================================
dnRailBeam:
For Railgun like beam effect
===============================================================================
*/
class dnRailBeam : public dnTracerEffect {
private:
int fadeOut;
int time; // In seconds
int previousTime;
float offset;
idVec3 smokeOffset;
float beamEndWidth;
float deltaWidthPerMsec;
idVec4 fadeColor;
idVec4 fadeOutIntervals;
qhandle_t modelDefHandle;
renderEntity_t renderEntity;
float smokeLength;
int nSmokeParticles;
int smokeStartTime;
const idDeclParticle* smokeParticle;//Used for smoke particles
public :
dnRailBeam( idEntity *owner, const idVec3 &beamStart );
virtual ~dnRailBeam() {
if ( modelDefHandle >= 0){
gameRenderWorld->FreeEntityDef( modelDefHandle );
}
};
void Create( const idVec3 &beamEnd );
void Think( void ) ;
static int Type( void ) { return TR_TYPE_RAILBEAM; }
};
#endif /* !__GAME_TRACER_H__ */
#endif /* !_DENTONMOD */