API tools faq
paste
Advertisement
techforce

Creepcam from Frogbot

techforce
Oct 11th, 2011
533
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Clone C 38.06 KB | None | 0 0
raw download clone embed print report
  1. float TILT_RATE    = 80;
  2. float WALL_DISTANCE    = 6;
  3. float CAMERA_OFFSET    = 12;
  4. float PRED_TIME    = 1;
  5. float DUAL_BLEND_RATE    = 2;
  6. float CLIP_TIME    = 0.05;
  7. float MAX_SLACK    = 360;
  8. float WATER_TILT    = 2;
  9. float VIEWING_PITCH    = 16;
  10. float FAST_TURN_RATE    = 180;
  11. float SLOW_TURN_RATE    = 60;
  12. float TRACE_TEST    = 240;
  13. float TRACE_BUFFER    = 0.2;
  14. float TRACE_MINIMUM    = 0.5;
  15. float TRACE_RATE    = 0.4;
  16. float TRACE_PAUSE    = 0.5;
  17. float STAIR_BLEND_RATE    = 140;
  18. float FILM_HI_LIP    = 15;
  19. float FILM_LO_LIP    = -23;
  20. float TURNING_INTOVIEW    = 1;
  21. float TILTING_INTOVIEW    = 2;
  22. float DUAL_BLEND_INTOVIEW    = 4;
  23. float VIEW_FIXED_POINT    = 8;
  24. float FIRST_GUY_KILLED    = 16;
  25. float SECOND_GUY_KILLED    = 32;
  26. float EITHER_GUY_KILLED    = 48;
  27. float NOT_EITHER_GUY_KILLED    = 16777167;
  28. float FIND_DIFFERENT_GUY    = 64;
  29. float CF_RESET_FILTER    = 16;
  30. float CF_DOINGLONGMESSAGE    = 256;
  31. entity freecamlist;
  32. .vector filmpos;
  33. .vector predpos;
  34. .float filmlip;
  35. .vector slack1;
  36. .vector slack2;
  37. .vector cangles;
  38. .float vangle;
  39. .float view_pitch;
  40. .float oldstate;
  41. .entity oldmovetarget;
  42. .float msgtime;
  43. .float view_offset;
  44. .vector view_angle;
  45. .vector view_origin;
  46. .float lefty;
  47. .entity oldenemy;
  48. .string deathtype_;
  49. float (float v) cc_anglemod;
  50.  
  51. void (entity e) CC_DisplayCreepView;
  52. void (entity cam) CC_DisplayNames;
  53. void (entity c) CC_ChangeToAnyCam;
  54.  
  55.  
  56. entity (entity first_in_list) AddToList =
  57. {
  58.     self.next = first_in_list;
  59.     self.previous = first_in_list.previous;
  60.     if (first_in_list)
  61.     {
  62.         if (first_in_list.previous)
  63.         {
  64.             first_in_list.previous.next = self;
  65.         }
  66.         first_in_list.previous = self;
  67.     }
  68.     return (self);
  69. };
  70. void () Add_takedamage =
  71. {
  72.     self.takedamage = DAMAGE_YES;
  73.     first_takedamage = AddToList (first_takedamage);
  74.     takedamage_exists = TRUE;
  75. };
  76.  
  77. void () UpdateRadiusDamage =
  78. {
  79.     if (takedamage_exists)
  80.     {
  81.         if (numberofclients)
  82.         {
  83.             return;
  84.         }
  85.         test_enemy = first_takedamage;
  86.         while (test_enemy.next)
  87.         {
  88.             test_enemy = test_enemy.next;
  89.         }
  90.         test_enemy.next = first_client;
  91.         first_client.previous = test_enemy;
  92.     }
  93.     else
  94.     {
  95.         first_takedamage = first_client;
  96.     }
  97. };
  98.  
  99. void () SetViewPort =
  100. {
  101.     WriteByte (MSG_ONE, SVC_SETVIEWPORT);
  102.     WriteEntity (MSG_ONE, viewport);
  103. };
  104.  
  105. void () SetViewPortClient =
  106. {
  107.     if (non_viewport.modelindex)
  108.     {
  109.         non_viewport.modelindex = 0;
  110.         if (msg_entity.player_)
  111.         {
  112.             SetViewPort ();
  113.         }
  114.         msg_entity = msg_entity.clink;
  115.         while (msg_entity.clink)
  116.         {
  117.             if ((msg_entity.pflags & PF_FIRSTPERSON))
  118.             {
  119.                 SetViewPort ();
  120.             }
  121.         }
  122.     }
  123. };
  124.  
  125. void () SetViewPlayer =
  126. {
  127.     msg_entity = self;
  128.     if (self.player_)
  129.     {
  130.         viewport = self;
  131.         non_viewport = self.aiment;
  132.     }
  133.     else
  134.     {
  135.         viewport = self.aiment;
  136.         non_viewport = self;
  137.     }
  138.     SetViewPortClient ();
  139.     viewport.modelindex = modelindex_player;
  140. };
  141.  
  142.  
  143.  
  144. void (entity e, entity f) CopyName =
  145. {
  146.     e.block0 = f.block0;
  147.     e.block1 = f.block1;
  148.     e.block2 = f.block2;
  149.     e.block3 = f.block3;
  150.     e.block4 = f.block4;
  151. };
  152.  
  153. float (entity e, entity f) NamesEqual =
  154. {
  155.     if ((e.block0 == f.block0))
  156.     {
  157.         if ((e.block1 == f.block1))
  158.         {
  159.             if ((e.block2 == f.block2))
  160.             {
  161.                 if ((e.block3 == f.block3))
  162.                 {
  163.                     if ((e.block4 == f.block4))
  164.                     {
  165.                         return (TRUE);
  166.                     }
  167.                 }
  168.             }
  169.         }
  170.     }
  171.     return (FALSE);
  172. };
  173.  
  174. float (float block, float insert_character) insert_block =
  175. {
  176.     character = (block & 255);
  177.     if (character)
  178.     {
  179.         character = (floor ((block / 256)) & 255);
  180.         if (character)
  181.         {
  182.             character = floor ((block / 65536));
  183.             if (character)
  184.             {
  185.                 return (0);
  186.             }
  187.             else
  188.             {
  189.                 return ((block + (insert_character * 65536)));
  190.             }
  191.         }
  192.         else
  193.         {
  194.             return ((block + (insert_character * 256)));
  195.         }
  196.     }
  197.     else
  198.     {
  199.         return (insert_character);
  200.     }
  201. };
  202.  
  203. void (entity client, float insert_character) insert_netname =
  204. {
  205.     block_ = insert_block (client.block0, insert_character);
  206.     if (block_)
  207.     {
  208.         client.block0 = block_;
  209.     }
  210.     else
  211.     {
  212.         block_ = insert_block (client.block1, insert_character);
  213.         if (block_)
  214.         {
  215.             client.block1 = block_;
  216.         }
  217.         else
  218.         {
  219.             block_ = insert_block (client.block2, insert_character);
  220.             if (block_)
  221.             {
  222.                 client.block2 = block_;
  223.             }
  224.             else
  225.             {
  226.                 block_ = insert_block (client.block3, insert_character);
  227.                 if (block_)
  228.                 {
  229.                     client.block3 = block_;
  230.                 }
  231.                 else
  232.                 {
  233.                     block_ = insert_block (client.block4, insert_character);
  234.                     if (block_)
  235.                     {
  236.                         client.block4 = block_;
  237.                     }
  238.                 }
  239.             }
  240.         }
  241.     }
  242. };
  243.  
  244. float (float to, float block) print_block =
  245. {
  246.     character = (block & 255);
  247.     if (character)
  248.     {
  249.         WriteByte (to, character);
  250.         character = (floor ((block / 256)) & 255);
  251.         if (character)
  252.         {
  253.             WriteByte (to, character);
  254.             character = floor ((block / 65536));
  255.             if (character)
  256.             {
  257.                 WriteByte (to, character);
  258.                 return (TRUE);
  259.             }
  260.         }
  261.     }
  262. };
  263.  
  264. void (float to, entity client) WriteName_apply =
  265. {
  266.     if (print_block (to, client.block0))
  267.     {
  268.         if (print_block (to, client.block1))
  269.         {
  270.             if (print_block (to, client.block2))
  271.             {
  272.                 if (print_block (to, client.block3))
  273.                 {
  274.                     print_block (to, client.block4);
  275.                 }
  276.             }
  277.         }
  278.     }
  279. };
  280.  
  281.  
  282.  
  283.  
  284. entity (entity first_in_list) RemoveFromList =
  285. {
  286.     if ((first_in_list == self))
  287.     {
  288.         first_in_list = first_in_list.next;
  289.     }
  290.     if (self.previous)
  291.     {
  292.         self.previous.next = self.next;
  293.     }
  294.     if (self.next)
  295.     {
  296.         self.next.previous = self.previous;
  297.     }
  298.     return (first_in_list);
  299. };
  300.  
  301. void () Add_client =
  302. {
  303.     if (self.client_)
  304.     {
  305.         return;
  306.     }
  307.     self.client_ = TRUE;
  308.     first_client = AddToList (first_client);
  309.     UpdateRadiusDamage ();
  310.     numberofclients = (numberofclients + 1);
  311.     /*
  312.     if (teamplay)
  313.     {
  314.         //self.realteam = self.team;
  315.         //team_index = (self.team - 1);
  316.         self.teamflag = 1;
  317.         while (team_index)
  318.         {
  319.             team_index = (team_index - 1);
  320.             self.teamflag = (self.teamflag * 2);
  321.         }
  322.     }
  323.     else
  324.     {
  325.         current_team = (current_team + 1);
  326.         self.realteam = current_team;
  327.     }
  328.     */
  329.     self.movetarget = world;
  330.     self.enemy = world;
  331.     self.goalentity = world;
  332. };
  333.  
  334.  
  335. void (entity c) CC_RemoveFromCreepList =
  336. {
  337.     local entity l;
  338.  
  339.     l = c.owner;
  340.     if (l)
  341.     {
  342.         if ((c.pflags & PF_FIRSTPERSON))
  343.         {
  344.             CC_DisplayCreepView (c);
  345.         }
  346.         if (c.clink)
  347.         {
  348.             if ((l.clink == c))
  349.             {
  350.                 other = c.clink;
  351.                 other.cangles = c.cangles;
  352.                 other.lefty = c.lefty;
  353.                 other.filmpos = c.filmpos;
  354.                 other.predpos = c.predpos;
  355.                 other.movetarget = c.movetarget;
  356.                 other.oldenemy = c.oldenemy;
  357.                 other.state = c.state;
  358.                 other.style = c.style;
  359.                 other.dest = c.dest;
  360.                 other.slack1 = c.slack1;
  361.                 other.slack2 = c.slack2;
  362.                 other.think = c.think;
  363.                 other.nextthink = c.nextthink;
  364.                 other.search_time = c.search_time;
  365.                 other.light_lev = c.light_lev;
  366.                 other.vangle = c.vangle;
  367.                 other.view_angle = c.view_angle;
  368.                 other.view_origin = c.view_origin;
  369.                 other.view_pitch = c.view_pitch;
  370.             }
  371.         }
  372.     }
  373.     else
  374.     {
  375.         if ((freecamlist == c))
  376.         {
  377.             freecamlist = c.clink;
  378.             return;
  379.         }
  380.         else
  381.         {
  382.             l = freecamlist;
  383.         }
  384.     }
  385.     while (l.clink)
  386.     {
  387.         if ((l.clink == c))
  388.         {
  389.             l.clink = c.clink;
  390.             c.clink = world;
  391.             c.owner = world;
  392.             return;
  393.         }
  394.         l = l.clink;
  395.     }
  396. };
  397.  
  398. void () RemoveFromAllLists =
  399. {
  400.     if (self.client_)
  401.     {
  402.         self.client_ = FALSE;
  403.         //self.frogbot = FALSE;
  404.         first_client = RemoveFromList (first_client);
  405.         UpdateRadiusDamage ();
  406.         numberofclients = (numberofclients - 1);
  407.         other = self.clink;
  408.         while (other)
  409.         {
  410.             CC_ChangeToAnyCam (other);
  411.             other = other.clink;
  412.         }
  413.     }
  414.     if ((self.flags & FL_CREEPCAM))
  415.     {
  416.         CC_RemoveFromCreepList (self);
  417.         self.flags = (self.flags - FL_CREEPCAM);
  418.         first_creepcam = RemoveFromList (first_creepcam);
  419.     }
  420. };
  421.  
  422.  
  423. vector (vector delta, float watercam, entity cam) CC_GetDualAngles =
  424. {
  425.     delta = vectoangles (delta);
  426.     if (watercam)
  427.     {
  428.         if ((delta_x > 180))
  429.         {
  430.             delta_x = ((360 + (VIEWING_PITCH * cam.view_pitch)) - ((delta_x - 360) / 2));
  431.         }
  432.         else
  433.         {
  434.             delta_x = ((360 + (VIEWING_PITCH * cam.view_pitch)) - (delta_x / 3));
  435.         }
  436.     }
  437.     else
  438.     {
  439.         if ((delta_x > 180))
  440.         {
  441.             delta_x = ((VIEWING_PITCH * cam.view_pitch) - ((delta_x - 360) / 2.5));
  442.         }
  443.         else
  444.         {
  445.             delta_x = ((VIEWING_PITCH * cam.view_pitch) - (delta_x / 2));
  446.         }
  447.     }
  448.     if ((delta_x < 0))
  449.     {
  450.         delta_x = (delta_x + 360);
  451.     }
  452.     return (delta);
  453. };
  454.  
  455. void (entity cam) CC_StartCamTransition =
  456. {
  457.     local vector dualangles;
  458.  
  459.     if ((cam.state != 0))
  460.     {
  461.         if ((cam.style & VIEW_FIXED_POINT))
  462.         {
  463.             dualangles = CC_GetDualAngles ((cam.movetarget.filmpos - cam.dest), (cam.owner.waterlevel > 0), cam);
  464.         }
  465.         else
  466.         {
  467.             dualangles = CC_GetDualAngles ((cam.movetarget.filmpos - cam.owner.filmpos), (cam.owner.waterlevel > 0), cam);
  468.         }
  469.         dualangles_z = cc_anglemod (((cam.cangles_y - dualangles_y) + 60));
  470.         if ((dualangles_z > 120))
  471.         {
  472.             cam.style = (cam.style | TURNING_INTOVIEW);
  473.         }
  474.     }
  475.     cam.predpos = cam.filmpos;
  476.     cam.lefty = 0;
  477.     cam.style = ((cam.style | DUAL_BLEND_INTOVIEW) | TILTING_INTOVIEW);
  478. };
  479.  
  480. void (entity cam, float goal) CC_ControlCamFocalLength =
  481. {
  482.     local float frac;
  483.  
  484.     if ((goal > TRACE_MINIMUM))
  485.     {
  486.         frac = (goal - TRACE_BUFFER);
  487.         if ((frac < TRACE_MINIMUM))
  488.         {
  489.             goal = TRACE_MINIMUM;
  490.         }
  491.     }
  492.     else
  493.     {
  494.         frac = goal;
  495.     }
  496.     if ((frac > cam.light_lev))
  497.     {
  498.         if ((frac < TRACE_MINIMUM))
  499.         {
  500.             cam.light_lev = (cam.light_lev + (TRACE_RATE * frametime));
  501.             if ((cam.light_lev > frac))
  502.             {
  503.                 cam.light_lev = frac;
  504.             }
  505.         }
  506.         else
  507.         {
  508.             if ((cam.search_time == -1))
  509.             {
  510.                 cam.search_time = (time + TRACE_PAUSE);
  511.             }
  512.             else
  513.             {
  514.                 if (((time >= cam.search_time) || (frac < TRACE_MINIMUM)))
  515.                 {
  516.                     cam.light_lev = (cam.light_lev + (TRACE_RATE * frametime));
  517.                     if ((cam.light_lev > frac))
  518.                     {
  519.                         cam.light_lev = frac;
  520.                     }
  521.                 }
  522.             }
  523.         }
  524.     }
  525.     else
  526.     {
  527.         cam.search_time = -1;
  528.         if ((frac < cam.light_lev))
  529.         {
  530.             cam.light_lev = (cam.light_lev - (TRACE_RATE * frametime));
  531.             if ((cam.light_lev > goal))
  532.             {
  533.                 cam.light_lev = goal;
  534.             }
  535.             else
  536.             {
  537.                 if ((cam.light_lev < frac))
  538.                 {
  539.                     cam.light_lev = frac;
  540.                 }
  541.             }
  542.         }
  543.     }
  544. };
  545.  
  546. float (entity guy, entity rel, entity prevguy) CC_InterestLevel =
  547. {
  548.     local float lev;
  549.     local float dist1;
  550.     local float dist2;
  551.  
  552.     lev = 0;
  553.     if (guy.client_)
  554.     {
  555.         if (!guy.deadflag)
  556.         {
  557.             lev = 256;
  558.         }
  559.     }
  560.     if (teamplay)
  561.     {
  562.         if ((guy.team != rel.team))
  563.         {
  564.             lev = (lev + 128);
  565.         }
  566.     }
  567.     if ((((guy.items & IT_ROCKET_LAUNCHER) && (guy.ammo_rockets >= 1)) || ((guy.items & IT_LIGHTNING) && (guy.ammo_cells >= 5))))
  568.     {
  569.         lev = (lev + 64);
  570.     }
  571.     if ((guy.items & IT_QUAD))
  572.     {
  573.         lev = (lev + 32);
  574.     }
  575.     if ((guy.items & IT_INVULNERABILITY))
  576.     {
  577.         lev = (lev + 16);
  578.     }
  579.     dist1 = vlen ((guy.origin - rel.origin));
  580.     dist2 = vlen ((prevguy.origin - rel.origin));
  581.     if ((dist1 < (dist2 * 0.5)))
  582.     {
  583.         lev = (lev + 8);
  584.     }
  585.     if ((dist1 < (dist2 * 0.25)))
  586.     {
  587.         lev = (lev + 4);
  588.     }
  589.     if ((dist1 < (dist2 * 0.125)))
  590.     {
  591.         lev = (lev + 2);
  592.     }
  593.     return (lev);
  594. };
  595.  
  596. void (entity cam) CC_CheckForBetterTarget =
  597. {
  598.     local entity targ1;
  599.     local entity targ2;
  600.     local float tangle;
  601.     local float worthit;
  602.     local entity prevguy;
  603.     local entity oldtarget;
  604.     local float lev1;
  605.     local float lev2;
  606.  
  607.     if ((cam.style & EITHER_GUY_KILLED))
  608.     {
  609.         return;
  610.     }
  611.     if (!first_client)
  612.     {
  613.         return;
  614.     }
  615.     targ1 = cam.owner;
  616.     targ2 = cam.oldenemy;
  617.     if (((targ2.flags & FL_CREEPCAM) || !targ2))
  618.     {
  619.         cam.oldenemy = world;
  620.         targ2 = world;
  621.     }
  622.     while (1)
  623.     {
  624.         if (!targ2)
  625.         {
  626.             targ2 = first_client;
  627.         }
  628.         else
  629.         {
  630.             targ2 = targ2.next;
  631.             if (!targ2)
  632.             {
  633.                 if (cam.oldenemy)
  634.                 {
  635.                     cam.oldenemy = world;
  636.                     targ2 = first_client;
  637.                 }
  638.                 else
  639.                 {
  640.                     return;
  641.                 }
  642.             }
  643.         }
  644.         if (!targ2.deadflag)
  645.         {
  646.             if ((targ2 != targ1))
  647.             {
  648.                 cam.oldenemy = targ2;
  649.                 if ((cam.state == 0))
  650.                 {
  651.                     traceline (targ1.predpos, targ2.predpos, 1, targ1);
  652.                     if (!trace_startsolid)
  653.                     {
  654.                         if ((trace_endpos == targ2.predpos))
  655.                         {
  656.                             if ((targ2.deadflag == DEAD_NO))
  657.                             {
  658.                                 cam.movetarget = targ2;
  659.                                 cam.state = 1;
  660.                                 cam.slack1 = targ1.predpos;
  661.                                 cam.slack2 = targ2.predpos;
  662.                                 CC_StartCamTransition (cam);
  663.                             }
  664.                         }
  665.                     }
  666.                 }
  667.                 else
  668.                 {
  669.                     traceline (targ1.filmpos, targ2.filmpos, 1, targ1);
  670.                     if (!trace_startsolid)
  671.                     {
  672.                         if ((trace_endpos == targ2.filmpos))
  673.                         {
  674.                             prevguy = cam.movetarget;
  675.                             if ((prevguy == targ2))
  676.                             {
  677.                                 cam.state = 2;
  678.                             }
  679.                             else
  680.                             {
  681.                                 lev1 = CC_InterestLevel (targ2, targ1, prevguy);
  682.                                 lev2 = CC_InterestLevel (prevguy, targ1, prevguy);
  683.                                 if ((lev1 > lev2))
  684.                                 {
  685.                                     cam.state = 2;
  686.                                     cam.movetarget = targ2;
  687.                                     CC_StartCamTransition (cam);
  688.                                 }
  689.                             }
  690.                         }
  691.                     }
  692.                 }
  693.                 return;
  694.             }
  695.         }
  696.     }
  697. };
  698.  
  699. void (entity cam) CC_UpdateViewingPitch =
  700. {
  701.     if ((cam.owner.waterlevel >= 3))
  702.     {
  703.         cam.view_pitch = (cam.view_pitch - (frametime * WATER_TILT));
  704.         if ((cam.view_pitch < -1))
  705.         {
  706.             cam.view_pitch = -1;
  707.         }
  708.     }
  709.     else
  710.     {
  711.         cam.view_pitch = (cam.view_pitch + (frametime * WATER_TILT));
  712.         if ((cam.view_pitch > 1))
  713.         {
  714.             cam.view_pitch = 1;
  715.         }
  716.     }
  717. };
  718.  
  719. void (entity cam) CC_UpdateViewOffset =
  720. {
  721.     local vector trace_dest;
  722.  
  723.     if ((cam.view_pitch > 0))
  724.     {
  725.         trace_dest = cam.owner.origin;
  726.         trace_dest_z = (trace_dest_z + (4 * CAMERA_OFFSET));
  727.         traceline (cam.owner.origin, trace_dest, 1, cam.owner);
  728.         if ((trace_fraction < 1))
  729.         {
  730.             cam.view_offset = (CAMERA_OFFSET - (((1 - trace_fraction) * 4) * CAMERA_OFFSET));
  731.         }
  732.         else
  733.         {
  734.             cam.view_offset = CAMERA_OFFSET;
  735.         }
  736.     }
  737.     else
  738.     {
  739.         cam.view_offset = CAMERA_OFFSET;
  740.     }
  741. };
  742.  
  743. void (entity cam) CC_MoveSingleCamera =
  744. {
  745.     local vector newvec;
  746.     local float voffset;
  747.     local float tangle;
  748.     local float dangle;
  749.     local float frac;
  750.     local float trace1;
  751.     local float trace2;
  752.     local float trace3;
  753.     local vector angle;
  754.  
  755.     newvec = cam.owner.velocity;
  756.     newvec_z = 0;
  757.     tangle = cam.owner.v_angle_y;
  758.     dangle = cc_anglemod ((tangle - cam.cangles_y));
  759.     frac = (vlen (newvec) / 320);
  760.     if ((frac < 0.7))
  761.     {
  762.         frac = 0.7;
  763.     }
  764.     if (((cam.style & VIEW_FIXED_POINT) == 0))
  765.     {
  766.         if ((dangle < 180))
  767.         {
  768.             if ((dangle > 15))
  769.             {
  770.                 if ((cam.style & DUAL_BLEND_INTOVIEW))
  771.                 {
  772.                     dangle = (dangle - ((frametime * frac) * SLOW_TURN_RATE));
  773.                 }
  774.                 else
  775.                 {
  776.                     if ((dangle < 90))
  777.                     {
  778.                         angle_y = dangle;
  779.                         makevectors (angle);
  780.                         dangle = (dangle - (((frametime * frac) * FAST_TURN_RATE) * v_forward_y));
  781.                     }
  782.                     else
  783.                     {
  784.                         dangle = (dangle - ((frametime * frac) * FAST_TURN_RATE));
  785.                     }
  786.                 }
  787.                 if ((dangle < 15))
  788.                 {
  789.                     dangle = 15;
  790.                 }
  791.             }
  792.             else
  793.             {
  794.                 if ((frac < 0.8))
  795.                 {
  796.                     dangle = (dangle + (frametime * 30));
  797.                     if ((dangle > 15))
  798.                     {
  799.                         dangle = 15;
  800.                     }
  801.                 }
  802.             }
  803.         }
  804.         else
  805.         {
  806.             if ((dangle < 345))
  807.             {
  808.                 if ((cam.style & DUAL_BLEND_INTOVIEW))
  809.                 {
  810.                     dangle = (dangle + ((frametime * frac) * SLOW_TURN_RATE));
  811.                 }
  812.                 else
  813.                 {
  814.                     if ((dangle > 270))
  815.                     {
  816.                         angle_y = (360 - dangle);
  817.                         makevectors (angle);
  818.                         dangle = (dangle + (((frametime * frac) * FAST_TURN_RATE) * v_forward_y));
  819.                     }
  820.                     else
  821.                     {
  822.                         dangle = (dangle + ((frametime * frac) * FAST_TURN_RATE));
  823.                     }
  824.                 }
  825.                 if ((dangle > 345))
  826.                 {
  827.                     dangle = 345;
  828.                 }
  829.             }
  830.             else
  831.             {
  832.                 if ((frac < 0.8))
  833.                 {
  834.                     dangle = (dangle - (frametime * 30));
  835.                     if ((dangle < 345))
  836.                     {
  837.                         dangle = 345;
  838.                     }
  839.                 }
  840.             }
  841.         }
  842.         cam.cangles_y = cc_anglemod ((tangle - dangle));
  843.     }
  844.     voffset = 0;
  845.     if ((cam.owner.v_angle_x < (cam.vangle - (frametime * TILT_RATE))))
  846.     {
  847.         cam.vangle = (cam.vangle - (frametime * TILT_RATE));
  848.     }
  849.     else
  850.     {
  851.         if ((cam.owner.v_angle_x > (cam.vangle + (frametime * TILT_RATE))))
  852.         {
  853.             cam.vangle = (cam.vangle + (frametime * TILT_RATE));
  854.         }
  855.         else
  856.         {
  857.             cam.vangle = cam.owner.v_angle_x;
  858.         }
  859.     }
  860.     if ((cam.vangle < -55))
  861.     {
  862.         cam.vangle = -55;
  863.     }
  864.     if ((cam.vangle > 20))
  865.     {
  866.         voffset = ((cam.vangle - 20) * (1.125 - (cam.view_pitch * 0.375)));
  867.     }
  868.     else
  869.     {
  870.         if ((cam.vangle < -20))
  871.         {
  872.             voffset = ((cam.vangle + 20) * (1.125 + (cam.view_pitch * 0.375)));
  873.         }
  874.     }
  875.     tangle = ((VIEWING_PITCH * cam.view_pitch) + voffset);
  876.     if (((cam.style & TILTING_INTOVIEW) == 0))
  877.     {
  878.         cam.cangles_x = tangle;
  879.     }
  880.     else
  881.     {
  882.         dangle = cc_anglemod ((cam.cangles_x - tangle));
  883.         if ((dangle < 180))
  884.         {
  885.             dangle = (dangle - (SLOW_TURN_RATE * frametime));
  886.             if ((dangle <= 0))
  887.             {
  888.                 dangle = 0;
  889.                 cam.style = (cam.style - TILTING_INTOVIEW);
  890.             }
  891.         }
  892.         else
  893.         {
  894.             dangle = (dangle + (SLOW_TURN_RATE * frametime));
  895.             if ((dangle >= 360))
  896.             {
  897.                 dangle = 0;
  898.                 cam.style = (cam.style - TILTING_INTOVIEW);
  899.             }
  900.         }
  901.         cam.cangles_x = cc_anglemod ((tangle + dangle));
  902.     }
  903.     cam.cangles_z = 0;
  904.     makevectors (cam.cangles);
  905.     if ((cam.style & DUAL_BLEND_INTOVIEW))
  906.     {
  907.         cam.lefty = (cam.lefty + (DUAL_BLEND_RATE * frametime));
  908.         if ((cam.lefty > 1))
  909.         {
  910.             cam.lefty = 1;
  911.             cam.style = (cam.style - DUAL_BLEND_INTOVIEW);
  912.         }
  913.         cam.filmpos_x = ((cam.lefty * v_forward_x) + ((1 - cam.lefty) * cam.predpos_x));
  914.         cam.filmpos_y = ((cam.lefty * v_forward_y) + ((1 - cam.lefty) * cam.predpos_y));
  915.         cam.filmpos_z = ((cam.lefty * v_forward_z) + ((1 - cam.lefty) * cam.predpos_z));
  916.         cam.view_angle = vectoangles (cam.filmpos);
  917.         cam.view_angle_x = (0 - cam.view_angle_x);
  918.     }
  919.     else
  920.     {
  921.         cam.filmpos = v_forward;
  922.         cam.view_angle = cam.cangles;
  923.     }
  924.     if ((cam.style & VIEW_FIXED_POINT))
  925.     {
  926.         newvec = cam.dest;
  927.     }
  928.     else
  929.     {
  930.         newvec = cam.owner.filmpos;
  931.     }
  932.     newvec_z = (newvec_z + cam.view_offset);
  933.     traceline (newvec, (newvec - (v_forward * TRACE_TEST)), 1, cam);
  934.     trace1 = (trace_fraction * TRACE_TEST);
  935.     start = (newvec + (v_right * WALL_DISTANCE));
  936.     traceline (start, (start - (v_forward * TRACE_TEST)), 1, cam);
  937.     trace2 = ((trace_fraction * TRACE_TEST) + WALL_DISTANCE);
  938.     start = (newvec - (v_right * WALL_DISTANCE));
  939.     traceline (start, (start - (v_forward * TRACE_TEST)), 1, cam);
  940.     trace3 = ((trace_fraction * TRACE_TEST) + WALL_DISTANCE);
  941.     trace_fraction = trace1;
  942.     if ((trace2 < trace_fraction))
  943.     {
  944.         trace_fraction = trace2;
  945.     }
  946.     if ((trace3 < trace_fraction))
  947.     {
  948.         trace_fraction = trace3;
  949.     }
  950.     trace_fraction = (trace_fraction / TRACE_TEST);
  951.     CC_ControlCamFocalLength (cam, trace_fraction);
  952.     cam.view_origin = (newvec - (v_forward * ((TRACE_TEST * cam.light_lev) - WALL_DISTANCE)));
  953. };
  954.  
  955. void (entity cam) CC_UpdateDualCamState =
  956. {
  957.     local entity targ1;
  958.     local entity targ2;
  959.     local float slack;
  960.  
  961.     if ((cam.state > 0))
  962.     {
  963.         if (cam.movetarget.deadflag)
  964.         {
  965.             cam.state = 0;
  966.             CC_StartCamTransition (cam);
  967.             return;
  968.         }
  969.     }
  970.     if ((cam.state == 2))
  971.     {
  972.         targ2 = cam.movetarget;
  973.         if ((targ2.flags & FL_CREEPCAM))
  974.         {
  975.             cam.style = (cam.style - (cam.style & SECOND_GUY_KILLED));
  976.             cam.state = 0;
  977.             CC_StartCamTransition (cam);
  978.         }
  979.         else
  980.         {
  981.             targ1 = cam.owner;
  982.             traceline (targ1.filmpos, targ2.filmpos, 1, targ1);
  983.             if ((trace_startsolid || (trace_endpos != targ2.filmpos)))
  984.             {
  985.                 cam.state = 1;
  986.             }
  987.             else
  988.             {
  989.                 cam.slack1 = targ1.filmpos;
  990.                 cam.slack2 = targ2.filmpos;
  991.             }
  992.         }
  993.     }
  994.     if ((cam.state == 1))
  995.     {
  996.         if (((vlen ((cam.owner.filmpos - cam.slack1)) > MAX_SLACK) || (vlen ((cam.movetarget.filmpos - cam.slack2)) > MAX_SLACK)))
  997.         {
  998.             cam.state = 0;
  999.             CC_StartCamTransition (cam);
  1000.         }
  1001.     }
  1002. };
  1003.  
  1004. void (entity cam) CC_MoveDualCamera =
  1005. {
  1006.     local vector newvec;
  1007.     local vector dualangles;
  1008.     local float tangle;
  1009.     local float dangle;
  1010.     local float frac;
  1011.     local vector v1;
  1012.     local vector v2;
  1013.     local float vl1;
  1014.     local float vl2;
  1015.     local vector vnet;
  1016.     local vector angle;
  1017.     local float trace1;
  1018.     local float trace2;
  1019.     local float trace3;
  1020.  
  1021.     if ((cam.style & VIEW_FIXED_POINT))
  1022.     {
  1023.         dualangles = CC_GetDualAngles ((cam.movetarget.filmpos - cam.dest), (cam.owner.waterlevel > 0), cam);
  1024.     }
  1025.     else
  1026.     {
  1027.         dualangles = CC_GetDualAngles ((cam.movetarget.filmpos - cam.owner.filmpos), (cam.owner.waterlevel > 0), cam);
  1028.     }
  1029.     if (((cam.style & TURNING_INTOVIEW) == 0))
  1030.     {
  1031.         newvec = cam.owner.velocity;
  1032.         newvec_z = 0;
  1033.         tangle = vectoyaw (newvec);
  1034.         dangle = cc_anglemod ((tangle - cam.cangles_y));
  1035.         frac = (vlen (newvec) / 400);
  1036.         if ((cc_anglemod (((cam.cangles_y - dualangles_y) + 60)) > 120))
  1037.         {
  1038.             if ((cc_anglemod ((cam.cangles_y - dualangles_y)) < 180))
  1039.             {
  1040.                 cam.cangles_y = (cam.cangles_y - ((frametime * 2) * FAST_TURN_RATE));
  1041.                 if ((cam.cangles_y < cc_anglemod ((dualangles_y + 60))))
  1042.                 {
  1043.                     cam.cangles_y = cc_anglemod ((dualangles_y + 60));
  1044.                 }
  1045.             }
  1046.             else
  1047.             {
  1048.                 cam.cangles_y = (cam.cangles_y + ((frametime * 2) * FAST_TURN_RATE));
  1049.                 if ((cam.cangles_y > cc_anglemod ((dualangles_y - 60))))
  1050.                 {
  1051.                     cam.cangles_y = cc_anglemod ((dualangles_y - 60));
  1052.                 }
  1053.             }
  1054.         }
  1055.         else
  1056.         {
  1057.             if ((frac > 0.1))
  1058.             {
  1059.                 if (!(cam.style & VIEW_FIXED_POINT))
  1060.                 {
  1061.                     if ((dangle < 180))
  1062.                     {
  1063.                         if ((dangle > 15))
  1064.                         {
  1065.                             dangle = (dangle - ((frametime * frac) * FAST_TURN_RATE));
  1066.                             if ((dangle < 15))
  1067.                             {
  1068.                                 dangle = 15;
  1069.                             }
  1070.                         }
  1071.                     }
  1072.                     else
  1073.                     {
  1074.                         if ((dangle < 345))
  1075.                         {
  1076.                             dangle = (dangle + ((frametime * frac) * FAST_TURN_RATE));
  1077.                             if ((dangle > 345))
  1078.                             {
  1079.                                 dangle = 345;
  1080.                             }
  1081.                         }
  1082.                     }
  1083.                     cam.cangles_y = cc_anglemod ((tangle - dangle));
  1084.                 }
  1085.             }
  1086.             if ((cc_anglemod (((cam.cangles_y - dualangles_y) + 60)) > 120))
  1087.             {
  1088.                 if ((cc_anglemod ((cam.cangles_y - dualangles_y)) < 180))
  1089.                 {
  1090.                     cam.cangles_y = cc_anglemod ((dualangles_y + 60));
  1091.                 }
  1092.                 else
  1093.                 {
  1094.                     cam.cangles_y = cc_anglemod ((dualangles_y - 60));
  1095.                 }
  1096.             }
  1097.         }
  1098.     }
  1099.     else
  1100.     {
  1101.         dangle = cc_anglemod ((cam.cangles_y - dualangles_y));
  1102.         if ((dangle < 180))
  1103.         {
  1104.             dangle = (dangle - (FAST_TURN_RATE * frametime));
  1105.             if ((dangle <= 60))
  1106.             {
  1107.                 dangle = 60;
  1108.                 cam.style = (cam.style - (cam.style & TURNING_INTOVIEW));
  1109.             }
  1110.         }
  1111.         else
  1112.         {
  1113.             dangle = (dangle + (FAST_TURN_RATE * frametime));
  1114.             if ((dangle >= 300))
  1115.             {
  1116.                 dangle = 300;
  1117.                 cam.style = (cam.style - (cam.style & TURNING_INTOVIEW));
  1118.             }
  1119.         }
  1120.         cam.cangles_y = cc_anglemod ((dualangles_y + dangle));
  1121.     }
  1122.     if (((cam.style & TILTING_INTOVIEW) == 0))
  1123.     {
  1124.         cam.cangles_x = dualangles_x;
  1125.     }
  1126.     else
  1127.     {
  1128.         dangle = cc_anglemod ((cam.cangles_x - dualangles_x));
  1129.         if ((dangle < 180))
  1130.         {
  1131.             dangle = (dangle - (FAST_TURN_RATE * frametime));
  1132.             if ((dangle <= 0))
  1133.             {
  1134.                 dangle = 0;
  1135.                 cam.style = (cam.style - TILTING_INTOVIEW);
  1136.             }
  1137.         }
  1138.         else
  1139.         {
  1140.             dangle = (dangle + (FAST_TURN_RATE * frametime));
  1141.             if ((dangle >= 360))
  1142.             {
  1143.                 dangle = 0;
  1144.                 cam.style = (cam.style - TILTING_INTOVIEW);
  1145.             }
  1146.         }
  1147.         cam.cangles_x = cc_anglemod ((dualangles_x + dangle));
  1148.     }
  1149.     cam.cangles_z = 0;
  1150.     makevectors (cam.cangles);
  1151.     if ((cam.style & VIEW_FIXED_POINT))
  1152.     {
  1153.         newvec = cam.dest;
  1154.     }
  1155.     else
  1156.     {
  1157.         newvec = cam.owner.filmpos;
  1158.     }
  1159.     newvec_z = (newvec_z + cam.view_offset);
  1160.     traceline (newvec, (newvec - (v_forward * TRACE_TEST)), 1, cam);
  1161.     trace1 = (trace_fraction * TRACE_TEST);
  1162.     start = (newvec + (v_right * WALL_DISTANCE));
  1163.     traceline (start, (start - (v_forward * TRACE_TEST)), 1, cam);
  1164.     trace2 = ((trace_fraction * TRACE_TEST) + WALL_DISTANCE);
  1165.     start = (newvec - (v_right * WALL_DISTANCE));
  1166.     traceline (start, (start - (v_forward * TRACE_TEST)), 1, cam);
  1167.     trace3 = ((trace_fraction * TRACE_TEST) + WALL_DISTANCE);
  1168.     trace_fraction = trace1;
  1169.     if ((trace2 < trace_fraction))
  1170.     {
  1171.         trace_fraction = trace2;
  1172.     }
  1173.     if ((trace3 < trace_fraction))
  1174.     {
  1175.         trace_fraction = trace3;
  1176.     }
  1177.     trace_fraction = (trace_fraction / TRACE_TEST);
  1178.     CC_ControlCamFocalLength (cam, trace_fraction);
  1179.     cam.view_origin = (newvec - (v_forward * ((TRACE_TEST * cam.light_lev) - WALL_DISTANCE)));
  1180.     v1 = (newvec - cam.view_origin);
  1181.     v2 = (cam.movetarget.filmpos - cam.view_origin);
  1182.     vl1 = vlen (v1);
  1183.     vl2 = vlen (v2);
  1184.     vnet_x = ((v1_x / vl1) + (v2_x / vl2));
  1185.     vnet_y = ((v1_y / vl1) + (v2_y / vl2));
  1186.     vnet_z = ((v1_z / vl1) + (v2_z / vl2));
  1187.     if ((cam.style & DUAL_BLEND_INTOVIEW))
  1188.     {
  1189.         cam.lefty = (cam.lefty + (DUAL_BLEND_RATE * frametime));
  1190.         if ((cam.lefty > 1))
  1191.         {
  1192.             cam.lefty = 1;
  1193.             cam.style = (cam.style - DUAL_BLEND_INTOVIEW);
  1194.         }
  1195.         vnet_x = ((cam.lefty * vnet_x) + ((1 - cam.lefty) * cam.predpos_x));
  1196.         vnet_y = ((cam.lefty * vnet_y) + ((1 - cam.lefty) * cam.predpos_y));
  1197.         vnet_z = ((cam.lefty * vnet_z) + ((1 - cam.lefty) * cam.predpos_z));
  1198.     }
  1199.     cam.filmpos = vnet;
  1200.     cam.view_angle = vectoangles (vnet);
  1201.     cam.view_angle_x = (0 - cam.view_angle_x);
  1202. };
  1203.  
  1204. void (entity cam) CC_DoCamAlgorithm =
  1205. {
  1206.     CC_UpdateDualCamState (cam);
  1207.     CC_CheckForBetterTarget (cam);
  1208.     CC_UpdateViewingPitch (cam);
  1209.     CC_UpdateViewOffset (cam);
  1210.     if ((cam.state == 0))
  1211.     {
  1212.         CC_MoveSingleCamera (cam);
  1213.     }
  1214.     else
  1215.     {
  1216.         CC_MoveDualCamera (cam);
  1217.     }
  1218. };
  1219.  
  1220.  
  1221.  
  1222.  
  1223. void () PrepareToObserve =
  1224. {
  1225.     if (self.client_)
  1226.     {
  1227.         TeamCaptureDropFlagOfPlayer (self);
  1228.         //ResetItems ();
  1229.     }
  1230.     RemoveFromAllLists ();
  1231.     SetViewPlayer ();
  1232.     self.model = "";
  1233.     self.weaponmodel = "";
  1234.     self.attack_finished = 0;
  1235.     self.nextthink = 0;
  1236.     self.solid = 0;
  1237.     self.deadflag = 0;
  1238.     self.takedamage = 0;
  1239.     //self.frags = -99;
  1240.     setorigin (self, (self.origin + self.view_ofs));
  1241.     self.velocity = '0 0 0';
  1242.     self.view_ofs_z = 0;
  1243.    
  1244.    
  1245.     //self.fChasing = 0;
  1246.     //self.observer = 1;
  1247.     //self.do_observer = 0;
  1248.     self.lastteam = -50;
  1249.     self.team = -50;
  1250.     self.frags = 0;
  1251.     DropRune ();
  1252.    
  1253.    
  1254.    
  1255.    
  1256.    
  1257. };
  1258.  
  1259.  
  1260. void (entity e) CC_DisplayCreepView =
  1261. {
  1262.     e.view_ofs_z = 0;
  1263.     e.velocity = '0 0 0';
  1264.     e.weaponmodel = "";
  1265.     msg_entity = e;
  1266.     viewport = e;
  1267.     SetViewPort ();
  1268.     e.modelindex = modelindex_player;
  1269. };
  1270.  
  1271. void (entity e) CC_DisplayFirstView =
  1272. {
  1273.     e.view_ofs = viewport.view_ofs;
  1274.     msg_entity = e;
  1275.     viewport = e.owner;
  1276.     if (!viewport.modelindex)
  1277.     {
  1278.         viewport = viewport.aiment;
  1279.     }
  1280.     SetViewPort ();
  1281.     e.modelindex = 0;
  1282. };
  1283.  
  1284. void (entity c) CC_ChangeToWorldCam =
  1285. {
  1286.     CC_RemoveFromCreepList (c);
  1287.     c.owner = world;
  1288.     c.clink = freecamlist;
  1289.     freecamlist = c;
  1290. };
  1291.  
  1292. void (entity c, entity targ_) CC_ChangeToFollowCam =
  1293. {
  1294.     local entity l;
  1295.  
  1296.     CC_RemoveFromCreepList (c);
  1297.     c.owner = targ_;
  1298.     if ((c.pflags & PF_FIRSTPERSON))
  1299.     {
  1300.         CC_DisplayFirstView (c);
  1301.     }
  1302.     if (!targ_.clink)
  1303.     {
  1304.         targ_.clink = c;
  1305.         c.movetarget = world;
  1306.         c.oldenemy = world;
  1307.         c.state = 0;
  1308.         c.style = 0;
  1309.         if ((c.owner.waterlevel >= 3))
  1310.         {
  1311.             c.view_pitch = -1;
  1312.         }
  1313.         else
  1314.         {
  1315.             c.view_pitch = 1;
  1316.         }
  1317.         c.cangles_x = (VIEWING_PITCH * c.view_pitch);
  1318.         c.cangles_z = 0;
  1319.         c.vangle = 0;
  1320.         c.cangles_y = targ_.v_angle_y;
  1321.         makevectors (c.cangles);
  1322.         c.filmpos = v_forward;
  1323.         c.predpos = c.filmpos;
  1324.         c.search_time = CONTENT_EMPTY;
  1325.         c.light_lev = 1;
  1326.     }
  1327.     else
  1328.     {
  1329.         l = targ_.clink;
  1330.         while (l.clink)
  1331.         {
  1332.             l = l.clink;
  1333.         }
  1334.         l.clink = c;
  1335.     }
  1336.     CC_CheckForBetterTarget (c);
  1337.     if (!(c.creepflags & CF_DOINGLONGMESSAGE))
  1338.     {
  1339.         CC_DisplayNames (c);
  1340.     }
  1341. };
  1342. void () CC_WaitingCamThink;
  1343.  
  1344. void (entity c) CC_ChangeToAnyCam =
  1345. {
  1346.     if (!first_client)
  1347.     {
  1348.         CC_ChangeToWorldCam (c);
  1349.         c.state = 0;
  1350.         c.think = CC_WaitingCamThink;
  1351.         c.nextthink = 0.001;
  1352.     }
  1353.     else
  1354.     {
  1355.         CC_ChangeToFollowCam (c, first_client);
  1356.     }
  1357. };
  1358.  
  1359. void () CC_WaitingCamThink =
  1360. {
  1361.     local entity pos;
  1362.  
  1363.     if (first_client)
  1364.     {
  1365.         CC_ChangeToFollowCam (self, first_client);
  1366.         return;
  1367.     }
  1368.     if ((self.state == 10))
  1369.     {
  1370.         self.state = 0;
  1371.     }
  1372.     self.state = (self.state + 1);
  1373.     if ((self.state == 1))
  1374.     {
  1375.         pos = find (self.movetarget, classname, "info_intermission");
  1376.         if ((pos.classname != "info_intermission"))
  1377.         {
  1378.             pos = find (world, classname, "info_intermission");
  1379.         }
  1380.         setorigin (self, pos.origin);
  1381.         self.filmpos = pos.origin;
  1382.         self.cangles = pos.mangle;
  1383.         self.movetarget = pos;
  1384.         self.nextthink = (time + 1.5);
  1385.         self.v_angle = self.cangles;
  1386.         self.angles = self.cangles;
  1387.         self.fixangle = 1;
  1388.     }
  1389.     else
  1390.     {
  1391.         if ((self.state <= 3))
  1392.         {
  1393.             if (!(self.creepflags & CF_DOINGLONGMESSAGE))
  1394.             {
  1395.                 centerprint (self, "\n\n\n\n\n\n\n\n\n\n\nWaiting for players...");
  1396.             }
  1397.         }
  1398.         self.nextthink = (time + 1);
  1399.     }
  1400. };
  1401.  
  1402. void () CC_IntroCamThink =
  1403. {
  1404.     local entity pos;
  1405.  
  1406.     self.state = (self.state + 1);
  1407.     if ((self.state == 1))
  1408.     {
  1409.         pos = find (world, classname, "info_intermission");
  1410.         self.movetarget = pos;
  1411.         setorigin (self, pos.origin);
  1412.         self.filmpos = pos.origin;
  1413.         self.cangles = pos.mangle;
  1414.         self.v_angle = self.cangles;
  1415.         self.angles = self.cangles;
  1416.         self.fixangle = 1;
  1417.         self.nextthink = (time + 0.8);
  1418.     }
  1419.     else
  1420.     {
  1421.         if ((self.state == 2))
  1422.         {
  1423.             msg_entity = self;
  1424.             //bf ();
  1425.             if (!(self.creepflags & CF_DOINGLONGMESSAGE))
  1426.             {
  1427.                 centerprint (self, "ÄiMeÂ’XŸ CreepCam\n\n… activated …");
  1428.             }
  1429.             self.nextthink = (time + 3);
  1430.         }
  1431.         else
  1432.         {
  1433.             CC_ChangeToAnyCam (self);
  1434.         }
  1435.     }
  1436. };
  1437.  
  1438. void () CC_RequestCam =
  1439. {
  1440.     if ((self.flags & FL_CREEPCAM))
  1441.     return;
  1442.    
  1443.     PrepareToObserve ();
  1444.     self.flags = (self.flags | FL_CREEPCAM);
  1445.     first_creepcam = AddToList (first_creepcam);
  1446.     self.owner = world;
  1447.     self.clink = freecamlist;
  1448.     freecamlist = self;
  1449.     bprint (self.netname);
  1450.     bprint (" became a spectator\n");
  1451.     //spawn_tfog (self.origin, world);
  1452.     self.movetype = MOVETYPE_NONE;
  1453.     self.currentammo = 0;
  1454.     self.items = 0;
  1455.     self.health = 100;
  1456.     self.armorvalue = 0;
  1457.     self.ammo_shells = 0;
  1458.     self.ammo_nails = 0;
  1459.     self.ammo_rockets = 0;
  1460.     self.ammo_cells = 0;
  1461.     self.cangles = self.angles;
  1462.     self.state = 0;
  1463.     self.style = 0;
  1464.     self.think = CC_IntroCamThink;
  1465.     self.nextthink = 0.001;
  1466. };
  1467.  
  1468. void () CC_SwitchToNextPlayer =
  1469. {
  1470.     local entity next_;
  1471.  
  1472.     if (self.owner)
  1473.     {
  1474.         next_ = self.owner.next;
  1475.         if (!next_)
  1476.         {
  1477.             next_ = first_client;
  1478.             if ((next_ == self.owner))
  1479.             {
  1480.                 return;
  1481.             }
  1482.         }
  1483.         CC_ChangeToFollowCam (self, next_);
  1484.     }
  1485. };
  1486.  
  1487. void (entity cam) CC_DisplayNames =
  1488. {
  1489.     local entity e;
  1490.     local float timeleft;
  1491.     local float teammate;
  1492.     local string tempstring;
  1493.  
  1494.     if ((((cam.owner.clink.state > 0) && (cam.owner.team == cam.owner.clink.movetarget.team)) && teamplay))
  1495.     {
  1496.         teammate = TRUE;
  1497.     }
  1498.     else
  1499.     {
  1500.         teammate = FALSE;
  1501.     }
  1502.     if (cam.owner.player_)
  1503.     {
  1504.         if ((cam.pflags & PF_FIRSTPERSON))
  1505.         {
  1506.             centerprint2 (cam, "\n\n\n\n\n\n\n\n\n\nviewing  ", cam.owner.netname);
  1507.         }
  1508.         else
  1509.         {
  1510.             if ((!cam.owner.clink.state || (cam.pflags & PF_NONAMES)))
  1511.             {
  1512.                 centerprint2 (cam, "\n\n\n\n\n\n\n\n\n\nfollowing  ", cam.owner.netname);
  1513.             }
  1514.             else
  1515.             {
  1516.                 if (teammate)
  1517.                 {
  1518.                     centerprint4 (cam, "\n\n\n\n\n\n\n\n\n\nfollowing  ", cam.owner.netname, "\ntracking  ", cam.owner.clink.movetarget.netname);
  1519.                 }
  1520.                 else
  1521.                 {
  1522.                     centerprint4 (cam, "\n\n\n\n\n\n\n\n\n\nfollowing  ", cam.owner.netname, "\nôòáãëéîç  ", cam.owner.clink.movetarget.netname);
  1523.                 }
  1524.             }
  1525.         }
  1526.     }
  1527.     else
  1528.     {
  1529.         msg_entity = cam;
  1530.         WriteByte (MSG_ONE, SVC_CENTERPRINT);
  1531.         WriteByte (MSG_ONE, enter);
  1532.         WriteByte (MSG_ONE, enter);
  1533.         WriteByte (MSG_ONE, enter);
  1534.         WriteByte (MSG_ONE, enter);
  1535.         WriteByte (MSG_ONE, enter);
  1536.         WriteByte (MSG_ONE, enter);
  1537.         WriteByte (MSG_ONE, enter);
  1538.         WriteByte (MSG_ONE, enter);
  1539.         WriteByte (MSG_ONE, enter);
  1540.         WriteByte (MSG_ONE, enter);
  1541.         if ((cam.pflags & PF_FIRSTPERSON))
  1542.         {
  1543.             WriteByte (MSG_ONE, _v);
  1544.             WriteByte (MSG_ONE, _i);
  1545.             WriteByte (MSG_ONE, _e);
  1546.             WriteByte (MSG_ONE, _w);
  1547.             WriteByte (MSG_ONE, _i);
  1548.             WriteByte (MSG_ONE, _n);
  1549.             WriteByte (MSG_ONE, _g);
  1550.             WriteByte (MSG_ONE, space);
  1551.             WriteByte (MSG_ONE, 29);
  1552.             WriteByte (MSG_ONE, 31);
  1553.             WriteByte (MSG_ONE, space);
  1554.             WriteName_apply (MSG_ONE, cam.owner);
  1555.             WriteByte (MSG_ONE, 0);
  1556.         }
  1557.         else
  1558.         {
  1559.             WriteByte (MSG_ONE, _f);
  1560.             WriteByte (MSG_ONE, _o);
  1561.             WriteByte (MSG_ONE, _l);
  1562.             WriteByte (MSG_ONE, _l);
  1563.             WriteByte (MSG_ONE, _o);
  1564.             WriteByte (MSG_ONE, _w);
  1565.             WriteByte (MSG_ONE, _i);
  1566.             WriteByte (MSG_ONE, _n);
  1567.             WriteByte (MSG_ONE, _g);
  1568.             WriteByte (MSG_ONE, space);
  1569.             WriteByte (MSG_ONE, 29);
  1570.             WriteByte (MSG_ONE, 31);
  1571.             WriteByte (MSG_ONE, space);
  1572.             WriteName_apply (MSG_ONE, cam.owner);
  1573.             if ((!cam.owner.clink.state || (cam.pflags & PF_NONAMES)))
  1574.             {
  1575.                 WriteByte (MSG_ONE, 0);
  1576.             }
  1577.             else
  1578.             {
  1579.                 WriteByte (MSG_ONE, enter);
  1580.                 if (teammate)
  1581.                 {
  1582.                     WriteByte (MSG_ONE, _t);
  1583.                     WriteByte (MSG_ONE, _r);
  1584.                     WriteByte (MSG_ONE, _a);
  1585.                     WriteByte (MSG_ONE, _c);
  1586.                     WriteByte (MSG_ONE, _k);
  1587.                     WriteByte (MSG_ONE, _i);
  1588.                     WriteByte (MSG_ONE, _n);
  1589.                     WriteByte (MSG_ONE, _g);
  1590.                     WriteByte (MSG_ONE, space);
  1591.                     WriteByte (MSG_ONE, 29);
  1592.                     WriteByte (MSG_ONE, 31);
  1593.                     WriteByte (MSG_ONE, space);
  1594.                 }
  1595.                 else
  1596.                 {
  1597.                     WriteByte (MSG_ONE, 244);
  1598.                     WriteByte (MSG_ONE, 242);
  1599.                     WriteByte (MSG_ONE, 225);
  1600.                     WriteByte (MSG_ONE, 227);
  1601.                     WriteByte (MSG_ONE, 235);
  1602.                     WriteByte (MSG_ONE, 233);
  1603.                     WriteByte (MSG_ONE, 238);
  1604.                     WriteByte (MSG_ONE, 231);
  1605.                     WriteByte (MSG_ONE, space);
  1606.                     WriteByte (MSG_ONE, 29);
  1607.                     WriteByte (MSG_ONE, 31);
  1608.                     WriteByte (MSG_ONE, space);
  1609.                 }
  1610.                 if (cam.owner.clink.movetarget.player_)
  1611.                 {
  1612.                     WriteString (MSG_ONE, cam.owner.clink.movetarget.netname);
  1613.                 }
  1614.                 else
  1615.                 {
  1616.                     WriteName_apply (MSG_ONE, cam.owner.clink.movetarget);
  1617.                     WriteByte (MSG_ONE, 0);
  1618.                 }
  1619.             }
  1620.         }
  1621.     }
  1622.     cam.msgtime = (time + 1);
  1623. };
  1624.  
  1625. void (entity cam) CC_RefreshNames =
  1626. {
  1627.     local float update;
  1628.  
  1629.     update = FALSE;
  1630.     if (!(cam.pflags & PF_NONAMES))
  1631.     {
  1632.         if (((!cam.owner.clink.state && (cam.oldstate > 0)) || ((cam.owner.clink.state > 0) && !cam.oldstate)))
  1633.         {
  1634.             update = TRUE;
  1635.         }
  1636.         if (((cam.owner.clink.state > 0) && (cam.owner.clink.movetarget != cam.oldmovetarget)))
  1637.         {
  1638.             update = TRUE;
  1639.         }
  1640.         if ((time > cam.msgtime))
  1641.         {
  1642.             CC_DisplayNames (cam);
  1643.         }
  1644.         else
  1645.         {
  1646.             if (!(cam.pflags & PF_FIRSTPERSON))
  1647.             {
  1648.                 if ((update == TRUE))
  1649.                 {
  1650.                     CC_DisplayNames (cam);
  1651.                 }
  1652.             }
  1653.         }
  1654.     }
  1655.     cam.oldstate = cam.owner.clink.state;
  1656.     cam.oldmovetarget = cam.owner.clink.movetarget;
  1657. };
  1658.  
  1659. void () CC_NoNames =
  1660. {
  1661.     msg_entity = self;
  1662.     if ((self.pflags & PF_NONAMES))
  1663.     {
  1664.         //sprint ("constant name display åîáâìåä.\n");
  1665.         self.pflags = (self.pflags - (self.pflags & PF_NONAMES));
  1666.     }
  1667.     else
  1668.     {
  1669.     //  sprint ("constant name display äéóáâìåä.\n");
  1670.         self.pflags = (self.pflags | PF_NONAMES);
  1671.     }
  1672. };
  1673.  
  1674.  
  1675.  
  1676.  
  1677. float (float v) newanglemod;
  1678. float (float v) FixedAngle2;
  1679.  
  1680. void () CC_PlayerPostThink =
  1681. {
  1682.     local vector d;
  1683.  
  1684.     if ((self.flags & FL_ONGROUND))
  1685.     {
  1686.         if (((self.origin_z - self.oldorigin_z) > ((self.velocity_z * frametime) + 1)))
  1687.         {
  1688.             d = (self.origin - self.oldorigin);
  1689.             d_z = 0;
  1690.             if ((vlen (d) < 300))
  1691.             {
  1692.                 self.filmlip = ((self.filmlip - self.origin_z) + self.oldorigin_z);
  1693.                 if ((self.filmlip < FILM_LO_LIP))
  1694.                 {
  1695.                     self.filmlip = FILM_LO_LIP;
  1696.                 }
  1697.             }
  1698.         }
  1699.     }
  1700.     if ((self.filmlip < FILM_HI_LIP))
  1701.     {
  1702.         self.filmlip = (self.filmlip + (STAIR_BLEND_RATE * frametime));
  1703.         if ((self.filmlip > FILM_HI_LIP))
  1704.         {
  1705.             self.filmlip = FILM_HI_LIP;
  1706.         }
  1707.     }
  1708.     self.filmpos = self.origin;
  1709.     self.filmpos_z = (self.filmpos_z + self.filmlip);
  1710.     traceline (self.filmpos, (self.filmpos + (PRED_TIME * self.velocity)), TRUE, self);
  1711.     self.predpos = (trace_endpos - (CLIP_TIME * self.velocity));
  1712. };
  1713.  
  1714. void () CC_CamPostThink_has_owner1 =
  1715. {
  1716.     if (((self.owner.health > 0) || (self.pflags & PF_FIRSTPERSON)))
  1717.     {
  1718.         self.health = self.owner.health;
  1719.     }
  1720.     else
  1721.     {
  1722.         self.health = 1;
  1723.     }
  1724.     self.weapon = self.owner.weapon;
  1725.     self.currentammo = self.owner.currentammo;
  1726.     self.ammo_shells = self.owner.ammo_shells;
  1727.     self.ammo_nails = self.owner.ammo_nails;
  1728.     self.ammo_rockets = self.owner.ammo_rockets;
  1729.     self.ammo_cells = self.owner.ammo_cells;
  1730.     self.items = self.owner.items;
  1731.     self.armortype = self.owner.armortype;
  1732.     self.armorvalue = self.owner.armorvalue;
  1733. };
  1734.  
  1735. void () CC_CamPostThink_no_owner =
  1736. {
  1737.     self.health = 100;
  1738.     self.weapon = IT_AXE;
  1739.     self.currentammo = 0;
  1740.     self.ammo_shells = 0;
  1741.     self.ammo_nails = 0;
  1742.     self.ammo_rockets = 0;
  1743.     self.ammo_cells = 0;
  1744.     self.items = 0;
  1745.     self.armortype = 0;
  1746.     self.armorvalue = 0;
  1747. };
  1748.  
  1749. void () CC_CamPostThink =
  1750. {
  1751.     if (self.button0)
  1752.     {
  1753.         if (!(self.attack_finished & BUTTON0))
  1754.         {
  1755.             self.attack_finished = (self.attack_finished | BUTTON0);
  1756.             if (self.owner)
  1757.             {
  1758.                 if ((self.pflags & PF_FIRSTPERSON))
  1759.                 {
  1760.                     self.pflags = (self.pflags - PF_FIRSTPERSON);
  1761.                     CC_DisplayCreepView (self);
  1762.                 }
  1763.                 else
  1764.                 {
  1765.                     self.pflags = (self.pflags | PF_FIRSTPERSON);
  1766.                     CC_DisplayFirstView (self);
  1767.                 }
  1768.                 CC_DisplayNames (self);
  1769.             }
  1770.         }
  1771.     }
  1772.     else
  1773.     {
  1774.         self.attack_finished = (self.attack_finished & NOT_BUTTON0);
  1775.     }
  1776.     if (self.button2)
  1777.     {
  1778.         if (!(self.attack_finished & BUTTON2))
  1779.         {
  1780.             self.attack_finished = (self.attack_finished | BUTTON2);
  1781.             CC_SwitchToNextPlayer ();
  1782.         }
  1783.     }
  1784.     else
  1785.     {
  1786.         self.attack_finished = (self.attack_finished & NOT_BUTTON2);
  1787.     }
  1788. };
  1789.  
  1790. void () CC_CamPostThink_has_owner2 =
  1791. {
  1792.     if ((self.pflags & PF_FIRSTPERSON))
  1793.     {
  1794.         setorigin (self, self.owner.origin);
  1795.         self.weaponmodel = self.owner.weaponmodel;
  1796.         self.weaponframe = self.owner.weaponframe;
  1797.         self.view_ofs = self.owner.view_ofs;
  1798.         if ((self.owner.v_angle_x < 0))
  1799.         {
  1800.             self.angles_x = (self.owner.v_angle_x - 2.8125);
  1801.         }
  1802.         else
  1803.         {
  1804.             self.angles_x = self.owner.v_angle_x;
  1805.         }
  1806.         self.angles_y = self.owner.v_angle_y;
  1807.         self.velocity = self.owner.velocity;
  1808.     }
  1809.     else
  1810.     {
  1811.         setorigin (self, self.owner.clink.view_origin);
  1812.         self.angles_x = self.owner.clink.view_angle_x;
  1813.         self.angles_y = self.owner.clink.view_angle_y;
  1814.     }
  1815.     self.angles_z = 0;
  1816.     self.angles_x = FixedAngle2 (self.angles_x);
  1817.     self.angles_y = FixedAngle2 (self.angles_y);
  1818.     self.fixangle = TRUE;
  1819.     CC_RefreshNames (self);
  1820. };
  1821.  
  1822. void () CC_CamThink =
  1823. {
  1824.     if (self.owner)
  1825.     {
  1826.         if ((self.owner.clink == self))
  1827.         {
  1828.             creep_self = self;
  1829.             CC_CamPostThink_has_owner1 ();
  1830.             CC_CamPostThink ();
  1831.             CC_DoCamAlgorithm (self);
  1832.             CC_CamPostThink_has_owner2 ();
  1833.             self = self.clink;
  1834.             while (self.clink)
  1835.             {
  1836.                 CC_CamPostThink_has_owner1 ();
  1837.                 CC_CamPostThink ();
  1838.                 CC_CamPostThink_has_owner2 ();
  1839.             }
  1840.             self = creep_self;
  1841.         }
  1842.     }
  1843.     else
  1844.     {
  1845.         CC_CamPostThink_no_owner ();
  1846.         CC_CamPostThink ();
  1847.     }
  1848. };
  1849.  
  1850. float (float v) cc_anglemod =
  1851. {
  1852.     while ((v >= 360))
  1853.     {
  1854.         v = (v - 360);
  1855.     }
  1856.     while ((v < 0))
  1857.     {
  1858.         v = (v + 360);
  1859.     }
  1860.     return (v);
  1861. };
  1862.  
  1863. float (float v) newanglemod =
  1864. {
  1865.     while ((v >= 180))
  1866.     {
  1867.         v = (v - 360);
  1868.     }
  1869.     while ((v < -180))
  1870.     {
  1871.         v = (v + 360);
  1872.     }
  1873.     return (v);
  1874. };
  1875.  
  1876.  
  1877.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!