X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=qcsrc%2Fcommon%2Fturrets%2Fsv_turrets.qc;h=66b3f3dbb61d864a744a620845d809db1b32e0dc;hb=cf1edea8694548556934b5b05f526bc192f576cb;hp=e979c4802ba94cfa7fe75c84cfa2144c13614ecb;hpb=ac5366add2c2d44bff2e03fc916b991eb009a10a;p=xonotic%2Fxonotic-data.pk3dir.git diff --git a/qcsrc/common/turrets/sv_turrets.qc b/qcsrc/common/turrets/sv_turrets.qc index e979c4802..66b3f3dbb 100644 --- a/qcsrc/common/turrets/sv_turrets.qc +++ b/qcsrc/common/turrets/sv_turrets.qc @@ -1,11 +1,9 @@ -// ========================= -// SVQC Turret Properties -// ========================= - +#ifdef SVQC +#include // Generic aiming vector turret_aim_generic() -{ +{SELFPARAM(); vector pre_pos, prep; float distance, impact_time = 0, i, mintime; @@ -15,7 +13,7 @@ vector turret_aim_generic() if(self.aim_flags & TFL_AIM_SIMPLE) return real_origin(self.enemy); - mintime = max(self.attack_finished_single - time,0) + sys_frametime; + mintime = max(self.attack_finished_single[0] - time,0) + sys_frametime; // Baseline pre_pos = real_origin(self.enemy); @@ -26,14 +24,14 @@ vector turret_aim_generic() if (self.aim_flags & TFL_AIM_SHOTTIMECOMPENSATE) // Need to conpensate for shot traveltime { prep = pre_pos; - + distance = vlen(prep - self.tur_shotorg); impact_time = distance / self.shot_speed; prep = pre_pos + (self.enemy.velocity * (impact_time + mintime)); if(self.aim_flags & TFL_AIM_ZPREDICT) - if(!(self.enemy.flags & FL_ONGROUND)) + if(!IS_ONGROUND(self.enemy)) if(self.enemy.movetype == MOVETYPE_WALK || self.enemy.movetype == MOVETYPE_TOSS || self.enemy.movetype == MOVETYPE_BOUNCE) { float vz; @@ -121,7 +119,7 @@ float turret_targetscore_generic(entity _turret, entity _target) (m_score * _turret.target_select_missilebias) + (p_score * _turret.target_select_playerbias); - if(_turret.target_range < vlen(_turret.tur_shotorg - real_origin(_target))) + if(vdist((_turret.tur_shotorg - real_origin(_target)), >, _turret.target_range)) { //dprint("Wtf?\n"); score *= 0.001; @@ -166,15 +164,14 @@ float turret_targetscore_generic(entity _turret, entity _target) } // Generic damage handling -void() turret_respawn; -void turret_hide() +void turret_hide(entity this) { self.effects |= EF_NODRAW; self.nextthink = time + self.respawntime - 0.2; - self.think = turret_respawn; + setthink(self, turret_respawn); } -void turret_die() +void turret_die(entity this) { self.deadflag = DEAD_DEAD; self.tur_head.deadflag = self.deadflag; @@ -191,9 +188,10 @@ void turret_die() // Go boom //RadiusDamage (self,self, min(self.ammo,50),min(self.ammo,50) * 0.25,250,world,min(self.ammo,50)*5,DEATH_TURRET,world); + Turret tur = get_turretinfo(self.m_id); if(self.damage_flags & TFL_DMG_DEATH_NORESPAWN) { - TUR_ACTION(self.turretid, TR_DEATH); + tur.tr_death(tur, self); remove(self.tur_head); remove(self); @@ -203,63 +201,58 @@ void turret_die() // Setup respawn self.SendFlags |= TNSF_STATUS; self.nextthink = time + 0.2; - self.think = turret_hide; + setthink(self, turret_hide); - TUR_ACTION(self.turretid, TR_DEATH); + tur.tr_death(tur, self); } } -void turret_damage (entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector vforce) +void turret_damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector vforce) { - // Enougth allready! - if(self.deadflag == DEAD_DEAD) + // Enough already! + if(this.deadflag == DEAD_DEAD) return; // Inactive turrets take no damage. (hm..) - if(!self.active) + if(!this.active) return; - if (teamplay) - if (self.team == attacker.team) + if(SAME_TEAM(this, attacker)) { - // This does not happen anymore. Re-enable if you fix that. - if(IS_REAL_CLIENT(attacker)) - sprint(attacker, "\{1}Turret tells you: I'm on your team!\n"); - if(autocvar_g_friendlyfire) damage = damage * autocvar_g_friendlyfire; else return; } - self.health -= damage; + this.health -= damage; // thorw head slightly off aim when hit? - if (self.damage_flags & TFL_DMG_HEADSHAKE) + if (this.damage_flags & TFL_DMG_HEADSHAKE) { - self.tur_head.angles_x = self.tur_head.angles_x + (-0.5 + random()) * damage; - self.tur_head.angles_y = self.tur_head.angles_y + (-0.5 + random()) * damage; + this.tur_head.angles_x = this.tur_head.angles_x + (-0.5 + random()) * damage; + this.tur_head.angles_y = this.tur_head.angles_y + (-0.5 + random()) * damage; - self.SendFlags |= TNSF_ANG; + this.SendFlags |= TNSF_ANG; } - if (self.turret_flags & TUR_FLAG_MOVE) - self.velocity = self.velocity + vforce; + if (this.turret_flags & TUR_FLAG_MOVE) + this.velocity = this.velocity + vforce; - if (self.health <= 0) + if (this.health <= 0) { - self.event_damage = func_null; - self.tur_head.event_damage = func_null; - self.takedamage = DAMAGE_NO; - self.nextthink = time; - self.think = turret_die; + this.event_damage = func_null; + this.tur_head.event_damage = func_null; + this.takedamage = DAMAGE_NO; + this.nextthink = time; + setthink(this, turret_die); } - self.SendFlags |= TNSF_STATUS; + this.SendFlags |= TNSF_STATUS; } -void() turret_think; -void turret_respawn() +void turret_think(entity this); +void turret_respawn(entity this) { // Make sure all parts belong to the same team since // this function doubles as "teamchange" function. @@ -279,11 +272,12 @@ void turret_respawn() self.ammo = self.ammo_max; self.nextthink = time + self.ticrate; - self.think = turret_think; + setthink(self, turret_think); self.SendFlags = TNSF_FULL_UPDATE; - - TUR_ACTION(self.turretid, TR_SETUP); + + Turret tur = get_turretinfo(self.m_id); + tur.tr_setup(tur, self); } @@ -291,7 +285,7 @@ void turret_respawn() #define cvar_base "g_turrets_unit_" .float clientframe; void turrets_setframe(float _frame, float client_only) -{ +{SELFPARAM(); if((client_only ? self.clientframe : self.frame ) != _frame) { self.SendFlags |= TNSF_ANIM; @@ -305,14 +299,14 @@ void turrets_setframe(float _frame, float client_only) } -float turret_send(entity to, float sf) +bool turret_send(entity this, entity to, float sf) { - WriteByte(MSG_ENTITY, ENT_CLIENT_TURRET); + WriteHeader(MSG_ENTITY, ENT_CLIENT_TURRET); WriteByte(MSG_ENTITY, sf); if(sf & TNSF_SETUP) { - WriteByte(MSG_ENTITY, self.turretid); + WriteByte(MSG_ENTITY, self.m_id); WriteCoord(MSG_ENTITY, self.origin_x); WriteCoord(MSG_ENTITY, self.origin_y); @@ -363,11 +357,12 @@ float turret_send(entity to, float sf) WriteByte(MSG_ENTITY, ceil((self.health / self.max_health) * 255)); } - return TRUE; + return true; } -void load_unit_settings(entity ent, string unitname, float is_reload) -{ +void load_unit_settings(entity ent, bool is_reload) +{SELFPARAM(); + string unitname = ent.netname; string sbase; if (ent == world) @@ -426,43 +421,46 @@ void load_unit_settings(entity ent, string unitname, float is_reload) ent.track_accel_rotate = cvar(strcat(sbase,"_track_accel_rot")); ent.track_blendrate = cvar(strcat(sbase,"_track_blendrate")); - if(is_reload) - TUR_ACTION(self.turretid, TR_SETUP); + if(is_reload) { + Turret tur = get_turretinfo(self.m_id); + tur.tr_setup(tur, self); + } } -void turret_projectile_explode() +void turret_projectile_explode(entity this) { self.takedamage = DAMAGE_NO; self.event_damage = func_null; #ifdef TURRET_DEBUG float d; - d = RadiusDamage (self, self.owner, self.owner.shot_dmg, 0, self.owner.shot_radius, self, self.owner.shot_force, self.totalfrags, world); + d = RadiusDamage (self, self.owner, self.owner.shot_dmg, 0, self.owner.shot_radius, self, world, self.owner.shot_force, self.totalfrags, world); self.owner.tur_debug_dmg_t_h = self.owner.tur_debug_dmg_t_h + d; self.owner.tur_debug_dmg_t_f = self.owner.tur_debug_dmg_t_f + self.owner.shot_dmg; #else - RadiusDamage (self, self.realowner, self.owner.shot_dmg, 0, self.owner.shot_radius, self, self.owner.shot_force, self.totalfrags, world); + RadiusDamage (self, self.realowner, self.owner.shot_dmg, 0, self.owner.shot_radius, self, world, self.owner.shot_force, self.totalfrags, world); #endif remove(self); } -void turret_projectile_touch() +void turret_projectile_touch(entity this) { PROJECTILE_TOUCH; - turret_projectile_explode(); + turret_projectile_explode(this); } -void turret_projectile_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector vforce) +void turret_projectile_damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector vforce) { - self.velocity += vforce; - self.health -= damage; - //self.realowner = attacker; // Dont change realowner, it does not make much sense for turrets - if(self.health <= 0) - W_PrepareExplosionByDamage(self.owner, turret_projectile_explode); + this.velocity += vforce; + this.health -= damage; + //this.realowner = attacker; // Dont change realowner, it does not make much sense for turrets + if(this.health <= 0) + W_PrepareExplosionByDamage(this, this.owner, turret_projectile_explode); } -entity turret_projectile(string _snd, float _size, float _health, float _death, float _proj_type, float _cull, float _cli_anim) -{ +entity turret_projectile(Sound _snd, float _size, float _health, float _death, float _proj_type, float _cull, float _cli_anim) +{SELFPARAM(); + TC(Sound, _snd); entity proj; sound (self, CH_WEAPON_A, _snd, VOL_BASE, ATTEN_NORM); @@ -471,10 +469,10 @@ entity turret_projectile(string _snd, float _size, float _health, float _death, setsize(proj, '-0.5 -0.5 -0.5' * _size, '0.5 0.5 0.5' * _size); proj.owner = self; proj.realowner = self; - proj.bot_dodge = TRUE; + proj.bot_dodge = true; proj.bot_dodgerating = self.shot_dmg; - proj.think = turret_projectile_explode; - proj.touch = turret_projectile_touch; + setthink(proj, turret_projectile_explode); + settouch(proj, turret_projectile_touch); proj.nextthink = time + 9; proj.movetype = MOVETYPE_FLYMISSILE; proj.velocity = normalize(self.tur_shotdir_updated + randomvec() * self.shot_spread) * self.shot_speed; @@ -502,40 +500,32 @@ entity turret_projectile(string _snd, float _size, float _health, float _death, **/ void turret_do_updates(entity t_turret) { - vector enemy_pos; - entity oldself; - - oldself = self; - self = t_turret; + vector enemy_pos = real_origin(t_turret.enemy); - enemy_pos = real_origin(self.enemy); + WITHSELF(t_turret, turret_tag_fire_update()); - turret_tag_fire_update(); + t_turret.tur_shotdir_updated = v_forward; + t_turret.tur_dist_enemy = vlen(t_turret.tur_shotorg - enemy_pos); + t_turret.tur_dist_aimpos = vlen(t_turret.tur_shotorg - t_turret.tur_aimpos); - self.tur_shotdir_updated = v_forward; - self.tur_dist_enemy = vlen(self.tur_shotorg - enemy_pos); - self.tur_dist_aimpos = vlen(self.tur_shotorg - self.tur_aimpos); - - /*if((self.firecheck_flags & TFL_FIRECHECK_VERIFIED) && (self.enemy)) + /*if((t_turret.firecheck_flags & TFL_FIRECHECK_VERIFIED) && (t_turret.enemy)) { - oldpos = self.enemy.origin; - setorigin(self.enemy, self.tur_aimpos); - tracebox(self.tur_shotorg, '-1 -1 -1', '1 1 1', self.tur_shotorg + (self.tur_shotdir_updated * self.tur_dist_aimpos), MOVE_NORMAL,self); - setorigin(self.enemy, oldpos); + oldpos = t_turret.enemy.origin; + setorigin(t_turret.enemy, t_turret.tur_aimpos); + tracebox(t_turret.tur_shotorg, '-1 -1 -1', '1 1 1', t_turret.tur_shotorg + (t_turret.tur_shotdir_updated * t_turret.tur_dist_aimpos), MOVE_NORMAL,t_turret); + setorigin(t_turret.enemy, oldpos); - if(trace_ent == self.enemy) - self.tur_dist_impact_to_aimpos = 0; + if(trace_ent == t_turret.enemy) + t_turret.tur_dist_impact_to_aimpos = 0; else - self.tur_dist_impact_to_aimpos = vlen(trace_endpos - self.tur_aimpos); + t_turret.tur_dist_impact_to_aimpos = vlen(trace_endpos - t_turret.tur_aimpos); } else*/ - tracebox(self.tur_shotorg, '-1 -1 -1','1 1 1', self.tur_shotorg + (self.tur_shotdir_updated * self.tur_dist_aimpos), MOVE_NORMAL,self); - - self.tur_dist_impact_to_aimpos = vlen(trace_endpos - self.tur_aimpos) - (vlen(self.enemy.maxs - self.enemy.mins) * 0.5); - self.tur_impactent = trace_ent; - self.tur_impacttime = vlen(self.tur_shotorg - trace_endpos) / self.shot_speed; + tracebox(t_turret.tur_shotorg, '-1 -1 -1','1 1 1', t_turret.tur_shotorg + (t_turret.tur_shotdir_updated * t_turret.tur_dist_aimpos), MOVE_NORMAL,t_turret); - self = oldself; + t_turret.tur_dist_impact_to_aimpos = vlen(trace_endpos - t_turret.tur_aimpos) - (vlen(t_turret.enemy.maxs - t_turret.enemy.mins) * 0.5); + t_turret.tur_impactent = trace_ent; + t_turret.tur_impacttime = vlen(t_turret.tur_shotorg - trace_endpos) / t_turret.shot_speed; } /** @@ -544,7 +534,7 @@ void turret_do_updates(entity t_turret) **/ .float turret_framecounter; void turret_track() -{ +{SELFPARAM(); vector target_angle; // This is where we want to aim vector move_angle; // This is where we can aim float f_tmp; @@ -701,18 +691,20 @@ float turret_validate_target(entity e_turret, entity e_target, float validate_fl //if(!validate_flags & TFL_TARGETSELECT_NOBUILTIN) // return -0.5; + if(!e_target) + return -2; + if(e_target.owner == e_turret) return -0.5; if(!checkpvs(e_target.origin, e_turret)) return -1; - if(!e_target) - return -2; + if(e_target.alpha <= 0.3) + return -1; - if(g_onslaught) - if (substring(e_target.classname, 0, 10) == "onslaught_") // don't attack onslaught targets, that's the player's job! - return - 3; + if(MUTATOR_CALLHOOK(TurretValidateTarget, e_turret, e_target, validate_flags)) + return ret_float; if (validate_flags & TFL_TARGETSELECT_NO) return -4; @@ -722,14 +714,14 @@ float turret_validate_target(entity e_turret, entity e_target, float validate_fl return -5; // Cant touch this - if(e_target.vehicle_flags & VHF_ISVEHICLE) + if(IS_VEHICLE(e_target)) { if (e_target.vehicle_health <= 0) return -6; } else if (e_target.health <= 0) return -6; - else if(e_target.frozen > 0) + else if(STAT(FROZEN, e_target) > 0) return -6; // player @@ -738,7 +730,7 @@ float turret_validate_target(entity e_turret, entity e_target, float validate_fl if(!(validate_flags & TFL_TARGETSELECT_PLAYERS)) return -7; - if (e_target.deadflag != DEAD_NO) + if (IS_DEAD(e_target)) return -8; } @@ -819,7 +811,7 @@ float turret_validate_target(entity e_turret, entity e_target, float validate_fl traceline(e_turret.origin + '0 0 16', v_tmp, 0, e_turret); - if (e_turret.aim_firetolerance_dist < vlen(v_tmp - trace_endpos)) + if(vdist(v_tmp - trace_endpos, >, e_turret.aim_firetolerance_dist)) return -19; } @@ -832,14 +824,14 @@ float turret_validate_target(entity e_turret, entity e_target, float validate_fl */ #ifdef TURRET_DEBUG_TARGETSELECT - dprint("Target:",e_target.netname," is a valid target for ",e_turret.netname,"\n"); + LOG_TRACE("Target:",e_target.netname," is a valid target for ",e_turret.netname,"\n"); #endif return 1; } entity turret_select_target() -{ +{SELFPARAM(); entity e; // target looper entity float score; // target looper entity score entity e_enemy; // currently best scoreing target @@ -906,7 +898,7 @@ entity turret_select_target() ** Preforms pre-fire checks based on the uints firecheck_flags **/ float turret_firecheck() -{ +{SELFPARAM(); // This one just dont care =) if (self.firecheck_flags & TFL_FIRECHECK_NO) return 1; @@ -916,7 +908,7 @@ float turret_firecheck() // Ready? if (self.firecheck_flags & TFL_FIRECHECK_REFIRE) - if (self.attack_finished_single > time) return 0; + if (self.attack_finished_single[0] > time) return 0; // Special case: volly fire turret that has to fire a full volly if a shot was fired. if (self.shoot_flags & TFL_SHOOT_VOLLYALWAYS) @@ -926,7 +918,7 @@ float turret_firecheck() // Lack of zombies makes shooting dead things unnecessary :P if (self.firecheck_flags & TFL_FIRECHECK_DEAD) - if (self.enemy.deadflag != DEAD_NO) + if (IS_DEAD(self.enemy)) return 0; // Own ammo? @@ -979,14 +971,27 @@ float turret_firecheck() return 1; } +bool turret_checkfire() +{SELFPARAM(); + bool ret = false; // dummy + if(MUTATOR_CALLHOOK(Turret_CheckFire, ret)) + return ret_bool; + + return self.turret_firecheckfunc(); +} + void turret_fire() -{ +{SELFPARAM(); if (autocvar_g_turrets_nofire != 0) return; - - TUR_ACTION(self.turretid, TR_ATTACK); - self.attack_finished_single = time + self.shot_refire; + if(MUTATOR_CALLHOOK(TurretFire, self)) + return; + + Turret info = get_turretinfo(self.m_id); + info.tr_attack(info, self); + + self.attack_finished_single[0] = time + self.shot_refire; self.ammo -= self.shot_dmg; self.volly_counter = self.volly_counter - 1; @@ -998,7 +1003,7 @@ void turret_fire() self.enemy = world; if (self.shot_volly > 1) - self.attack_finished_single = time + self.shot_volly_refire; + self.attack_finished_single[0] = time + self.shot_volly_refire; } #ifdef TURRET_DEBUG @@ -1006,26 +1011,11 @@ void turret_fire() #endif } -void turret_think() +void turret_think(entity this) { - entity e; - self.nextthink = time + self.ticrate; - // ONS uses somewhat backwards linking. - if (teamplay) - { - if (g_onslaught) - if (self.target) - { - e = find(world, targetname,self.target); - if (e != world) - self.team = e.team; - } - - if (self.team != self.tur_head.team) - turret_respawn(); - } + MUTATOR_CALLHOOK(TurretThink, self); #ifdef TURRET_DEBUG if (self.tur_debug_tmr1 < time) @@ -1054,7 +1044,7 @@ void turret_think() if (self.shoot_flags & TFL_SHOOT_HITALLVALID) { // Do a self.turret_fire for every valid target. - e = findradius(self.origin,self.target_range); + entity e = findradius(self.origin,self.target_range); while (e) { if(e.takedamage) @@ -1065,7 +1055,7 @@ void turret_think() turret_do_updates(self); - if (self.turret_firecheckfunc()) + if (turret_checkfire()) turret_fire(); } } @@ -1089,7 +1079,7 @@ void turret_think() turret_do_updates(self); // Fire? - if (self.turret_firecheckfunc()) + if (turret_checkfire()) turret_fire(); } else @@ -1109,10 +1099,11 @@ void turret_think() turret_do_updates(self); // Fire! - if (self.turret_firecheckfunc() != 0) + if (turret_checkfire()) turret_fire(); - - TUR_ACTION(self.turretid, TR_THINK); + + Turret tur = get_turretinfo(self.m_id); + tur.tr_think(tur, self); return; } @@ -1149,8 +1140,9 @@ void turret_think() // Turn & pitch if(!(self.track_flags & TFL_TRACK_NO)) turret_track(); - - TUR_ACTION(self.turretid, TR_THINK); + + Turret tur = get_turretinfo(self.m_id); + tur.tr_think(tur, self); // And bail. return; @@ -1169,85 +1161,110 @@ void turret_think() turret_do_updates(self); // Fire? - if (self.turret_firecheckfunc()) + if (turret_checkfire()) turret_fire(); } - TUR_ACTION(self.turretid, TR_THINK); + Turret tur = get_turretinfo(self.m_id); + tur.tr_think(tur, self); } /* When .used a turret switch team to activator.team. If activator is world, the turret go inactive. */ -void turret_use() +void turret_use(entity this, entity actor, entity trigger) { - dprint("Turret ",self.netname, " used by ", activator.classname, "\n"); + LOG_TRACE("Turret ",this.netname, " used by ", actor.classname, "\n"); - self.team = activator.team; + this.team = actor.team; - if(self.team == 0) - self.active = ACTIVE_NOT; + if(this.team == 0) + this.active = ACTIVE_NOT; else - self.active = ACTIVE_ACTIVE; + this.active = ACTIVE_ACTIVE; } void turret_link() -{ - Net_LinkEntity(self, TRUE, 0, turret_send); - self.think = turret_think; +{SELFPARAM(); + Net_LinkEntity(self, true, 0, turret_send); + setthink(self, turret_think); self.nextthink = time; self.tur_head.effects = EF_NODRAW; } -void turrets_manager_think() +void turrets_manager_think(entity this) { - self.nextthink = time + 1; + this.nextthink = time + 1; - entity e; if (autocvar_g_turrets_reloadcvars == 1) { - e = nextent(world); - while (e) - { - if (e.turret_flags & TUR_FLAG_ISTURRET) - { - load_unit_settings(e,e.cvar_basename,1); - TUR_ACTION(self.turretid, TR_THINK); - } - - e = nextent(e); - } - cvar_set("g_turrets_reloadcvars","0"); + FOREACH_ENTITY(IS_TURRET(it), { + load_unit_settings(it, true); + Turret tur = get_turretinfo(it.m_id); + tur.tr_think(tur, it); + }); + cvar_set("g_turrets_reloadcvars", "0"); } } -float turret_initialize(float tur_id) +void turret_initparams(entity tur) { + #define TRY(x) (x) ? (x) + tur.respawntime = max (-1, (TRY(tur.respawntime) : 60 )); + tur.shot_refire = bound(0.01, (TRY(tur.shot_refire) : 1 ), 9999); + tur.shot_dmg = max (1, (TRY(tur.shot_dmg) : tur.shot_refire * 50 )); + tur.shot_radius = max (1, (TRY(tur.shot_radius) : tur.shot_dmg * 0.5 )); + tur.shot_speed = max (1, (TRY(tur.shot_speed) : 2500 )); + tur.shot_spread = bound(0.0001, (TRY(tur.shot_spread) : 0.0125 ), 500); + tur.shot_force = bound(0.001, (TRY(tur.shot_force) : tur.shot_dmg * 0.5 + tur.shot_radius * 0.5 ), 5000); + tur.shot_volly = bound(1, (TRY(tur.shot_volly) : 1 ), floor(tur.ammo_max / tur.shot_dmg)); + tur.shot_volly_refire = bound(tur.shot_refire, (TRY(tur.shot_volly_refire) : tur.shot_refire * tur.shot_volly ), 60); + tur.target_range = bound(0, (TRY(tur.target_range) : tur.shot_speed * 0.5 ), MAX_SHOT_DISTANCE); + tur.target_range_min = bound(0, (TRY(tur.target_range_min) : tur.shot_radius * 2 ), MAX_SHOT_DISTANCE); + tur.target_range_optimal = bound(0, (TRY(tur.target_range_optimal) : tur.target_range * 0.5 ), MAX_SHOT_DISTANCE); + tur.aim_maxrotate = bound(0, (TRY(tur.aim_maxrotate) : 90 ), 360); + tur.aim_maxpitch = bound(0, (TRY(tur.aim_maxpitch) : 20 ), 90); + tur.aim_speed = bound(0.1, (TRY(tur.aim_speed) : 36 ), 1000); + tur.aim_firetolerance_dist = bound(0.1, (TRY(tur.aim_firetolerance_dist) : 5 + (tur.shot_radius * 2) ), MAX_SHOT_DISTANCE); + tur.target_select_rangebias = bound(-10, (TRY(tur.target_select_rangebias) : 1 ), 10); + tur.target_select_samebias = bound(-10, (TRY(tur.target_select_samebias) : 1 ), 10); + tur.target_select_anglebias = bound(-10, (TRY(tur.target_select_anglebias) : 1 ), 10); + tur.target_select_missilebias = bound(-10, (TRY(tur.target_select_missilebias) : 1 ), 10); + tur.target_select_playerbias = bound(-10, (TRY(tur.target_select_playerbias) : 1 ), 10); + tur.ammo_max = max (tur.shot_dmg, (TRY(tur.ammo_max) : tur.shot_dmg * 10 )); + tur.ammo_recharge = max (0, (TRY(tur.ammo_recharge) : tur.shot_dmg * 0.5 )); + #undef TRY +} + +float turret_initialize(Turret tur) +{SELFPARAM(); if(!autocvar_g_turrets) - return FALSE; + return false; - entity e; - entity tur = get_turretinfo(tur_id); - if(tur.turretid == 0) - return FALSE; // invalid turret + if(tur.m_id == 0) + return false; // invalid turret + + // if tur_head exists, we can assume this turret re-spawned + if(!self.tur_head) { + tur.tr_precache(tur); + } - e = find(world, classname, "turret_manager"); + entity e = find(world, classname, "turret_manager"); if(!e) { - e = spawn(); - e.classname = "turret_manager"; - e.think = turrets_manager_think; + e = new(turret_manager); + setthink(e, turrets_manager_think); e.nextthink = time + 2; } if(!(self.spawnflags & TSF_SUSPENDED)) builtin_droptofloor(); - self.cvar_basename = tur.cvar_basename; - load_unit_settings(self, self.cvar_basename, 0); - + self.netname = tur.netname; + load_unit_settings(self, 0); + if(!self.team || !teamplay) { self.team = MAX_SHOT_DISTANCE; } if(!self.ticrate) { self.ticrate = ((self.turret_flags & TUR_FLAG_SUPPORT) ? 0.2 : 0.1); } if(!self.health) { self.health = 1000; } @@ -1262,72 +1279,50 @@ float turret_initialize(float tur_id) if(!self.target_select_flags) { self.target_select_flags = TFL_TARGETSELECT_LOS | TFL_TARGETSELECT_TEAMCHECK | TFL_TARGETSELECT_RANGELIMITS | TFL_TARGETSELECT_ANGLELIMITS; } if(!self.firecheck_flags) { self.firecheck_flags = TFL_FIRECHECK_DEAD | TFL_FIRECHECK_DISTANCES | TFL_FIRECHECK_LOS | TFL_FIRECHECK_AIMDIST | TFL_FIRECHECK_TEAMCHECK | TFL_FIRECHECK_AMMO_OWN | TFL_FIRECHECK_REFIRE; } - + if(self.track_type != TFL_TRACKTYPE_STEPMOTOR) { // Fluid / Ineria mode. Looks mutch nicer. // Can reduce aim preformance alot, needs a bit diffrent aimspeed - + self.aim_speed = bound(0.1, ((!self.aim_speed) ? 180 : self.aim_speed), 1000); - + if(!self.track_accel_pitch) { self.track_accel_pitch = 0.5; } if(!self.track_accel_rotate) { self.track_accel_rotate = 0.5; } if(!self.track_blendrate) { self.track_blendrate = 0.35; } } - - self.respawntime = max(-1, ((!self.respawntime) ? 60 : self.respawntime)); - self.shot_refire = bound(0.01, ((!self.shot_refire) ? 1 : self.shot_refire), 9999); - self.shot_dmg = max(1, ((!self.shot_dmg) ? self.shot_refire * 50 : self.shot_dmg)); - self.shot_radius = max(1, ((!self.shot_radius) ? self.shot_dmg * 0.5 : self.shot_radius)); - self.shot_speed = max(1, ((!self.shot_speed) ? 2500 : self.shot_speed)); - self.shot_spread = bound(0.0001, ((!self.shot_spread) ? 0.0125 : self.shot_spread), 500); - self.shot_force = bound(0.001, ((!self.shot_force) ? self.shot_dmg * 0.5 + self.shot_radius * 0.5 : self.shot_force), 5000); - self.shot_volly = bound(1, ((!self.shot_volly) ? 1 : self.shot_volly), floor(self.ammo_max / self.shot_dmg)); - self.shot_volly_refire = bound(self.shot_refire, ((!self.shot_volly_refire) ? self.shot_refire * self.shot_volly : self.shot_volly_refire), 60); - self.target_range = bound(0, ((!self.target_range) ? self.shot_speed * 0.5 : self.target_range), MAX_SHOT_DISTANCE); - self.target_range_min = bound(0, ((!self.target_range_min) ? self.shot_radius * 2 : self.target_range_min), MAX_SHOT_DISTANCE); - self.target_range_optimal = bound(0, ((!self.target_range_optimal) ? self.target_range * 0.5 : self.target_range_optimal), MAX_SHOT_DISTANCE); - self.aim_maxrotate = bound(0, ((!self.aim_maxrotate) ? 90 : self.aim_maxrotate), 360); - self.aim_maxpitch = bound(0, ((!self.aim_maxpitch) ? 20 : self.aim_maxpitch), 90); - self.aim_speed = bound(0.1, ((!self.aim_speed) ? 36 : self.aim_speed), 1000); - self.aim_firetolerance_dist = bound(0.1, ((!self.aim_firetolerance_dist) ? 5 + (self.shot_radius * 2) : self.aim_firetolerance_dist), MAX_SHOT_DISTANCE); - self.target_select_rangebias = bound(-10, ((!self.target_select_rangebias) ? 1 : self.target_select_rangebias), 10); - self.target_select_samebias = bound(-10, ((!self.target_select_samebias) ? 1 : self.target_select_samebias), 10); - self.target_select_anglebias = bound(-10, ((!self.target_select_anglebias) ? 1 : self.target_select_anglebias), 10); - self.target_select_missilebias = bound(-10, ((!self.target_select_missilebias) ? 1 : self.target_select_missilebias), 10); - self.target_select_playerbias = bound(-10, ((!self.target_select_playerbias) ? 1 : self.target_select_playerbias), 10); - self.ammo_max = max(self.shot_dmg, ((!self.ammo_max) ? self.shot_dmg * 10 : self.ammo_max)); - self.ammo_recharge = max(0, ((!self.ammo_recharge) ? self.shot_dmg * 0.5 : self.ammo_recharge)); - + + turret_initparams(self); + self.turret_flags = TUR_FLAG_ISTURRET | (tur.spawnflags); - + if(self.turret_flags & TUR_FLAG_SPLASH) self.aim_flags |= TFL_AIM_SPLASH; - + if(self.turret_flags & TUR_FLAG_MISSILE) self.target_select_flags |= TFL_TARGETSELECT_MISSILES; if(self.turret_flags & TUR_FLAG_PLAYER) self.target_select_flags |= TFL_TARGETSELECT_PLAYERS; - + if(self.spawnflags & TSL_NO_RESPAWN) self.damage_flags |= TFL_DMG_DEATH_NORESPAWN; - + if (self.turret_flags & TUR_FLAG_SUPPORT) self.turret_score_target = turret_targetscore_support; else self.turret_score_target = turret_targetscore_generic; - + ++turret_count; - - setmodel(self, tur.model); + + _setmodel(self, tur.model); setsize(self, tur.mins, tur.maxs); - - self.turretid = tur_id; + + self.m_id = tur.m_id; self.classname = "turret_main"; self.active = ACTIVE_ACTIVE; self.effects = EF_NODRAW; - self.netname = TUR_NAME(tur_id); + self.netname = tur.turret_name; self.ticrate = bound(sys_frametime, self.ticrate, 60); self.max_health = self.health; self.target_validate_flags = self.target_select_flags; @@ -1340,23 +1335,23 @@ float turret_initialize(float tur_id) self.turret_firecheckfunc = turret_firecheck; self.event_damage = turret_damage; self.use = turret_use; - self.bot_attack = TRUE; + self.bot_attack = true; self.nextthink = time + 1; self.nextthink += turret_count * sys_frametime; - - self.tur_head = spawn(); - setmodel(self.tur_head, tur.head_model); + + self.tur_head = new(turret_head); + _setmodel(self.tur_head, tur.head_model); setsize(self.tur_head, '0 0 0', '0 0 0'); setorigin(self.tur_head, '0 0 0'); setattachment(self.tur_head, self, "tag_head"); - - self.tur_head.netname = self.tur_head.classname = "turret_head"; + + self.tur_head.netname = self.tur_head.classname; self.tur_head.team = self.team; self.tur_head.owner = self; self.tur_head.takedamage = DAMAGE_NO; self.tur_head.solid = SOLID_NOT; self.tur_head.movetype = self.movetype; - + if(!self.tur_defend) if(self.target != "") { @@ -1364,18 +1359,18 @@ float turret_initialize(float tur_id) if (self.tur_defend == world) { self.target = ""; - dprint("Turret has invalid defendpoint!\n"); + LOG_TRACE("Turret has invalid defendpoint!\n"); } } - + if (self.tur_defend) self.idle_aim = self.tur_head.angles + angleofs(self.tur_head, self.tur_defend); else self.idle_aim = '0 0 0'; - + #ifdef TURRET_DEBUG self.tur_debug_start = self.nextthink; - while (vlen(self.tur_debug_rvec) < 2) + while(vdist(self.tur_debug_rvec, <, 2)) self.tur_debug_rvec = randomvec() * 4; self.tur_debug_rvec_x = fabs(self.tur_debug_rvec_x); @@ -1384,13 +1379,14 @@ float turret_initialize(float tur_id) #endif turret_link(); - turret_respawn(); + turret_respawn(self); turret_tag_fire_update(); - - TUR_ACTION(tur_id, TR_SETUP); - - if(MUTATOR_CALLHOOK(TurretSpawn)) - return FALSE; - return TRUE; + tur.tr_setup(tur, self); + + if(MUTATOR_CALLHOOK(TurretSpawn, self)) + return false; + + return true; } +#endif