The walker is back.

[divverent/nexuiz.git] / data / qcsrc / server / tturrets / include / turret_tturrets_early.qh

// Comment out below to skip turrets\r
#define TTURRETS_ENABLED\r
\r
#ifdef TTURRETS_ENABLED\r
\r
#message "with tZork turrets rc2"\r
\r
vector real_origin(entity ent);\r
\r
/// target selection flags\r
.float target_select_flags;\r
.float target_validate_flags;\r
/// Dont select a target on its own.\r
#define TFL_TARGETSELECT_NO            1024\r
/// Need line of sight\r
#define TFL_TARGETSELECT_LOS           2\r
/// Players are valid targets\r
#define TFL_TARGETSELECT_PLAYERS       4\r
/// Missiles are valid targets\r
#define TFL_TARGETSELECT_MISSILES      8\r
/// Responds to turret_trigger_target events\r
#define TFL_TARGETSELECT_TRIGGERTARGET 16\r
/// Angular limitations of turret head limits target selection\r
#define TFL_TARGETSELECT_ANGLELIMITS   32\r
/// Range limits apply in targetselection\r
#define TFL_TARGETSELECT_RANGELIMTS    64\r
/// DOnt select targets with a .team matching its own\r
#define TFL_TARGETSELECT_TEAMCHECK     4096\r
/// Cant select targets on its own. needs to be triggerd or slaved.\r
#define TFL_TARGETSELECT_NOBUILTIN     256\r
/// TFL_TARGETSELECT_TEAMCHECK is inverted (selects only mebers of own .team)\r
#define TFL_TARGETSELECT_OWNTEAM       2048\r
/// Turrets aren't valid targets\r
#define TFL_TARGETSELECT_NOTURRETS     128\r
\r
/// aim flags\r
.float aim_flags;\r
/// Dont aim.\r
#define TFL_AIM_NO                  1\r
/// Go for ground, not direct hit\r
#define TFL_AIM_GROUND              2\r
/// Go for ground, not direct hit if target is on ground too\r
#define TFL_AIM_GROUND2              4\r
/// Use balistic aim (not implemented)\r
#define TFL_AIM_BALISTIC            8\r
/// Try to predict target movement (does not account for gravity)\r
#define TFL_AIM_LEAD                16\r
/// Compensate for shot traveltime when lead\r
#define TFL_AIM_SHOTTIMECOMPENSATE  32\r
/// Aim slightly in front of target\r
#define TFL_AIM_INFRONT             64\r
/// Aim slightly behind target\r
#define TFL_AIM_BEHIND              128\r
/// blend real and predicted z positions. (fake bounce prediction)\r
#define TFL_AIM_ZEASE               256\r
/// Try to do real prediction of targets z pos at impact.\r
//#define TFL_AIM_ZPREDICT            256\r
/// Just poitn at target's current location\r
#define TFL_AIM_SIMPLE              512\r
\r
/// track (turn and pitch head) flags\r
.float track_flags;\r
/// Dont move head\r
#define TFL_TRACK_NO    2\r
/// Pitch the head\r
#define TFL_TRACK_PITCH 4\r
/// Rotate the head\r
#define TFL_TRACK_ROT   8\r
\r
/// How tracking is preformed\r
.float track_type;\r
/// Hard angle increments. Ugly for fast turning, best accuracy.\r
#define TFL_TRACKTYPE_STEPMOTOR    1\r
/// Smoth absolute movement. Looks ok, fair accuracy.\r
#define TFL_TRACKTYPE_FLUIDPRECISE 2\r
/// Simulated inertia. "Wobbly mode" Looks kool, can mean terrible accuracy depending on how the feilds below are set\r
#define TFL_TRACKTYPE_FLUIDINERTIA 3\r
/// TFL_TRACKTYPE_FLUIDINERTIA: pitch multiplier\r
.float track_accel_pitch;\r
/// TFL_TRACKTYPE_FLUIDINERTIA: rotation multiplier\r
.float  track_accel_rot;\r
/// TFL_TRACKTYPE_FLUIDINERTIA: Blendrate with old rotation (inertia simulation) 1  = only old, 0 = only new\r
.float  track_blendrate;\r
\r
/// How prefire check is preformed\r
.float firecheck_flags;\r
/// Dont do any chekcs\r
#define TFL_FIRECHECK_NO          8192\r
/// Dont kill the world\r
#define TFL_FIRECHECK_WORLD       2\r
/// Dont kill the dead\r
#define TFL_FIRECHECK_DEAD        4\r
/// Range limits apply\r
#define TFL_FIRECHECK_DISTANCES   8\r
/// Line Of Sight needs to be clear\r
#define TFL_FIRECHECK_LOS         16\r
/// Consider distance inpactpoint<->aimspot\r
#define TFL_FIRECHECK_AIMDIST     32\r
/// Consider enemy origin<->impactpoint\r
#define TFL_FIRECHECK_REALDIST    64\r
/// Consider angular diff head<->aimspot\r
#define TFL_FIRECHECK_ANGLEDIST  128\r
/// (re)consider target.team<->self.team\r
#define TFL_FIRECHECK_TEAMCECK   256\r
/// Try to avoid friendly fire\r
#define TFL_FIRECHECK_AFF        512\r
/// Own .ammo needs to be >= then own .shot_dmg\r
#define TFL_FIRECHECK_OWM_AMMO   1024\r
/// Others ammo need to be < others .ammo_max\r
#define TFL_FIRECHECK_OTHER_AMMO 2048\r
/// Check own .attack_finished_single vs time\r
#define TFL_FIRECHECK_REFIRE     4096\r
\r
/// How shooting is done\r
.float shoot_flags;\r
/// Dont shoot\r
#define  TFL_SHOOT_NO          64\r
/// Fire in vollys (partial implementation through .shot_volly)\r
#define  TFL_SHOOT_VOLLY       2\r
/// Always do a full volly, even if target is lost or dead. (not implemented)\r
#define  TFL_SHOOT_VOLLYALWAYS 4\r
/// Loop though all valid tarters, and hit them.\r
#define  TFL_SHOOT_HITALLVALID 8\r
/// Fiering makes unit loose target (after volly is done, if in volly mode)\r
#define  TFL_SHOOT_CLEARTARGET 16\r
///Custom shooting;\r
#define  TFL_SHOOT_CUSTOM 32\r
\r
/// Information aboute the units capabilities\r
.float turrcaps_flags;\r
/// No kown capabilities\r
#define  TFL_TURRCAPS_NONE        0\r
/// Capable of sniping\r
#define  TFL_TURRCAPS_SNIPER      2\r
/// Capable of splasdamage\r
#define  TFL_TURRCAPS_RADIUSDMG   4\r
/// Has one or more cannons with zero shot traveltime\r
#define  TFL_TURRCAPS_HITSCAN     8\r
/// More then one (type of) gun\r
#define  TFL_TURRCAPS_MULTIGUN    16\r
/// Carries at least one guided weapon\r
#define  TFL_TURRCAPS_GUIDED      32\r
/// At least one gun fiers slow projectiles\r
#define  TFL_TURRCAPS_SLOWPROJ    64\r
/// At least one gun fiers medium speed projectiles\r
#define  TFL_TURRCAPS_MEDPROJ     128\r
/// At least one gun fiers fast projectiles\r
#define  TFL_TURRCAPS_FASTPROJ    256\r
/// At least one gun capable of damaging players\r
#define  TFL_TURRCAPS_PLAYERKILL  512\r
/// At least one gun that can shoot town missiles\r
#define  TFL_TURRCAPS_MISSILEKILL 1024\r
/// Has support capabilities. powerplants and sutch.\r
#define  TFL_TURRCAPS_SUPPORT     2048\r
/// Proveides at least one type of ammmo\r
#define  TFL_TURRCAPS_AMMOSOURCE  4096\r
/// Can recive targets from external sources\r
#define TFL_TURRCAPS_RECIVETARGETS 8192\r
/// Capable of self-transport\r
#define TFL_TURRCAPS_MOVE 16384\r
/// Will roam arround even if not chasing anyting\r
#define TFL_TURRCAPS_ROAM 32768\r
#define TFL_TURRCAPS_LINKED 65536\r
\r
/// Ammo types needed and/or provided\r
.float ammo_flags;\r
/// Has and needs no ammo\r
#define  TFL_AMMO_NONE     64\r
/// Uses power\r
#define  TFL_AMMO_ENERGY   2\r
/// Uses bullets\r
#define  TFL_AMMO_BULLETS  4\r
/// Uses explosives\r
#define  TFL_AMMO_ROCKETS  8\r
/// Regenerates ammo on its own\r
#define  TFL_AMMO_RECHARGE 16\r
/// Can recive ammo from others\r
#define  TFL_AMMO_RECIVE   32\r
\r
/// How incomming damage is handeld\r
.float damage_flags;\r
/// Cant be hurt\r
#define  TFL_DMG_NO              256\r
/// Can be damaged\r
#define  TFL_DMG_YES             2\r
/// Can be damaged  by teammates\r
#define  TFL_DMG_TAKEFROMTEAM    4\r
/// Traget attackers\r
#define  TFL_DMG_RETALIATE       8\r
/// Target attackers, even is on own team\r
#define  TFL_DMG_RETALIATEONTEAM 16\r
/// Loses target when damaged\r
#define  TFL_DMG_TARGETLOSS      32\r
/// Reciving damage trows off aim\r
#define  TFL_DMG_AIMSHAKE        64\r
/// Reciving damage slaps the head arround\r
#define  TFL_DMG_HEADSHAKE       128\r
\r
// Spawnflags\r
/// Spawn in teambased modes\r
#define TFL_SPAWN_TEAM      2\r
/// Spawn in FFA modes\r
#define TFL_SPAWN_FFA       4\r
/// Respawn after death\r
#define TFL_SPAWN_RESPAWN   8\r
\r
/*\r
* Fields commnly used by turrets\r
*/\r
/// Turrets internal ai speed\r
.float      ticrate;\r
/// Where to point the head when no target\r
.vector     idle_aim;\r
/// Top part of turret\r
.entity     tur_head;\r
/// Start/respawn health\r
.float      tur_health;\r
/// Defend this entity (or ratehr this entitys position)\r
.entity     tur_defend;\r
/// on/off toggle.\r
.float      tur_active;\r
/// Aim from this point,\r
.vector     tur_aimorg;\r
/// and shoot from here. (could be non constant, think MLRS)\r
.vector     tur_shotorg;\r
/// Aim at this spot\r
.vector     tur_aimpos;\r
/// Predicted time the round will impact\r
.float      tur_impacttime;\r
/// Predicted place the round will impact\r
.vector     tur_impactpoint;\r
/// What entity the aimtrace hit, if any.\r
.entity     tur_impactent;\r
/// Distance to enemy\r
.float      tur_dist_enemy;\r
/// Distance impact<->aim\r
.float      tur_dist_toaimpos;\r
/// Decresment counter form .shot_volly to 0.\r
.float      volly_counter;\r
\r
/*\r
* Projectile/missile. its up to the individual turret implementation to\r
** deal the damage, blow upp the missile or whatever.\r
*/\r
/// Track then refireing is possible\r
//.float attack_finished; = attack_finished_single\r
/// Shoot this often\r
.float shot_refire;\r
/// Shots travel this fast, when appliable\r
.float shot_speed;\r
/// Inaccuracy\r
.float shot_spread;\r
/// Estimated (core) damage of projectiles. also reduce on ammo with this amount when fiering\r
.float shot_dmg;\r
/// If radius dmg, this is how big that radius is.\r
.float shot_radius;\r
/// Max force exserted by round impact\r
.float shot_force;\r
/// < 1 = shoot # times at target (if possible)\r
.float shot_volly;\r
/// Refire after a compleated or borken volly.\r
.float shot_volly_refire;\r
\r
/// Consider targets within this range\r
.float target_range;\r
/// Dont consider targets closer then\r
.float target_range_min;\r
/// Engage fire routine on targets within\r
.float target_range_fire;\r
/// Targets closer to this are prefered\r
.float target_range_optimal;\r
\r
/*\r
* The standard targetselection tries to select a target based on\r
* range, angle offset, target type, "is old target"\r
* Thise biases will allow score scaling to (dis)favor diffrent targets\r
*/\r
/// (dis)Favor best range this mutch\r
.float target_select_rangebias;\r
/// (dis)Favor targeting my old enemy this mutch\r
.float target_select_samebias;\r
/// (dis)Favor targeting the enemy closest to my guns current angle this mutch\r
.float target_select_anglebias;\r
/// (dis)Favor Missiles? (-1 to diable targeting compleatly)\r
.float target_select_missilebias;\r
/// (dis)Favot living players (-1 to diable targeting compleatly)\r
.float target_select_playerbias;\r
\r
/*\r
* Aim refers to real aiming, not gun pos (thats done by track)\r
*/\r
/// Maximum offset between impact and aim spot to fire\r
.float aim_firetolerance_dist;\r
/// Maximum angular offset between head and aimspot to fire\r
//.float aim_firetolerance_angle;\r
/// How fast can i rotate/pitch (per second in stepmotor mode, base force in smooth modes)\r
.float aim_speed;\r
/// cant aim higher/lower then this\r
.float aim_maxpitch;\r
/// I cant rotate more then this\r
.float aim_maxrot;\r
\r
// Ammo/power. keeping dmg and ammo on a one to one ratio is preferable (for rating)\r
/// Staring & current ammo\r
.float ammo;\r
/// Regenerate this mutch ammo (per second)\r
.float ammo_recharge;\r
/// Max amount of ammo i can hold\r
.float ammo_max;\r
\r
\r
// Uncomment below to enable various debug output.\r
//#define TURRET_DEBUG\r
//#define TURRET_DEBUG_TARGETVALIDATE\r
//#define TURRET_DEBUG_TARGETSELECT\r
\r
#ifdef TURRET_DEBUG\r
.float tur_dbg_dmg_t_h; // Total dmg that hit something (can be more then tur_dbg_dmg_t_f since it should count radius dmg.\r
.float tur_dbg_dmg_t_f; // Total damage spent\r
.float tur_dbg_start;   // When did i go online?\r
.float tur_dbg_tmr1;    // timer for random use\r
.float tur_dbg_tmr2;    // timer for random use\r
.float tur_dbg_tmr3;    // timer for random use\r
.vector tur_dbg_rvec;   // Random vector, mainly for coloruing stuff'\r
#endif\r
\r
// System main's\r
/// Main AI loop\r
void turret_think();\r
/// Prefire checks and sutch\r
void turret_fire();\r
\r
// Callbacks\r
/// implements the actual fiering\r
.void()  turret_firefunc;\r
/// prefire checks go here. return 1 to go bang, 0 not to.\r
.float() turret_firecheckfunc;\r
// Execure BEFORE main ai loop. return 0 to cancel any following proccessing.\r
//.float() turret_prethink;\r
/// Execure AFTER main AI loop UNLESS turret_prethink returnd 0\r
.void()  turret_postthink;\r
\r
/// Add a target\r
.float(entity e_target,entity e_sender) turret_addtarget;\r
\r
//.float call_diehook;\r
//.float call_respwnhook;\r
.void() turret_diehook;\r
.void() turret_respawnhook;\r
\r
/*\r
#define TEH_THINK 2\r
#define TEH_DAMAGE 4\r
#define TEH_DIE 8\r
#define TEH_RESPAWN 16\r
#define TEH_TRACK 32\r
#define TEH_AIM 64\r
#define TEH_SELECT 128\r
.float(float event_id) turret_eventhook;\r
*/\r
\r
/*\r
* Some turrets need other aimsystems then other.\r
* This should return the place to aim at, not acctualy turn or\r
* pitch anyting.\r
*\r
* use turret_stdproc_aim* or Make your own.\r
* Make sure you update tur_enemy_dist and tur_enemy_adist\r
* with the apropriate info, if you do.\r
\r
removed.\r
*/\r
/// function used to aim, usualy turret_stdproc_aim_generic\r
//.vector() turret_aim;\r
\r
/*\r
* This is where the acctual turret turning should take place\r
* Use turret_stdproc_track or make your own.\r
wkacked to save mem.\r
*/\r
// Function used to turn and pitch the .tur_head usualy turret_stdproc_track\r
//.void() turret_track;\r
\r
/*\r
* Target selection, preferably but not nessesarely\r
* return a normalized result.\r
*/\r
/// Function to use for target evaluation. usualy turret_stdproc_targetscore_generic\r
.float(entity e_turret, entity e_target) turret_score_target;\r
\r
/*\r
* Damage, death and respawn.\r
*/\r
//void turret_gibs_precash();\r
// generalized so save mem (on fields)\r
// Function to handle incomming damage. usualy turret_stdproc_damage\r
//.void(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector vforce) turret_damagefunc;\r
// Function to handle the event of death. usualy turret_stdproc_die\r
//.void() turret_diefunc;\r
// Function that handles rebirth. usualy turret_stdproc_respawn\r
//.void() turret_spawnfunc;\r
\r
/*\r
* Stuff to plug into requierd but unused callbacks.\r
*/\r
/// Always return 1\r
float turret_stdproc_true();\r
/// Always return 0\r
float turret_stdproc_false();\r
/// Always return nothing at all\r
void turret_stdproc_nothing();\r
\r
/*\r
* Target selection\r
*/\r
/// "closeer is beter" selection\r
float   turret_stdproc_targetscore_close(entity e_turret, entity e_target);\r
/// "further is beter" selection\r
float   turret_stdproc_targetscore_far(entity e_turret, entity e_target);\r
/// only target_range_optimal\r
float   turret_stdproc_targetscore_optimal(entity e_turret, entity e_target);\r
/// defendpos\r
float   turret_stdproc_targetscore_defend(entity e_turret, entity e_target);\r
/// Generic fairly smart bias-aware target selection.\r
float   turret_stdproc_targetscore_generic(entity e_turret, entity e_target);\r
/// Experimental supportunits targetselector\r
float   turret_stdproc_targetscore_support(entity e_turret,entity e_target);\r
\r
/*\r
* Aim functions\r
*/\r
/// Generic aimer guided by self.aim_flags\r
vector turret_stdproc_aim_generic()\r
// Straight line, current location\r
//vector  turret_stdproc_aim_simple()\r
\r
/*\r
* Turret turning & pitch\r
*/\r
/// Tries to line up the turret head with the aimpos\r
void turret_stdproc_track();\r
\r
/// Generic damage handeling. blows up the turret when health <= 0\r
void turret_stdproc_damage (entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector vforce);\r
/// Spawns a explotion, does some damage & trows bits arround.\r
void turret_stdproc_die();\r
/// reassembles the turret.\r
void turret_stdproc_respawn();\r
\r
/// Evaluate target validity\r
float turret_validate_target(entity e_turret,entity e_target,float validate_flags);\r
/// Turret Head Angle Diff Vector. updated by a sucsessfull call to turret_validate_target\r
vector tvt_thadv;\r
/// Turret Angle Diff Vector. updated by a sucsessfull call to turret_validate_target\r
vector tvt_tadv;\r
/// Turret Head Angle Diff Float. updated by a sucsessfull call to turret_validate_target\r
float  tvt_thadf;\r
/// Turret Angle Diff Float. updated by a sucsessfull call to turret_validate_target\r
float  tvt_tadf;\r
/// Distance. updated by a sucsessfull call to turret_validate_target\r
float  tvt_dist;\r
\r
/// updates aim org, shot org, shot dir and enemy org for selected turret\r
void turret_do_updates(entity e_turret);\r
.vector tur_aimorg_updated;\r
.vector tur_shotorg_updated;\r
.vector tur_shotdir_updated;\r
\r
void turrets_precash();\r
#endif // TTURRETS_ENABLED\r