X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fxonotic-data.pk3dir.git;a=blobdiff_plain;f=qcsrc%2Fcommon%2Fturrets%2Fsv_turrets.qc;h=66b3f3dbb61d864a744a620845d809db1b32e0dc;hp=9c02d7ad91ec28f57adbb5ecf96ebd1472b326cb;hb=cf1edea8694548556934b5b05f526bc192f576cb;hpb=fa9b4da73e5a48423237dfc709700fc0a206f024 diff --git a/qcsrc/common/turrets/sv_turrets.qc b/qcsrc/common/turrets/sv_turrets.qc index 9c02d7ad9..66b3f3dbb 100644 --- a/qcsrc/common/turrets/sv_turrets.qc +++ b/qcsrc/common/turrets/sv_turrets.qc @@ -1,5 +1,5 @@ #ifdef SVQC -#include "../../server/autocvars.qh" +#include // Generic aiming vector turret_aim_generic() @@ -13,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); @@ -31,7 +31,7 @@ vector turret_aim_generic() 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; @@ -119,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; @@ -164,15 +164,15 @@ float turret_targetscore_generic(entity _turret, entity _target) } // Generic damage handling -void turret_hide() -{SELFPARAM(); +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() -{SELFPARAM(); +void turret_die(entity this) +{ self.deadflag = DEAD_DEAD; self.tur_head.deadflag = self.deadflag; @@ -188,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); @@ -200,23 +201,23 @@ 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, int deathtype, vector hitloc, vector vforce) -{SELFPARAM(); +void turret_damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector vforce) +{ // Enough already! - if(self.deadflag == DEAD_DEAD) + if(this.deadflag == DEAD_DEAD) return; // Inactive turrets take no damage. (hm..) - if(!self.active) + if(!this.active) return; - if(SAME_TEAM(self, attacker)) + if(SAME_TEAM(this, attacker)) { if(autocvar_g_friendlyfire) damage = damage * autocvar_g_friendlyfire; @@ -224,35 +225,35 @@ void turret_damage (entity inflictor, entity attacker, float damage, int deathty 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() -{SELFPARAM(); +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. self.tur_head.team = self.team; @@ -271,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); } @@ -297,14 +299,14 @@ void turrets_setframe(float _frame, float client_only) } -float turret_send(entity to, float sf) -{SELFPARAM(); +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); @@ -358,8 +360,9 @@ float turret_send(entity to, float sf) 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) @@ -418,12 +421,14 @@ 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() -{SELFPARAM(); +void turret_projectile_explode(entity this) +{ self.takedamage = DAMAGE_NO; self.event_damage = func_null; @@ -438,23 +443,24 @@ void turret_projectile_explode() 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, int deathtype, vector hitloc, vector vforce) -{SELFPARAM(); - 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); +void turret_projectile_damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector vforce) +{ + 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); @@ -465,8 +471,8 @@ entity turret_projectile(string _snd, float _size, float _health, float _death, proj.realowner = self; 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; @@ -493,39 +499,33 @@ entity turret_projectile(string _snd, float _size, float _health, float _death, ** and updated aim<->predict impact distance. **/ void turret_do_updates(entity t_turret) -{SELFPARAM(); - vector enemy_pos; - - setself(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); - setself(this); + 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; } /** @@ -703,9 +703,8 @@ float turret_validate_target(entity e_turret, entity e_target, float validate_fl 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,7 +721,7 @@ float turret_validate_target(entity e_turret, entity e_target, float validate_fl } else if (e_target.health <= 0) return -6; - else if(e_target.frozen > 0) + else if(STAT(FROZEN, e_target) > 0) return -6; // player @@ -731,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; } @@ -812,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; } @@ -909,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) @@ -919,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? @@ -989,9 +988,10 @@ void turret_fire() if(MUTATOR_CALLHOOK(TurretFire, self)) return; - TUR_ACTION(self.turretid, TR_ATTACK); + Turret info = get_turretinfo(self.m_id); + info.tr_attack(info, self); - self.attack_finished_single = time + self.shot_refire; + self.attack_finished_single[0] = time + self.shot_refire; self.ammo -= self.shot_dmg; self.volly_counter = self.volly_counter - 1; @@ -1003,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 @@ -1011,26 +1011,11 @@ void turret_fire() #endif } -void turret_think() -{SELFPARAM(); - entity e; - +void turret_think(entity this) +{ 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) @@ -1059,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) @@ -1117,7 +1102,8 @@ void turret_think() if (turret_checkfire()) turret_fire(); - TUR_ACTION(self.turretid, TR_THINK); + Turret tur = get_turretinfo(self.m_id); + tur.tr_think(tur, self); return; } @@ -1155,7 +1141,8 @@ void turret_think() 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; @@ -1178,82 +1165,105 @@ void turret_think() 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() -{SELFPARAM(); - LOG_TRACE("Turret ",self.netname, " used by ", activator.classname, "\n"); +void turret_use(entity this, entity actor, entity trigger) +{ + 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() {SELFPARAM(); Net_LinkEntity(self, true, 0, turret_send); - self.think = turret_think; + setthink(self, turret_think); self.nextthink = time; self.tur_head.effects = EF_NODRAW; } -void turrets_manager_think() -{SELFPARAM(); - self.nextthink = time + 1; +void turrets_manager_think(entity this) +{ + this.nextthink = time + 1; - entity e; if (autocvar_g_turrets_reloadcvars == 1) { - e = nextent(world); - while (e) - { - if (IS_TURRET(e)) - { - 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; - entity e; - entity tur = get_turretinfo(tur_id); - if(tur.turretid == 0) + if(tur.m_id == 0) return false; // invalid turret - if(!self.tur_head) { TUR_ACTION(tur_id, TR_PRECACHE); } // if tur_head exists, we can assume this turret re-spawned + // 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); } @@ -1282,29 +1292,7 @@ float turret_initialize(float tur_id) 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); @@ -1330,11 +1318,11 @@ float turret_initialize(float tur_id) _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; @@ -1351,13 +1339,13 @@ float turret_initialize(float tur_id) self.nextthink = time + 1; self.nextthink += turret_count * sys_frametime; - self.tur_head = spawn(); + 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; @@ -1382,7 +1370,7 @@ float turret_initialize(float tur_id) #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); @@ -1391,10 +1379,10 @@ float turret_initialize(float tur_id) #endif turret_link(); - turret_respawn(); + turret_respawn(self); turret_tag_fire_update(); - TUR_ACTION(tur_id, TR_SETUP); + tur.tr_setup(tur, self); if(MUTATOR_CALLHOOK(TurretSpawn, self)) return false;