home *** CD-ROM | disk | FTP | other *** search
/ Quaker's Paradise / Quakers_Paradise.iso / div / godelqc / godel.qc < prev    next >
Encoding:
Text File  |  1997-06-20  |  27.6 KB  |  951 lines
  1. .float grenadetimer;
  2. .float numholo;//init
  3. .float nextregen;
  4.  
  5. entity newclient;
  6.  
  7. //prototypes
  8. float() crandom;
  9. void() GrenadeExplode;
  10. void() BecomeExplosion;
  11. void(string gibname,float dmg) ThrowGib;
  12. void(string gibname,float dmg) ThrowHead;
  13. void(vector p1, vector p2, entity from, float damage) LightningDamage;
  14. void() zombie_stand1;
  15. void() zombie_walk1;
  16. void() zombie_run1;
  17. void(entity attacker,float take) zombie_pain;
  18. void() zombie_paine1;
  19. void() zombie_die;
  20. void() zombie_missile;
  21. void() walkmonster_start_go;
  22.  
  23. //Make Thrown Ammo,Backpack,Gun pick uppable.   
  24. void() SUB_MakePickup = {
  25.     self.flags=FL_ITEM;
  26.     self.solid=SOLID_TRIGGER;
  27.     self.nextthink=time+600;
  28.     self.think=SUB_Remove;
  29. };
  30.  
  31. //Gib a Body into pieces after a while.
  32. void() SUB_Gib = {
  33.     ThrowGib("progs/gib1.mdl",10);
  34.     ThrowGib("progs/gib1.mdl",10);
  35.     ThrowGib("progs/gib2.mdl",10);
  36.     ThrowGib("progs/gib3.mdl",10);
  37.     ThrowHead("progs/h_player.mdl",10);
  38. };
  39.  
  40. //Used to toss a weapon, ammo, or armor.
  41. void(float ax) TossBackpack =
  42. {
  43.     local entity    item;
  44.     if (self.flags & FL_OBSERVER) return;
  45.     if (self.impulse==55) ax=0;
  46.     else if (self.impulse==56) ax=1;
  47.     else if (self.impulse==57) ax=32;
  48.     if (ax==0) {
  49.         if (self.weapon==IT_SUPER_SHOTGUN) ax=3;
  50.         if (self.weapon==IT_NAILGUN) ax=4;
  51.         if (self.weapon==IT_SUPER_NAILGUN) ax=5;
  52.         if (self.weapon==IT_GRENADE_LAUNCHER) ax=6;
  53.         if (self.weapon==IT_ROCKET_LAUNCHER) ax=7;
  54.         if (self.weapon==IT_LIGHTNING) ax=8;
  55.     }
  56.     if (ax==1) {
  57.         if (self.weapon==IT_SHOTGUN) ax=16;
  58.         if (self.weapon==IT_SUPER_SHOTGUN) ax=16;
  59.         if (self.weapon==IT_NAILGUN) ax=17;
  60.         if (self.weapon==IT_SUPER_NAILGUN) ax=17;
  61.         if (self.weapon==IT_GRENADE_LAUNCHER) ax=18;
  62.         if (self.weapon==IT_ROCKET_LAUNCHER) ax=18;
  63.         if (self.weapon==IT_LIGHTNING) ax=19;
  64.     }
  65.     if (ax==2) {
  66.         if (!(self.ammo_shells+self.ammo_nails+self.ammo_rockets+self.ammo_cells))
  67.             return;    // nothing in it
  68.         item = spawn();
  69.         item.owner = self;
  70.         item.items = 0;
  71.         setmodel (item, "progs/backpack.mdl");
  72.         setsize (item, '-16 -16 0', '16 16 56');
  73.         item.touch = BackpackTouch;
  74.         item.ammo_shells = self.ammo_shells;
  75.         item.ammo_nails = self.ammo_nails;
  76.         item.ammo_rockets = self.ammo_rockets;
  77.         item.ammo_cells = self.ammo_cells;
  78.         item.classname="backpack";
  79.         self.ammo_shells = 0;
  80.         self.ammo_nails = 0;
  81.         self.ammo_rockets = 0;
  82.         self.ammo_cells = 0;    
  83.     } else if (ax==3) {
  84.         if (!(self.items & IT_SUPER_SHOTGUN)) return;
  85.         item = spawn();
  86.         item.owner = self;
  87.         item.items = IT_SUPER_SHOTGUN;
  88.         self.items = self.items - IT_SUPER_SHOTGUN;
  89.         if (self.weapon==IT_SUPER_SHOTGUN) self.weapon=W_BestWeapon();
  90.         setmodel (item, "progs/g_shot.mdl");
  91.         setsize (item, '-16 -16 0', '16 16 56');
  92.         item.touch = BackpackTouch;
  93.         if (self.ammo_shells < 10)
  94.         item.ammo_shells = self.ammo_shells;
  95.         else    item.ammo_shells = 10;
  96.         self.ammo_shells=self.ammo_shells-item.ammo_shells;
  97.         item.classname="weapon_supershotgun";
  98.     } else if (ax==4) {
  99.         if (!(self.items & IT_NAILGUN)) return;
  100.         item = spawn();
  101.         item.owner = self;
  102.         item.items = IT_NAILGUN;
  103.         self.items = self.items - IT_NAILGUN;
  104.         if (self.weapon==IT_NAILGUN) self.weapon=W_BestWeapon();
  105.         setmodel (item, "progs/g_nail.mdl");
  106.         setsize (item, '-16 -16 0', '16 16 56');
  107.         item.touch = BackpackTouch;
  108.         if (self.ammo_nails < 20)
  109.             item.ammo_nails = self.ammo_nails;
  110.         else    item.ammo_nails = 20;
  111.         self.ammo_nails=self.ammo_nails-item.ammo_nails;
  112.         item.classname="weapon_nailgun";
  113.     } else if (ax==5) {
  114.         if (!(self.items & IT_SUPER_NAILGUN)) return;
  115.         item = spawn();
  116.         item.owner = self;
  117.         item.items = IT_SUPER_NAILGUN;
  118.         self.items = self.items - IT_SUPER_NAILGUN;
  119.         if (self.weapon==IT_SUPER_NAILGUN) self.weapon=W_BestWeapon();
  120.         setmodel (item, "progs/g_nail2.mdl");
  121.         setsize (item, '-16 -16 0', '16 16 56');
  122.         item.touch = BackpackTouch;
  123.         if (self.ammo_nails < 20) item.ammo_nails = self.ammo_nails;
  124.         else    item.ammo_nails = 20;
  125.         self.ammo_nails=self.ammo_nails-item.ammo_nails;
  126.         item.classname="weapon_supernailgun";
  127.     } else if (ax==6) {
  128.         if (!(self.items & IT_GRENADE_LAUNCHER)) return;
  129.         item = spawn();
  130.         item.owner = self;
  131.         item.items = IT_GRENADE_LAUNCHER;
  132.         self.items = self.items - IT_GRENADE_LAUNCHER;
  133.         if (self.weapon==IT_GRENADE_LAUNCHER) self.weapon=W_BestWeapon();
  134.         setmodel (item, "progs/g_rock.mdl");
  135.         setsize (item, '-16 -16 0', '16 16 56');
  136.         item.touch = BackpackTouch;
  137.         if (self.ammo_rockets < 10) item.ammo_rockets = self.ammo_rockets;
  138.         else    item.ammo_rockets = 10;
  139.         self.ammo_rockets=self.ammo_rockets-item.ammo_rockets;
  140.         item.classname="weapon_grenadelauncher";
  141.     } else if (ax==7) {
  142.         if (!(self.items & IT_ROCKET_LAUNCHER)) return;
  143.         item = spawn();
  144.         item.owner = self;
  145.         item.items = IT_ROCKET_LAUNCHER;
  146.         self.items = self.items - IT_ROCKET_LAUNCHER;
  147.         if (self.weapon==IT_ROCKET_LAUNCHER) self.weapon=W_BestWeapon();
  148.         setmodel (item, "progs/g_rock2.mdl");
  149.         setsize (item, '-16 -16 0', '16 16 56');
  150.         item.touch = BackpackTouch;
  151.         if (self.ammo_rockets < 10) item.ammo_rockets = self.ammo_rockets;
  152.         else    item.ammo_rockets = 10;
  153.         self.ammo_rockets=self.ammo_rockets-item.ammo_rockets;
  154.         item.classname="weapon_rocketlauncher";
  155.     } else if (ax==8) {
  156.         if (!(self.items & IT_LIGHTNING)) return;
  157.         item = spawn();
  158.         item.owner = self;
  159.         item.items = IT_LIGHTNING;
  160.         self.items = self.items - IT_LIGHTNING;
  161.         if (self.weapon==IT_LIGHTNING) self.weapon=W_BestWeapon();
  162.         setmodel (item, "progs/g_light.mdl");
  163.         setsize (item, '-16 -16 0', '16 16 56');
  164.         item.touch = BackpackTouch;
  165.         if (self.ammo_cells < 10) item.ammo_cells = self.ammo_cells;
  166.         else    item.ammo_cells = 10;
  167.         self.ammo_cells=self.ammo_cells-item.ammo_cells;
  168.         item.classname="weapon_lightning";
  169.     } else if (ax==16) {
  170.         //shells
  171.         if (self.ammo_shells==0) return;
  172.         item = spawn();
  173.         if (self.ammo_shells < 10) item.ammo_shells = self.ammo_shells;
  174.         else    item.ammo_shells = 10;
  175.         item.owner = self;
  176.         self.ammo_shells=self.ammo_shells-item.ammo_shells;
  177.         setmodel (item, "maps/b_shell1.bsp");
  178.         setsize (item, '-16 -16 0', '16 16 56');
  179.         item.touch = BackpackTouch;
  180.         item.classname = "ammo_shells";
  181.     } else if (ax==17) {
  182.         //nails
  183.         if (self.ammo_nails==0) return;
  184.         item = spawn();
  185.         if (self.ammo_nails < 20) item.ammo_nails = self.ammo_nails;
  186.         else    item.ammo_nails = 20;
  187.         item.owner = self;
  188.         self.ammo_nails=self.ammo_nails-item.ammo_nails;
  189.         setmodel (item, "maps/b_nail1.bsp");
  190.         setsize (item, '-16 -16 0', '16 16 56');
  191.         item.touch = BackpackTouch;
  192.         item.classname = "ammo_nails";
  193.     } else if (ax==18) {
  194.         //rockets
  195.         if (self.ammo_rockets==0) return;
  196.         item = spawn();
  197.         if (self.ammo_rockets < 10) item.ammo_rockets=self.ammo_rockets;
  198.         else    item.ammo_rockets = 10;
  199.         item.owner = self;
  200.         self.ammo_rockets=self.ammo_rockets-item.ammo_rockets;
  201.         setmodel (item, "maps/b_rock1.bsp");
  202.         setsize (item, '-16 -16 0', '16 16 56');
  203.         item.touch = BackpackTouch;
  204.         item.classname = "ammo_rockets";
  205.     } else if (ax==19) {
  206.         //cells
  207.         if (self.ammo_cells==0) return;
  208.         item = spawn();
  209.         if (self.ammo_cells < 10) item.ammo_cells = self.ammo_cells;
  210.         else    item.ammo_cells = 10;
  211.         item.owner = self;
  212.         self.ammo_cells=self.ammo_cells-item.ammo_cells;
  213.         setmodel (item, "maps/b_batt1.bsp");
  214.         setsize (item, '-16 -16 0', '16 16 56');
  215.         item.touch = BackpackTouch;
  216.         item.classname = "ammo_cells";
  217.     } else if (ax==32) {
  218.         if (self.armorvalue<1) return;
  219.         sound (self, CHAN_WEAPON, "weapons/grenade.wav", 1, ATTN_NORM);
  220.         item = spawn();
  221.         item.owner = self;
  222.         item.armortype=self.armortype;
  223.         item.armorvalue=self.armorvalue;
  224.         self.armortype=0;
  225.         self.armorvalue=0;
  226.         setmodel (item, "progs/armor.mdl");
  227.         if (item.armortype==0.3) {
  228.             item.skin=0;
  229.             self.items=self.items-IT_ARMOR1;
  230.             item.items=IT_ARMOR1;
  231.             item.classname="item_armor1";
  232.         } else if (item.armortype==0.6) {
  233.             item.skin=1;
  234.             self.items=self.items-IT_ARMOR2;
  235.             item.items=IT_ARMOR2;
  236.             item.classname="item_armor2";
  237.         } else if (item.armortype==0.8) {
  238.             item.skin=2;
  239.             self.items=self.items-IT_ARMOR3;
  240.             item.items=IT_ARMOR3;
  241.             item.classname="item_armorInv";
  242.         }
  243.         setsize (item, '-16 -16 0', '16 16 56');
  244.         item.touch = armor_touch;
  245.     } else return;
  246.     sound (self, CHAN_WEAPON, "weapons/grenade.wav", 1, ATTN_NORM);
  247.     W_SetCurrentAmmo();    //Draw new weapon on screen (in hand)
  248. // set missile speed    
  249.     makevectors (self.v_angle);
  250.     if (self.v_angle_x)
  251.         item.velocity = v_forward*600 + v_up * 200 +
  252.         crandom()*v_right*10 + crandom()*v_up*10;
  253.     else
  254.     {
  255.         item.velocity = aim(self, 10000);
  256.         item.velocity = item.velocity * 600;
  257.     }
  258.     item.origin = self.origin + (item.velocity * 0.0); 
  259.     item.movetype = MOVETYPE_TOSS;
  260. //    so people cant pick it up immediately
  261.     item.nextthink = time + 0.25;
  262.     item.think = SUB_MakePickup;
  263. };
  264.  
  265. //Detonate all pipebombs
  266. void() DetPipeBombs =
  267. {
  268.         local entity    head;
  269.  
  270.         head = find (world,classname,"pipebomb");
  271.         while(head)
  272.         {
  273.                 if(head.owner == self)
  274.                         head.nextthink = time;
  275.             head = find (head,classname,"pipebomb");
  276.         }
  277. };
  278.  
  279. void() PipeBombTouch =
  280. {
  281.     if (other == self.owner)
  282.         return;        // don't explode on owner
  283.     sound (self, CHAN_WEAPON, "weapons/bounce.wav", 1, ATTN_NORM);    // bounce sound
  284.     if (self.velocity == '0 0 0')
  285.         self.avelocity = '0 0 0';
  286. };
  287.  
  288. void() W_FirePipeBomb =
  289. {
  290.     local    entity missile, mpuff;
  291.     if(self.ammo_rockets < 1)    // have to have ammo
  292.       return;
  293.     self.currentammo = self.ammo_rockets = self.ammo_rockets - 1;
  294.     self.punchangle_x=-2;
  295.     missile = spawn ();
  296.     missile.owner = self;
  297.     missile.movetype = MOVETYPE_BOUNCE;
  298.     missile.solid = SOLID_BBOX;
  299.     missile.classname = "pipebomb";
  300.     makevectors (self.v_angle);
  301.     if (self.v_angle_x) missile.velocity = 
  302.     v_forward*600 + v_up * 200 + crandom()*v_right*10 + crandom()*v_up*10;
  303.     else {
  304.         missile.velocity = aim(self, 10000);
  305.         missile.velocity = missile.velocity * 600;
  306.         missile.velocity_z = 200;
  307.     }
  308.     missile.avelocity = '300 300 300';
  309.     missile.angles = vectoangles(missile.velocity);
  310.     missile.touch = PipeBombTouch;
  311.     missile.think = GrenadeExplode;
  312.     setmodel (missile, "progs/grenade.mdl");
  313.     setsize (missile, '0 0 0', '0 0 0');        
  314.     setorigin (missile, self.origin);
  315.     //pipe bombs explode after 5 mins by default
  316.     missile.nextthink=time+300;
  317. };
  318. // end pipebombs
  319.  
  320.  
  321. entity() LightFindTarget = {  //this routine based on function by VHOLD
  322.     local entity head, selected;
  323.     local float dist;
  324.     dist = 100000;
  325.     selected = world;
  326.     head = findradius(self.origin, 100000);
  327.     while(head) { 
  328.         if ((((coop) && (head.classname != "player")) || (!coop)) &&
  329.              (((teamplay==1 || teamplay==2 || teamplay==7) &&
  330.              (head.team != self.owner.team)) || (teamplay!=1 || teamplay!=7)) && 
  331.              ((head.health > 1) && (head != self) && (head != self.owner)) &&
  332.              (!(head.items & IT_INVISIBILITY ))) {
  333.             traceline(self.origin,head.origin,TRUE,self);
  334.             if ((trace_fraction==1) && (vlen(head.origin-self.origin) < dist)) {
  335.             selected = head;
  336.             dist = vlen(head.origin - self.origin);
  337.             }
  338.         }    
  339.         head = head.chain;
  340.     }
  341.     return selected;
  342. };
  343.  
  344. void(vector p1, vector p2, entity from, float damage) LightningStun =
  345. {
  346.     local entity            e1, e2;
  347.     local vector            f;
  348.  
  349.     f = p2 - p1;
  350.     normalize (f);
  351.     f_x = 0 - f_y;
  352.     f_y = f_x;
  353.     f_z = 0;
  354.     f = f*16;
  355.  
  356.     e1 = e2 = world;
  357.  
  358.     traceline (p1, p2, FALSE, self);
  359.     if (trace_ent.takedamage)
  360.     {
  361.         particle (trace_endpos, '0 0 100', 225, damage*4);
  362.         if (trace_ent.th_pain) {
  363.             trace_ent.th_pain (trace_ent,damage);
  364.         // nightmare mode monsters don't go into pain frames often
  365.             if (skill == 3) trace_ent.pain_finished = time + 5;          
  366.         }
  367.         if (self.classname == "player")
  368.         {
  369.             if (other.classname == "player")
  370.                 trace_ent.velocity_z = trace_ent.velocity_z + 400;
  371.         }
  372.     }
  373.     e1 = trace_ent;
  374.  
  375.     traceline (p1 + f, p2 + f, FALSE, self);
  376.     if (trace_ent != e1 && trace_ent.takedamage)
  377.     {
  378.         particle (trace_endpos, '0 0 100', 225, damage*4);
  379.         if (trace_ent.th_pain) {
  380.             trace_ent.th_pain (trace_ent,damage);
  381.         // nightmare mode monsters don't go into pain frames often
  382.             if (skill == 3) trace_ent.pain_finished = time + 5;          
  383.         }
  384.     }
  385.     e2 = trace_ent;
  386.  
  387.     traceline (p1 - f, p2 - f, FALSE, self);
  388.     if (trace_ent != e1 && trace_ent != e2 && trace_ent.takedamage)
  389.     {
  390.         particle (trace_endpos, '0 0 100', 225, damage*4);
  391.         if (trace_ent.th_pain) {
  392.             trace_ent.th_pain (trace_ent,damage);
  393.         // nightmare mode monsters don't go into pain frames often
  394.             if (skill == 3) trace_ent.pain_finished = time + 5;          
  395.         }
  396.     }
  397. };
  398.  
  399. void() CastMinionLightning =
  400. {
  401.     local    vector    org, dir;
  402.     
  403.     self.effects = self.effects | EF_MUZZLEFLASH;
  404.  
  405.     ai_face ();
  406.  
  407.     org=self.origin;
  408.  
  409.     dir = self.enemy.origin + '0 0 16' - org;
  410.     dir = normalize (dir);
  411.  
  412.     traceline (org, self.origin + dir*600, TRUE, self);
  413.  
  414.     WriteByte (MSG_BROADCAST, SVC_TEMPENTITY);
  415.     WriteByte (MSG_BROADCAST, TE_LIGHTNING1);
  416.     WriteEntity (MSG_BROADCAST, self);
  417.     WriteCoord (MSG_BROADCAST, org_x);
  418.     WriteCoord (MSG_BROADCAST, org_y);
  419.     WriteCoord (MSG_BROADCAST, org_z);
  420.     WriteCoord (MSG_BROADCAST, trace_endpos_x);
  421.     WriteCoord (MSG_BROADCAST, trace_endpos_y);
  422.     WriteCoord (MSG_BROADCAST, trace_endpos_z);
  423.     LightningStun (org, trace_endpos, self.owner, 40);
  424. };
  425.  
  426. //Minion AI
  427. void() MinionThink = {
  428.     local vector dir, vtemp;
  429.     local string s;
  430.     if ((self.owner.flags & FL_HASMINION)==0) {
  431.         remove(self);
  432.         return;    
  433.     }
  434.     self.enemy = self.owner;
  435.     if (self.enemy != world) {
  436.     vtemp = self.enemy.origin + '0 0 10';
  437.        dir = normalize(vtemp - self.origin + '0 0 25');
  438.        self.velocity = dir * 200;
  439.         self.angles = vectoangles(self.velocity);
  440.     }
  441.     self.enemy=LightFindTarget();
  442.     if (self.enemy) {
  443.      if (self.ammo_cells > 1) {
  444.     self.currentammo = self.ammo_cells =self.ammo_cells - 1; 
  445.     CastMinionLightning();
  446.     sound (self, CHAN_AUTO, "weapons/lstart.wav", 1, ATTN_NORM);
  447.      } else { 
  448.     self.owner.flags = self.owner.flags - (FL_HASMINION & self.owner.flags); 
  449.     remove(self);
  450.     return;
  451.     }
  452.     }
  453.     self.nextthink = time + 1;
  454.         self.think=MinionThink;
  455. };
  456.  
  457. //Create the minion
  458. void(vector vec) Minion = 
  459. {   
  460.     sound (self, CHAN_WEAPON, "items/damage3.wav", 1, ATTN_NORM);
  461.     vec = normalize(vec);
  462.     newmis = spawn();
  463.     newmis.owner = self;
  464.     newmis.classname = "electricminion";
  465.     newmis.movetype = MOVETYPE_NOCLIP;
  466. //    newmis.movetype = MOVETYPE_FLY;
  467.     newmis.solid = SOLID_NOT;
  468.     newmis.effects = EF_DIMLIGHT;
  469.     newmis.ammo_cells = 40;
  470.     newmis.items = IT_LIGHTNING;
  471.     setmodel (newmis, "progs/quaddama.mdl");
  472.     setsize (newmis, VEC_ORIGIN, VEC_ORIGIN);  
  473.     setorigin (newmis, self.origin + '0 0 25');// v_forward*8 + '0 0 16');
  474.     newmis.velocity = aim(self, 1000);
  475.     newmis.velocity = newmis.velocity * 1;
  476.     newmis.angles = vectoangles(newmis.velocity);
  477.     newmis.enemy = world;
  478.      newmis.nextthink = time + 2;
  479.     newmis.think = MinionThink;
  480. };
  481.  
  482. //Fire the minion with your gun
  483. void() W_FireMinion =
  484. {   
  485.     if ((self.ammo_cells < 80) || (self.flags & FL_HASMINION)) return;
  486.     //maybe add sound for failure?
  487.     sound (self, CHAN_AUTO, "weapons/lstart.wav", 1, ATTN_NORM);
  488.     self.effects = self.effects | EF_MUZZLEFLASH;
  489.     self.currentammo = self.ammo_cells = self.ammo_cells - 80;
  490.     self.flags = self.flags + FL_HASMINION;
  491.     Minion(self.enemy.origin - self.origin);
  492. };
  493.  
  494. //after a minute, hologram disappears
  495. void() Holothink = { 
  496.   self.owner.numholo = self.owner.numholo - 1;
  497.   sound (self, CHAN_WEAPON, "enforcer/enfire.wav", 1, ATTN_NORM);
  498.   remove(self);
  499.    
  500. };
  501.  
  502. //Create a hologram
  503. void(vector vec) Hologram = {    
  504.     if (self.flags & FL_OBSERVER) return;
  505.     sound (self, CHAN_WEAPON, "enforcer/enfire.wav", 1, ATTN_NORM); 
  506.     vec = normalize(vec);
  507.     
  508.     newmis = spawn();
  509.     newmis.owner = self;
  510.     newmis.classname = "hologram";
  511.     newmis.solid = SOLID_NOT;
  512.     setmodel (newmis, self.model);
  513.     newmis.skin=self.skin;
  514.     newmis.frame=self.frame;
  515.     newmis.colormap=self.colormap;
  516.     newmis.modelindex=self.modelindex;
  517.  
  518.     setsize (newmis, VEC_ORIGIN, VEC_ORIGIN);
  519.         
  520.     setorigin (newmis, self.origin);
  521.     newmis.velocity = aim(self, 1000);
  522.     newmis.velocity = newmis.velocity * 1;
  523.     newmis.angles = vectoangles(newmis.velocity);
  524.     newmis.nextthink = time + 60;
  525.     newmis.think = Holothink;
  526. };
  527.  
  528. //Fire the Hologram
  529. void() W_FireHolo =
  530. { 
  531.     if ((self.ammo_cells < 12) || (self.numholo > 2)) return;
  532.  
  533.     self.effects = self.effects | EF_MUZZLEFLASH;
  534.     self.currentammo = self.ammo_cells = self.ammo_cells - 12;
  535.     self.numholo = self.numholo + 1;
  536.     Hologram(self.enemy.origin - self.origin);
  537. };
  538.  
  539.  
  540. //Become an Observer
  541. void() Observer =
  542. {
  543.     self.items = self.items | (IT_INVULNERABILITY + IT_INVISIBILITY); 
  544.     self.solid = SOLID_NOT;
  545.     centerprint(self,"OBSERVER MODE"); 
  546.      self.flags = self.flags | (FL_OBSERVER);   
  547.     self.flags = self.flags - (self.flags & (FL_HASMINION));
  548.     self.movetype=MOVETYPE_NOCLIP;
  549.     self.frags=self.frags - 1;
  550.     // Detonate Pipe Bombs so person cant use them later
  551.     DetPipeBombs();
  552.     DropFlagCheck(TRUE);
  553.     bprint("\n");
  554.     bprint(self.netname); 
  555.     bprint(" ");
  556.     bprint("is now an observer.");   
  557.     bprint("\n");
  558.     setmodel(self,"");
  559. /*
  560.     self.flags=self.flags | FL_SWIM | FL_INWATER;
  561.     self.watertype=CONTENT_WATER;
  562.     self.waterlevel=1;
  563. */
  564. };          
  565.  
  566. //set the grenade timer based on impulses 53 and 54
  567. void ()SetGrenadeTimer = {
  568.     local string s;
  569.     local float iv; 
  570.     if (self.impulse==53){
  571.         if (self.grenadetimer==0.5) iv=0;
  572.         else iv= -0.5;
  573.         if (self.grenadetimer >5) iv = -1;
  574.         if (self.grenadetimer >20) iv= -5;
  575.         if (self.grenadetimer >60) iv= -15;
  576.         if (self.grenadetimer >120) iv= -30;
  577.     } else {
  578.         iv=0.5;
  579.         if (self.grenadetimer>=5) iv=1;
  580.         if (self.grenadetimer>=15) iv=5;
  581.         if (self.grenadetimer >=60) iv=15;
  582.         if (self.grenadetimer >=120) iv=30;
  583.         if (self.grenadetimer==300) iv=0;
  584.     }
  585.     self.grenadetimer=self.grenadetimer+iv;
  586.     if (!self.grenadetimer) self.grenadetimer=0.5;
  587.     sprint(self,"Grenade Timer: ");
  588.     s=ftos(self.grenadetimer);
  589.     sprint(self,s);
  590.     sprint(self,"\n");
  591. };
  592.  
  593. //If player has lightning gun and less than 50 cells, the gain a cell
  594. void ()CheckPowerRegen = {
  595.     if(self.nextregen <= time){
  596.         if((self.items & IT_LIGHTNING) && (self.ammo_cells < 50)){
  597.             self.ammo_cells=self.ammo_cells+1;
  598.             if (self.weapon==IT_LIGHTNING) self.currentammo=self.ammo_cells;
  599.         }
  600.         self.nextregen=time+5;
  601.     }    
  602. };
  603.  
  604. void() W_PushEnemy = {
  605.     local    vector    source;
  606.     local vector push;
  607.     source = self.origin + '0 0 16';
  608.     makevectors(self.angles);
  609.     traceline (source, source + v_forward*128, FALSE, self);
  610.     v_forward_z=0;
  611.     if (trace_fraction!=1.0)    
  612.         if (trace_ent.takedamage==DAMAGE_AIM){
  613.             //watch out what you move. should this be just players?
  614.             if (trace_ent.flags & FL_ONGROUND)
  615.                 
  616.                 trace_ent.flags=trace_ent.flags-FL_ONGROUND;
  617.             sound (self, CHAN_WEAPON, "player/plyrjmp8.wav", 1, ATTN_NORM);
  618.             push=(((v_forward*64)-(self.origin + '0 0 -32' - trace_ent.origin))*4);
  619.             push_z=push_z+80;
  620.             if (self.super_damage_finished > time) push=push*4;
  621.             trace_ent.velocity=trace_ent.velocity+push;
  622.         }
  623. };
  624.  
  625. void(vector bolt_org, vector bolt_dir, float spawn_num) LightningBounce =
  626. {
  627.     local entity tempent;
  628.     local vector old_endpos;
  629.  
  630.     if (spawn_num < 1)        
  631.         return;
  632.     tempent=spawn();
  633.     tempent.origin = bolt_org;
  634.     setorigin(tempent,bolt_org);
  635.     setmodel(tempent,"progs/grenade.mdl");
  636.     tempent.v_angle = bolt_dir;
  637.     tempent.angles = vectoangles(tempent.v_angle);
  638.     
  639.     traceline (bolt_org, bolt_org + bolt_dir * 600, FALSE, self);
  640.  
  641.     old_endpos = trace_endpos + bolt_dir * 4;
  642.     
  643.     bolt_dir_x = bolt_dir_x * (((0 - 2) * fabs(trace_plane_normal_x)) + 1);
  644.     bolt_dir_y = bolt_dir_y * (((0 - 2) * fabs(trace_plane_normal_y)) + 1);
  645.     bolt_dir_z = bolt_dir_z * (((0 - 2) * fabs(trace_plane_normal_z)) + 1);
  646.  
  647.     WriteByte (MSG_BROADCAST, SVC_TEMPENTITY);
  648.     WriteByte (MSG_BROADCAST, TE_LIGHTNING2);
  649.     WriteEntity (MSG_BROADCAST, tempent);
  650.     WriteCoord (MSG_BROADCAST, bolt_org_x);
  651.     WriteCoord (MSG_BROADCAST, bolt_org_y);
  652.     WriteCoord (MSG_BROADCAST, bolt_org_z);
  653.     WriteCoord (MSG_BROADCAST, trace_endpos_x);
  654.     WriteCoord (MSG_BROADCAST, trace_endpos_y);
  655.     WriteCoord (MSG_BROADCAST, trace_endpos_z);
  656.     
  657.     LightningDamage (bolt_org, old_endpos, self, 15*spawn_num);
  658.  
  659.     bolt_dir_x = bolt_dir_x + 0.05 * crandom();
  660.     bolt_dir_y = bolt_dir_y + 0.05 * crandom();
  661.     bolt_dir_z = bolt_dir_z + 0.05 * crandom();
  662.  
  663.     LightningBounce(old_endpos, bolt_dir, spawn_num - 1);
  664.     
  665.     remove(tempent);
  666. };
  667.  
  668. void() W_FireSuperLightning =
  669. {
  670.     local float cells;
  671.     local vector org;
  672.     if (self.ammo_cells < 3)
  673.     {
  674.         self.weaponnum=0;
  675.         self.weapon = W_BestWeapon ();
  676.         W_SetCurrentAmmo ();
  677.         return;
  678.     }
  679.  
  680. // explode if under water
  681.     if (self.waterlevel > 1)
  682.     {
  683.         cells=self.ammo_cells;
  684.         self.ammo_cells = 0;
  685.         T_RadiusDamage (self, self, 35*cells, world);
  686.         W_SetCurrentAmmo ();
  687.         return;
  688.     }
  689.  
  690.     if (self.t_width < time)
  691.     {
  692.         sound (self, CHAN_WEAPON, "weapons/lhit.wav", 1, ATTN_NORM);
  693.         self.t_width = time + 0.6;
  694.     }
  695.     
  696.     self.punchangle_x = -2;
  697.  
  698.     self.currentammo = self.ammo_cells = self.ammo_cells - 3;
  699.  
  700.     org=self.origin+'0 0 16';
  701.     traceline(org,org+v_forward*600,TRUE,self);
  702.     
  703.     makevectors(self.v_angle);
  704.  
  705.     self.attack_finished=time + 2;
  706.     LightningBounce(org, v_forward, 3);
  707. };
  708.  
  709. void() W_Remember =
  710. {
  711.     self.pos1 = self.origin;
  712.     self.pos2 = self.angles;
  713.     sound (self, CHAN_WEAPON, "misc/basekey.wav", 1, ATTN_NORM);
  714.     sprint (self, "Location Stored\n");
  715. };
  716.  
  717. // void(vector org) spawn_tfog;
  718. // void() tdeath_touch;
  719. void(vector org, entity death_owner) spawn_tdeath;
  720.  
  721. void() W_Teleport =
  722. {
  723.     if (self.ammo_cells < 10)
  724.     {
  725.         sprint(self,"Need 10 cells to teleport.\n");
  726.         return;
  727.     }
  728.     if (teamplay == 7)
  729.     {
  730.         sprint(self,"Teleporting disabled in Capture The Flag.\n");
  731.         return;
  732.     }
  733.     if (!(self.pos1 == '0 0 0'))
  734.     {
  735.     self.currentammo = self.ammo_cells = self.ammo_cells - 10;
  736.     WriteByte (MSG_BROADCAST, SVC_TEMPENTITY);
  737.     WriteByte (MSG_BROADCAST, TE_TELEPORT);
  738.     WriteCoord (MSG_BROADCAST, self.origin_x);
  739.     WriteCoord (MSG_BROADCAST, self.origin_y);
  740.     WriteCoord (MSG_BROADCAST, self.origin_z);
  741.     sound (self, CHAN_WEAPON, "misc/r_tele4.wav", 1, ATTN_NORM);
  742.     spawn_tdeath(self.pos1, self);
  743.     self.origin = self.pos1;
  744.     self.angles = self.pos2;
  745.     self.fixangle = 1;
  746.     
  747.     sound (self, CHAN_WEAPON, "misc/r_tele3.wav", 1, ATTN_NORM);
  748.     WriteByte (MSG_BROADCAST, SVC_TEMPENTITY);
  749.     WriteByte (MSG_BROADCAST, TE_TELEPORT);
  750.     WriteCoord (MSG_BROADCAST, self.origin_x);
  751.     WriteCoord (MSG_BROADCAST, self.origin_y);
  752.     WriteCoord (MSG_BROADCAST, self.origin_z);
  753.     }
  754.     else sprint(self,"No location stored.\n");
  755. };
  756.  
  757. void () W_TripExplode =
  758. {
  759.     self.owner = self.dmg_inflictor;
  760.     T_RadiusDamage (self, self.owner, 199, self);
  761.     WriteByte (MSG_BROADCAST, SVC_TEMPENTITY);
  762.     WriteByte (MSG_BROADCAST, TE_EXPLOSION);
  763.     WriteCoord (MSG_BROADCAST, self.origin_x);
  764.     WriteCoord (MSG_BROADCAST, self.origin_y);
  765.     WriteCoord (MSG_BROADCAST, self.origin_z);
  766.     BecomeExplosion ();
  767. };
  768.  
  769. void() W_TripActivate =
  770. {
  771.     local vector org;
  772.     local vector des;
  773.     local entity found;
  774.     local entity tempent;
  775.  
  776.     local float min_dist;
  777.  
  778.     org = self.origin;
  779.     des = self.pos1;
  780.  
  781.     traceline(org, des, FALSE, self);
  782.     
  783.     WriteByte (MSG_BROADCAST, SVC_TEMPENTITY);
  784.     WriteByte (MSG_BROADCAST, TE_LIGHTNING2);
  785.     WriteEntity (MSG_BROADCAST, self);
  786.     WriteCoord (MSG_BROADCAST, org_x);
  787.     WriteCoord (MSG_BROADCAST, org_y);
  788.     WriteCoord (MSG_BROADCAST, org_z);
  789.     WriteCoord (MSG_BROADCAST, trace_endpos_x);
  790.     WriteCoord (MSG_BROADCAST, trace_endpos_y);
  791.     WriteCoord (MSG_BROADCAST, trace_endpos_z);
  792.  
  793.     self.health = self.health - 1;
  794.     
  795.     if (trace_endpos != des && self.health > 3) 
  796.         self.health = 1;
  797.     
  798.     if (self.health == 1)
  799.         sound (self, CHAN_WEAPON, "misc/talk.wav", 1, ATTN_NORM);
  800.  
  801.     if (self.health <= 0)
  802.     {
  803.         self.think = W_TripExplode;
  804.         self.nextthink = time;
  805.     }
  806.     else
  807.     {
  808.         self.think = W_TripActivate;
  809.         self.nextthink = time + 0.15;
  810.     }
  811. };
  812.  
  813.  
  814. void() W_TripWait =
  815. {
  816.     local entity oldself;
  817.     if(other.health) {
  818.         remove(self);
  819.         return;
  820.     }
  821.     self.owner.attack_finished = time + 1;
  822.     self.owner.currentammo=self.owner.ammo_rockets = self.owner.ammo_rockets - 5;
  823.     self.owner.items=self.owner.items-(self.owner.items & IT_ROCKET_LAUNCHER);
  824.     oldself=self;
  825.     self=self.owner;
  826.     self.weapon=W_BestWeapon();
  827.     W_SetCurrentAmmo();
  828.     self=oldself;
  829.     setmodel(self,"progs/missile.mdl");
  830.     self.angles = self.velocity;
  831.     self.velocity = '0 0 0';
  832.     self.movetype = MOVETYPE_NONE;
  833.     setsize (self, '0 0 0', '0 0 0');
  834.     sound (self, CHAN_WEAPON, "misc/basekey.wav", 1, ATTN_NORM);
  835.     self.dmg_inflictor = self.owner;
  836.     traceline (self.origin, self.origin - self.angles*6000, FALSE, self);
  837.     self.pos1 = trace_endpos;
  838.     self.health = 1200 ;  // 3mins  
  839.     self.owner = self;
  840.     self.think = W_TripActivate;
  841.     self.nextthink = time + 1.5;
  842. };
  843.  
  844. void() W_FireTripBomb =
  845. {
  846.     local vector dir;
  847.     if (self.ammo_rockets < 5)
  848.     {
  849.         sprint (self, "Need 5 rockets to place tripbomb\n");
  850.         return;
  851.     }
  852.     dir = aim(self,1000);
  853.  
  854.     newmis = spawn ();
  855.     newmis.owner = self;
  856.     newmis.movetype = MOVETYPE_FLYMISSILE;
  857.     newmis.solid = SOLID_BBOX;
  858.     newmis.angles = vectoangles(dir);
  859.     newmis.touch = W_TripWait;
  860.     newmis.classname="tripbomb";
  861.     newmis.takedamage = DAMAGE_NO;
  862.     newmis.think = SUB_Remove;
  863.     newmis.nextthink = time + 0.05;
  864.     setsize (newmis, VEC_ORIGIN, VEC_ORIGIN);               
  865.     setorigin (newmis, self.origin);
  866.     newmis.velocity = dir * 5000;
  867. };
  868.  
  869.  
  870. void(entity targ,entity inflictor, float vel) DamageGib = {
  871.     local entity oldself;
  872.     local float rnum;
  873.     rnum = random();
  874.     if ((vel < 10) || (inflictor.weapon == IT_LIGHTNING)) return;
  875.     oldself=self;
  876.     self=targ;
  877.     if(vel < 50) ThrowGib("progs/gib1.mdl",-2 * vel);
  878.     else if(vel < 90) {
  879.         if(rnum < 0.5){
  880.             ThrowGib("progs/gib1.mdl",-2 * vel);
  881.             ThrowGib("progs/gib1.mdl",-2 * vel);
  882.         } else {
  883.             ThrowGib("progs/gib3.mdl",-2 * vel);
  884.         }
  885.     } else if(vel < 130) {
  886.         ThrowGib("progs/gib1.mdl",-2 * vel);
  887.         ThrowGib("progs/gib3.mdl",-2 * vel);
  888.     } else if(vel < 170) {
  889.         ThrowGib("progs/gib3.mdl",-2 * vel);
  890.         if(rnum < 0.5){
  891.             ThrowGib("progs/gib1.mdl",-2 * vel);
  892.             ThrowGib("progs/gib1.mdl",-2 * vel);
  893.         } else {
  894.             ThrowGib("progs/gib3.mdl",-2 * vel);
  895.         }
  896.     } else if(vel < 210) {
  897.         ThrowGib("progs/gib3.mdl",-2 * vel);
  898.         ThrowGib("progs/gib3.mdl",-2 * vel);
  899.         ThrowGib("progs/gib1.mdl",-2 * vel);
  900.     } else {
  901.         ThrowGib("progs/gib3.mdl",-2 * vel);
  902.         ThrowGib("progs/gib3.mdl",-2 * vel);
  903.         ThrowGib("progs/gib1.mdl",-2 * vel);
  904.         ThrowGib("progs/gib1.mdl",-2 * vel);
  905.     }
  906.     self=oldself;
  907. };
  908.  
  909. void() SetAliases = {
  910.     if(newclient==world) return;
  911.     stuffcmd(newclient,"alias INC_SKIN impulse 200\n");
  912.     stuffcmd(newclient,"alias DEC_SKIN impulse 201\n");
  913.     stuffcmd(newclient,"alias OBSERVER impulse 210\n");
  914.     stuffcmd(newclient,"alias UNPLACE impulse 17\n");
  915.     stuffcmd(newclient,"alias DROP_FLAG impulse 18\n");
  916.     stuffcmd(newclient,"alias CYCLE_TEAMPLAY impulse 19\n");
  917.     stuffcmd(newclient,"alias DETONATE impulse 52\n");
  918.     stuffcmd(newclient,"alias DEC_GRENADE_TIMER impulse 53\n");
  919.     stuffcmd(newclient,"alias INC_GRENADE_TIMER impulse 54\n");
  920.     stuffcmd(newclient,"alias TOSS_WEAPON impulse 55\n");
  921.     stuffcmd(newclient,"alias TOSS_AMMO impulse 56\n");
  922.     stuffcmd(newclient,"alias TOSS_ARMOR impulse 57\n");
  923.     stuffcmd(newclient,"alias HOLO impulse 58\n");
  924.     newclient=world;    
  925. };
  926.  
  927. void(entity targ,entity attacker) CreateZombie = {
  928.     local entity ent;
  929.     setmodel(targ,"progs/gib3.mdl");
  930.     ent=self;
  931.     self=spawn();
  932.     setorigin(self,targ.origin);
  933.     self.solid = SOLID_SLIDEBOX;
  934.     self.movetype = MOVETYPE_STEP;
  935.     setmodel (self, "progs/zombie.mdl");
  936.     setsize (self, '-16 -16 -24', '16 16 40');
  937.     self.friend=attacker;
  938.     self.health = 65;
  939.     self.classname = "monster_zombie";
  940.     self.th_stand = zombie_stand1;
  941.     self.th_walk = zombie_walk1;
  942.     self.th_run = zombie_run1;
  943.     self.th_pain = zombie_pain;
  944.     self.th_die = zombie_die;
  945.     self.th_missile = zombie_missile;
  946.     walkmonster_start_go();
  947.     T_Damage(self,ent,ent,60);
  948.     self=ent;
  949. };
  950.  
  951.