home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 14 / MA_Cover_14.iso / source / c / q1source_amy / qw / server / pr_cmds.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-12-21  |  31.9 KB  |  1,723 lines
  1. /*
  2. Copyright (C) 1996-1997 Id Software, Inc.
  3.  
  4. This program is free software; you can redistribute it and/or
  5. modify it under the terms of the GNU General Public License
  6. as published by the Free Software Foundation; either version 2
  7. of the License, or (at your option) any later version.
  8.  
  9. This program is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
  12.  
  13. See the GNU General Public License for more details.
  14.  
  15. You should have received a copy of the GNU General Public License
  16. along with this program; if not, write to the Free Software
  17. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18.  
  19. */
  20.  
  21. #include "qwsvdef.h"
  22.  
  23. #define    RETURN_EDICT(e) (((int *)pr_globals)[OFS_RETURN] = EDICT_TO_PROG(e))
  24. #define    RETURN_STRING(s) (((int *)pr_globals)[OFS_RETURN] = PR_SetString(s))
  25.  
  26. /*
  27. ===============================================================================
  28.  
  29.                         BUILT-IN FUNCTIONS
  30.  
  31. ===============================================================================
  32. */
  33.  
  34. char *PF_VarString (int    first)
  35. {
  36.     int        i;
  37.     static char out[256];
  38.     
  39.     out[0] = 0;
  40.     for (i=first ; i<pr_argc ; i++)
  41.     {
  42.         strcat (out, G_STRING((OFS_PARM0+i*3)));
  43.     }
  44.     return out;
  45. }
  46.  
  47.  
  48. /*
  49. =================
  50. PF_errror
  51.  
  52. This is a TERMINAL error, which will kill off the entire server.
  53. Dumps self.
  54.  
  55. error(value)
  56. =================
  57. */
  58. void PF_error (void)
  59. {
  60.     char    *s;
  61.     edict_t    *ed;
  62.     
  63.     s = PF_VarString(0);
  64.     Con_Printf ("======SERVER ERROR in %s:\n%s\n", PR_GetString(pr_xfunction->s_name) ,s);
  65.     ed = PROG_TO_EDICT(pr_global_struct->self);
  66.     ED_Print (ed);
  67.  
  68.     SV_Error ("Program error");
  69. }
  70.  
  71. /*
  72. =================
  73. PF_objerror
  74.  
  75. Dumps out self, then an error message.  The program is aborted and self is
  76. removed, but the level can continue.
  77.  
  78. objerror(value)
  79. =================
  80. */
  81. void PF_objerror (void)
  82. {
  83.     char    *s;
  84.     edict_t    *ed;
  85.     
  86.     s = PF_VarString(0);
  87.     Con_Printf ("======OBJECT ERROR in %s:\n%s\n", PR_GetString(pr_xfunction->s_name),s);
  88.     ed = PROG_TO_EDICT(pr_global_struct->self);
  89.     ED_Print (ed);
  90.     ED_Free (ed);
  91.     
  92.     SV_Error ("Program error");
  93. }
  94.  
  95.  
  96.  
  97. /*
  98. ==============
  99. PF_makevectors
  100.  
  101. Writes new values for v_forward, v_up, and v_right based on angles
  102. makevectors(vector)
  103. ==============
  104. */
  105. void PF_makevectors (void)
  106. {
  107.     AngleVectors (G_VECTOR(OFS_PARM0), pr_global_struct->v_forward, pr_global_struct->v_right, pr_global_struct->v_up);
  108. }
  109.  
  110. /*
  111. =================
  112. PF_setorigin
  113.  
  114. This is the only valid way to move an object without using the physics of the world (setting velocity and waiting).  Directly changing origin will not set internal links correctly, so clipping would be messed up.  This should be called when an object is spawned, and then only if it is teleported.
  115.  
  116. setorigin (entity, origin)
  117. =================
  118. */
  119. void PF_setorigin (void)
  120. {
  121.     edict_t    *e;
  122.     float    *org;
  123.     
  124.     e = G_EDICT(OFS_PARM0);
  125.     org = G_VECTOR(OFS_PARM1);
  126.     VectorCopy (org, e->v.origin);
  127.     SV_LinkEdict (e, false);
  128. }
  129.  
  130.  
  131. /*
  132. =================
  133. PF_setsize
  134.  
  135. the size box is rotated by the current angle
  136.  
  137. setsize (entity, minvector, maxvector)
  138. =================
  139. */
  140. void PF_setsize (void)
  141. {
  142.     edict_t    *e;
  143.     float    *min, *max;
  144.     
  145.     e = G_EDICT(OFS_PARM0);
  146.     min = G_VECTOR(OFS_PARM1);
  147.     max = G_VECTOR(OFS_PARM2);
  148.     VectorCopy (min, e->v.mins);
  149.     VectorCopy (max, e->v.maxs);
  150.     VectorSubtract (max, min, e->v.size);
  151.     SV_LinkEdict (e, false);
  152. }
  153.  
  154.  
  155. /*
  156. =================
  157. PF_setmodel
  158.  
  159. setmodel(entity, model)
  160. Also sets size, mins, and maxs for inline bmodels
  161. =================
  162. */
  163. void PF_setmodel (void)
  164. {
  165.     edict_t    *e;
  166.     char    *m, **check;
  167.     int        i;
  168.     model_t    *mod;
  169.  
  170.     e = G_EDICT(OFS_PARM0);
  171.     m = G_STRING(OFS_PARM1);
  172.  
  173. // check to see if model was properly precached
  174.     for (i=0, check = sv.model_precache ; *check ; i++, check++)
  175.         if (!strcmp(*check, m))
  176.             break;
  177.  
  178.     if (!*check)
  179.         PR_RunError ("no precache: %s\n", m);
  180.         
  181.     e->v.model = PR_SetString(m);
  182.     e->v.modelindex = i;
  183.  
  184. // if it is an inline model, get the size information for it
  185.     if (m[0] == '*')
  186.     {
  187.         mod = Mod_ForName (m, true);
  188.         VectorCopy (mod->mins, e->v.mins);
  189.         VectorCopy (mod->maxs, e->v.maxs);
  190.         VectorSubtract (mod->maxs, mod->mins, e->v.size);
  191.         SV_LinkEdict (e, false);
  192.     }
  193.  
  194. }
  195.  
  196. /*
  197. =================
  198. PF_bprint
  199.  
  200. broadcast print to everyone on server
  201.  
  202. bprint(value)
  203. =================
  204. */
  205. void PF_bprint (void)
  206. {
  207.     char        *s;
  208.     int            level;
  209.     
  210.     level = G_FLOAT(OFS_PARM0);
  211.  
  212.     s = PF_VarString(1);
  213.     SV_BroadcastPrintf (level, "%s", s);
  214. }
  215.  
  216. /*
  217. =================
  218. PF_sprint
  219.  
  220. single print to a specific client
  221.  
  222. sprint(clientent, value)
  223. =================
  224. */
  225. void PF_sprint (void)
  226. {
  227.     char        *s;
  228.     client_t    *client;
  229.     int            entnum;
  230.     int            level;
  231.     
  232.     entnum = G_EDICTNUM(OFS_PARM0);
  233.     level = G_FLOAT(OFS_PARM1);
  234.  
  235.     s = PF_VarString(2);
  236.     
  237.     if (entnum < 1 || entnum > MAX_CLIENTS)
  238.     {
  239.         Con_Printf ("tried to sprint to a non-client\n");
  240.         return;
  241.     }
  242.         
  243.     client = &svs.clients[entnum-1];
  244.     
  245.     SV_ClientPrintf (client, level, "%s", s);
  246. }
  247.  
  248.  
  249. /*
  250. =================
  251. PF_centerprint
  252.  
  253. single print to a specific client
  254.  
  255. centerprint(clientent, value)
  256. =================
  257. */
  258. void PF_centerprint (void)
  259. {
  260.     char        *s;
  261.     int            entnum;
  262.     client_t    *cl;
  263.     
  264.     entnum = G_EDICTNUM(OFS_PARM0);
  265.     s = PF_VarString(1);
  266.     
  267.     if (entnum < 1 || entnum > MAX_CLIENTS)
  268.     {
  269.         Con_Printf ("tried to sprint to a non-client\n");
  270.         return;
  271.     }
  272.         
  273.     cl = &svs.clients[entnum-1];
  274.  
  275.     ClientReliableWrite_Begin (cl, svc_centerprint, 2 + strlen(s));
  276.     ClientReliableWrite_String (cl, s);
  277. }
  278.  
  279.  
  280. /*
  281. =================
  282. PF_normalize
  283.  
  284. vector normalize(vector)
  285. =================
  286. */
  287. void PF_normalize (void)
  288. {
  289.     float    *value1;
  290.     vec3_t    newvalue;
  291.     float    new;
  292.     
  293.     value1 = G_VECTOR(OFS_PARM0);
  294.  
  295.     new = value1[0] * value1[0] + value1[1] * value1[1] + value1[2]*value1[2];
  296.     new = sqrt(new);
  297.     
  298.     if (new == 0)
  299.         newvalue[0] = newvalue[1] = newvalue[2] = 0;
  300.     else
  301.     {
  302.         new = 1/new;
  303.         newvalue[0] = value1[0] * new;
  304.         newvalue[1] = value1[1] * new;
  305.         newvalue[2] = value1[2] * new;
  306.     }
  307.     
  308.     VectorCopy (newvalue, G_VECTOR(OFS_RETURN));    
  309. }
  310.  
  311. /*
  312. =================
  313. PF_vlen
  314.  
  315. scalar vlen(vector)
  316. =================
  317. */
  318. void PF_vlen (void)
  319. {
  320.     float    *value1;
  321.     float    new;
  322.     
  323.     value1 = G_VECTOR(OFS_PARM0);
  324.  
  325.     new = value1[0] * value1[0] + value1[1] * value1[1] + value1[2]*value1[2];
  326.     new = sqrt(new);
  327.     
  328.     G_FLOAT(OFS_RETURN) = new;
  329. }
  330.  
  331. /*
  332. =================
  333. PF_vectoyaw
  334.  
  335. float vectoyaw(vector)
  336. =================
  337. */
  338. void PF_vectoyaw (void)
  339. {
  340.     float    *value1;
  341.     float    yaw;
  342.     
  343.     value1 = G_VECTOR(OFS_PARM0);
  344.  
  345.     if (value1[1] == 0 && value1[0] == 0)
  346.         yaw = 0;
  347.     else
  348.     {
  349.         yaw = (int) (atan2(value1[1], value1[0]) * 180 / M_PI);
  350.         if (yaw < 0)
  351.             yaw += 360;
  352.     }
  353.  
  354.     G_FLOAT(OFS_RETURN) = yaw;
  355. }
  356.  
  357.  
  358. /*
  359. =================
  360. PF_vectoangles
  361.  
  362. vector vectoangles(vector)
  363. =================
  364. */
  365. void PF_vectoangles (void)
  366. {
  367.     float    *value1;
  368.     float    forward;
  369.     float    yaw, pitch;
  370.     
  371.     value1 = G_VECTOR(OFS_PARM0);
  372.  
  373.     if (value1[1] == 0 && value1[0] == 0)
  374.     {
  375.         yaw = 0;
  376.         if (value1[2] > 0)
  377.             pitch = 90;
  378.         else
  379.             pitch = 270;
  380.     }
  381.     else
  382.     {
  383.         yaw = (int) (atan2(value1[1], value1[0]) * 180 / M_PI);
  384.         if (yaw < 0)
  385.             yaw += 360;
  386.  
  387.         forward = sqrt (value1[0]*value1[0] + value1[1]*value1[1]);
  388.         pitch = (int) (atan2(value1[2], forward) * 180 / M_PI);
  389.         if (pitch < 0)
  390.             pitch += 360;
  391.     }
  392.  
  393.     G_FLOAT(OFS_RETURN+0) = pitch;
  394.     G_FLOAT(OFS_RETURN+1) = yaw;
  395.     G_FLOAT(OFS_RETURN+2) = 0;
  396. }
  397.  
  398. /*
  399. =================
  400. PF_Random
  401.  
  402. Returns a number from 0<= num < 1
  403.  
  404. random()
  405. =================
  406. */
  407. void PF_random (void)
  408. {
  409.     float        num;
  410.         
  411.     num = (rand ()&0x7fff) / ((float)0x7fff);
  412.     
  413.     G_FLOAT(OFS_RETURN) = num;
  414. }
  415.  
  416.  
  417. /*
  418. =================
  419. PF_ambientsound
  420.  
  421. =================
  422. */
  423. void PF_ambientsound (void)
  424. {
  425.     char        **check;
  426.     char        *samp;
  427.     float        *pos;
  428.     float         vol, attenuation;
  429.     int            i, soundnum;
  430.  
  431.     pos = G_VECTOR (OFS_PARM0);            
  432.     samp = G_STRING(OFS_PARM1);
  433.     vol = G_FLOAT(OFS_PARM2);
  434.     attenuation = G_FLOAT(OFS_PARM3);
  435.     
  436. // check to see if samp was properly precached
  437.     for (soundnum=0, check = sv.sound_precache ; *check ; check++, soundnum++)
  438.         if (!strcmp(*check,samp))
  439.             break;
  440.             
  441.     if (!*check)
  442.     {
  443.         Con_Printf ("no precache: %s\n", samp);
  444.         return;
  445.     }
  446.  
  447. // add an svc_spawnambient command to the level signon packet
  448.  
  449.     MSG_WriteByte (&sv.signon,svc_spawnstaticsound);
  450.     for (i=0 ; i<3 ; i++)
  451.         MSG_WriteCoord(&sv.signon, pos[i]);
  452.  
  453.     MSG_WriteByte (&sv.signon, soundnum);
  454.  
  455.     MSG_WriteByte (&sv.signon, vol*255);
  456.     MSG_WriteByte (&sv.signon, attenuation*64);
  457.  
  458. }
  459.  
  460. /*
  461. =================
  462. PF_sound
  463.  
  464. Each entity can have eight independant sound sources, like voice,
  465. weapon, feet, etc.
  466.  
  467. Channel 0 is an auto-allocate channel, the others override anything
  468. allready running on that entity/channel pair.
  469.  
  470. An attenuation of 0 will play full volume everywhere in the level.
  471. Larger attenuations will drop off.
  472.  
  473. =================
  474. */
  475. void PF_sound (void)
  476. {
  477.     char        *sample;
  478.     int            channel;
  479.     edict_t        *entity;
  480.     int         volume;
  481.     float attenuation;
  482.         
  483.     entity = G_EDICT(OFS_PARM0);
  484.     channel = G_FLOAT(OFS_PARM1);
  485.     sample = G_STRING(OFS_PARM2);
  486.     volume = G_FLOAT(OFS_PARM3) * 255;
  487.     attenuation = G_FLOAT(OFS_PARM4);
  488.     
  489.     SV_StartSound (entity, channel, sample, volume, attenuation);
  490. }
  491.  
  492. /*
  493. =================
  494. PF_break
  495.  
  496. break()
  497. =================
  498. */
  499. void PF_break (void)
  500. {
  501. Con_Printf ("break statement\n");
  502. *(int *)-4 = 0;    // dump to debugger
  503. //    PR_RunError ("break statement");
  504. }
  505.  
  506. /*
  507. =================
  508. PF_traceline
  509.  
  510. Used for use tracing and shot targeting
  511. Traces are blocked by bbox and exact bsp entityes, and also slide box entities
  512. if the tryents flag is set.
  513.  
  514. traceline (vector1, vector2, tryents)
  515. =================
  516. */
  517. void PF_traceline (void)
  518. {
  519.     float    *v1, *v2;
  520.     trace_t    trace;
  521.     int        nomonsters;
  522.     edict_t    *ent;
  523.  
  524.     v1 = G_VECTOR(OFS_PARM0);
  525.     v2 = G_VECTOR(OFS_PARM1);
  526.     nomonsters = G_FLOAT(OFS_PARM2);
  527.     ent = G_EDICT(OFS_PARM3);
  528.  
  529.     trace = SV_Move (v1, vec3_origin, vec3_origin, v2, nomonsters, ent);
  530.  
  531.     pr_global_struct->trace_allsolid = trace.allsolid;
  532.     pr_global_struct->trace_startsolid = trace.startsolid;
  533.     pr_global_struct->trace_fraction = trace.fraction;
  534.     pr_global_struct->trace_inwater = trace.inwater;
  535.     pr_global_struct->trace_inopen = trace.inopen;
  536.     VectorCopy (trace.endpos, pr_global_struct->trace_endpos);
  537.     VectorCopy (trace.plane.normal, pr_global_struct->trace_plane_normal);
  538.     pr_global_struct->trace_plane_dist =  trace.plane.dist;    
  539.     if (trace.ent)
  540.         pr_global_struct->trace_ent = EDICT_TO_PROG(trace.ent);
  541.     else
  542.         pr_global_struct->trace_ent = EDICT_TO_PROG(sv.edicts);
  543. }
  544.  
  545. /*
  546. =================
  547. PF_checkpos
  548.  
  549. Returns true if the given entity can move to the given position from it's
  550. current position by walking or rolling.
  551. FIXME: make work...
  552. scalar checkpos (entity, vector)
  553. =================
  554. */
  555. void PF_checkpos (void)
  556. {
  557. }
  558.  
  559. //============================================================================
  560.  
  561. byte    checkpvs[MAX_MAP_LEAFS/8];
  562.  
  563. int PF_newcheckclient (int check)
  564. {
  565.     int        i;
  566.     byte    *pvs;
  567.     edict_t    *ent;
  568.     mleaf_t    *leaf;
  569.     vec3_t    org;
  570.  
  571. // cycle to the next one
  572.  
  573.     if (check < 1)
  574.         check = 1;
  575.     if (check > MAX_CLIENTS)
  576.         check = MAX_CLIENTS;
  577.  
  578.     if (check == MAX_CLIENTS)
  579.         i = 1;
  580.     else
  581.         i = check + 1;
  582.  
  583.     for ( ;  ; i++)
  584.     {
  585.         if (i == MAX_CLIENTS+1)
  586.             i = 1;
  587.  
  588.         ent = EDICT_NUM(i);
  589.  
  590.         if (i == check)
  591.             break;    // didn't find anything else
  592.  
  593.         if (ent->free)
  594.             continue;
  595.         if (ent->v.health <= 0)
  596.             continue;
  597.         if ((int)ent->v.flags & FL_NOTARGET)
  598.             continue;
  599.  
  600.     // anything that is a client, or has a client as an enemy
  601.         break;
  602.     }
  603.  
  604. // get the PVS for the entity
  605.     VectorAdd (ent->v.origin, ent->v.view_ofs, org);
  606.     leaf = Mod_PointInLeaf (org, sv.worldmodel);
  607.     pvs = Mod_LeafPVS (leaf, sv.worldmodel);
  608.     memcpy (checkpvs, pvs, (sv.worldmodel->numleafs+7)>>3 );
  609.  
  610.     return i;
  611. }
  612.  
  613. /*
  614. =================
  615. PF_checkclient
  616.  
  617. Returns a client (or object that has a client enemy) that would be a
  618. valid target.
  619.  
  620. If there are more than one valid options, they are cycled each frame
  621.  
  622. If (self.origin + self.viewofs) is not in the PVS of the current target,
  623. it is not returned at all.
  624.  
  625. name checkclient ()
  626. =================
  627. */
  628. #define    MAX_CHECK    16
  629. int c_invis, c_notvis;
  630. void PF_checkclient (void)
  631. {
  632.     edict_t    *ent, *self;
  633.     mleaf_t    *leaf;
  634.     int        l;
  635.     vec3_t    view;
  636.     
  637. // find a new check if on a new frame
  638.     if (sv.time - sv.lastchecktime >= 0.1)
  639.     {
  640.         sv.lastcheck = PF_newcheckclient (sv.lastcheck);
  641.         sv.lastchecktime = sv.time;
  642.     }
  643.  
  644. // return check if it might be visible    
  645.     ent = EDICT_NUM(sv.lastcheck);
  646.     if (ent->free || ent->v.health <= 0)
  647.     {
  648.         RETURN_EDICT(sv.edicts);
  649.         return;
  650.     }
  651.  
  652. // if current entity can't possibly see the check entity, return 0
  653.     self = PROG_TO_EDICT(pr_global_struct->self);
  654.     VectorAdd (self->v.origin, self->v.view_ofs, view);
  655.     leaf = Mod_PointInLeaf (view, sv.worldmodel);
  656.     l = (leaf - sv.worldmodel->leafs) - 1;
  657.     if ( (l<0) || !(checkpvs[l>>3] & (1<<(l&7)) ) )
  658.     {
  659. c_notvis++;
  660.         RETURN_EDICT(sv.edicts);
  661.         return;
  662.     }
  663.  
  664. // might be able to see it
  665. c_invis++;
  666.     RETURN_EDICT(ent);
  667. }
  668.  
  669. //============================================================================
  670.  
  671.  
  672. /*
  673. =================
  674. PF_stuffcmd
  675.  
  676. Sends text over to the client's execution buffer
  677.  
  678. stuffcmd (clientent, value)
  679. =================
  680. */
  681. void PF_stuffcmd (void)
  682. {
  683.     int        entnum;
  684.     char    *str;
  685.     client_t    *cl;
  686.     
  687.     entnum = G_EDICTNUM(OFS_PARM0);
  688.     if (entnum < 1 || entnum > MAX_CLIENTS)
  689.         PR_RunError ("Parm 0 not a client");
  690.     str = G_STRING(OFS_PARM1);    
  691.     
  692.     cl = &svs.clients[entnum-1];
  693.  
  694.     if (strcmp(str, "disconnect\n") == 0) {
  695.         // so long and thanks for all the fish
  696.         cl->drop = true;
  697.         return;
  698.     }
  699.  
  700.     ClientReliableWrite_Begin (cl, svc_stufftext, 2+strlen(str));
  701.     ClientReliableWrite_String (cl, str);
  702. }
  703.  
  704. /*
  705. =================
  706. PF_localcmd
  707.  
  708. Sends text over to the client's execution buffer
  709.  
  710. localcmd (string)
  711. =================
  712. */
  713. void PF_localcmd (void)
  714. {
  715.     char    *str;
  716.     
  717.     str = G_STRING(OFS_PARM0);    
  718.     Cbuf_AddText (str);
  719. }
  720.  
  721. /*
  722. =================
  723. PF_cvar
  724.  
  725. float cvar (string)
  726. =================
  727. */
  728. void PF_cvar (void)
  729. {
  730.     char    *str;
  731.     
  732.     str = G_STRING(OFS_PARM0);
  733.     
  734.     G_FLOAT(OFS_RETURN) = Cvar_VariableValue (str);
  735. }
  736.  
  737. /*
  738. =================
  739. PF_cvar_set
  740.  
  741. float cvar (string)
  742. =================
  743. */
  744. void PF_cvar_set (void)
  745. {
  746.     char    *var, *val;
  747.     
  748.     var = G_STRING(OFS_PARM0);
  749.     val = G_STRING(OFS_PARM1);
  750.     
  751.     Cvar_Set (var, val);
  752. }
  753.  
  754. /*
  755. =================
  756. PF_findradius
  757.  
  758. Returns a chain of entities that have origins within a spherical area
  759.  
  760. findradius (origin, radius)
  761. =================
  762. */
  763. void PF_findradius (void)
  764. {
  765.     edict_t    *ent, *chain;
  766.     float    rad;
  767.     float    *org;
  768.     vec3_t    eorg;
  769.     int        i, j;
  770.  
  771.     chain = (edict_t *)sv.edicts;
  772.     
  773.     org = G_VECTOR(OFS_PARM0);
  774.     rad = G_FLOAT(OFS_PARM1);
  775.  
  776.     ent = NEXT_EDICT(sv.edicts);
  777.     for (i=1 ; i<sv.num_edicts ; i++, ent = NEXT_EDICT(ent))
  778.     {
  779.         if (ent->free)
  780.             continue;
  781.         if (ent->v.solid == SOLID_NOT)
  782.             continue;
  783.         for (j=0 ; j<3 ; j++)
  784.             eorg[j] = org[j] - (ent->v.origin[j] + (ent->v.mins[j] + ent->v.maxs[j])*0.5);            
  785.         if (Length(eorg) > rad)
  786.             continue;
  787.             
  788.         ent->v.chain = EDICT_TO_PROG(chain);
  789.         chain = ent;
  790.     }
  791.  
  792.     RETURN_EDICT(chain);
  793. }
  794.  
  795.  
  796. /*
  797. =========
  798. PF_dprint
  799. =========
  800. */
  801. void PF_dprint (void)
  802. {
  803.     Con_Printf ("%s",PF_VarString(0));
  804. }
  805.  
  806. char    pr_string_temp[128];
  807.  
  808. void PF_ftos (void)
  809. {
  810.     float    v;
  811.     v = G_FLOAT(OFS_PARM0);
  812.     
  813.     if (v == (int)v)
  814.         sprintf (pr_string_temp, "%d",(int)v);
  815.     else
  816.         sprintf (pr_string_temp, "%5.1f",v);
  817.     G_INT(OFS_RETURN) = PR_SetString(pr_string_temp);
  818. }
  819.  
  820. void PF_fabs (void)
  821. {
  822.     float    v;
  823.     v = G_FLOAT(OFS_PARM0);
  824.     G_FLOAT(OFS_RETURN) = fabs(v);
  825. }
  826.  
  827. void PF_vtos (void)
  828. {
  829.     sprintf (pr_string_temp, "'%5.1f %5.1f %5.1f'", G_VECTOR(OFS_PARM0)[0], G_VECTOR(OFS_PARM0)[1], G_VECTOR(OFS_PARM0)[2]);
  830.     G_INT(OFS_RETURN) = PR_SetString(pr_string_temp);
  831. }
  832.  
  833. void PF_Spawn (void)
  834. {
  835.     edict_t    *ed;
  836.     ed = ED_Alloc();
  837.     RETURN_EDICT(ed);
  838. }
  839.  
  840. void PF_Remove (void)
  841. {
  842.     edict_t    *ed;
  843.     
  844.     ed = G_EDICT(OFS_PARM0);
  845.     ED_Free (ed);
  846. }
  847.  
  848.  
  849. // entity (entity start, .string field, string match) find = #5;
  850. void PF_Find (void)
  851. {
  852.     int        e;    
  853.     int        f;
  854.     char    *s, *t;
  855.     edict_t    *ed;
  856.     
  857.     e = G_EDICTNUM(OFS_PARM0);
  858.     f = G_INT(OFS_PARM1);
  859.     s = G_STRING(OFS_PARM2);
  860.     if (!s)
  861.         PR_RunError ("PF_Find: bad search string");
  862.         
  863.     for (e++ ; e < sv.num_edicts ; e++)
  864.     {
  865.         ed = EDICT_NUM(e);
  866.         if (ed->free)
  867.             continue;
  868.         t = E_STRING(ed,f);
  869.         if (!t)
  870.             continue;
  871.         if (!strcmp(t,s))
  872.         {
  873.             RETURN_EDICT(ed);
  874.             return;
  875.         }
  876.     }
  877.     
  878.     RETURN_EDICT(sv.edicts);
  879. }
  880.  
  881. void PR_CheckEmptyString (char *s)
  882. {
  883.     if (s[0] <= ' ')
  884.         PR_RunError ("Bad string");
  885. }
  886.  
  887. void PF_precache_file (void)
  888. {    // precache_file is only used to copy files with qcc, it does nothing
  889.     G_INT(OFS_RETURN) = G_INT(OFS_PARM0);
  890. }
  891.  
  892. void PF_precache_sound (void)
  893. {
  894.     char    *s;
  895.     int        i;
  896.     
  897.     if (sv.state != ss_loading)
  898.         PR_RunError ("PF_Precache_*: Precache can only be done in spawn functions");
  899.         
  900.     s = G_STRING(OFS_PARM0);
  901.     G_INT(OFS_RETURN) = G_INT(OFS_PARM0);
  902.     PR_CheckEmptyString (s);
  903.     
  904.     for (i=0 ; i<MAX_SOUNDS ; i++)
  905.     {
  906.         if (!sv.sound_precache[i])
  907.         {
  908.             sv.sound_precache[i] = s;
  909.             return;
  910.         }
  911.         if (!strcmp(sv.sound_precache[i], s))
  912.             return;
  913.     }
  914.     PR_RunError ("PF_precache_sound: overflow");
  915. }
  916.  
  917. void PF_precache_model (void)
  918. {
  919.     char    *s;
  920.     int        i;
  921.     
  922.     if (sv.state != ss_loading)
  923.         PR_RunError ("PF_Precache_*: Precache can only be done in spawn functions");
  924.         
  925.     s = G_STRING(OFS_PARM0);
  926.     G_INT(OFS_RETURN) = G_INT(OFS_PARM0);
  927.     PR_CheckEmptyString (s);
  928.  
  929.     for (i=0 ; i<MAX_MODELS ; i++)
  930.     {
  931.         if (!sv.model_precache[i])
  932.         {
  933.             sv.model_precache[i] = s;
  934.             return;
  935.         }
  936.         if (!strcmp(sv.model_precache[i], s))
  937.             return;
  938.     }
  939.     PR_RunError ("PF_precache_model: overflow");
  940. }
  941.  
  942.  
  943. void PF_coredump (void)
  944. {
  945.     ED_PrintEdicts ();
  946. }
  947.  
  948. void PF_traceon (void)
  949. {
  950.     pr_trace = true;
  951. }
  952.  
  953. void PF_traceoff (void)
  954. {
  955.     pr_trace = false;
  956. }
  957.  
  958. void PF_eprint (void)
  959. {
  960.     ED_PrintNum (G_EDICTNUM(OFS_PARM0));
  961. }
  962.  
  963. /*
  964. ===============
  965. PF_walkmove
  966.  
  967. float(float yaw, float dist) walkmove
  968. ===============
  969. */
  970. void PF_walkmove (void)
  971. {
  972.     edict_t    *ent;
  973.     float    yaw, dist;
  974.     vec3_t    move;
  975.     dfunction_t    *oldf;
  976.     int     oldself;
  977.     
  978.     ent = PROG_TO_EDICT(pr_global_struct->self);
  979.     yaw = G_FLOAT(OFS_PARM0);
  980.     dist = G_FLOAT(OFS_PARM1);
  981.     
  982.     if ( !( (int)ent->v.flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
  983.     {
  984.         G_FLOAT(OFS_RETURN) = 0;
  985.         return;
  986.     }
  987.  
  988.     yaw = yaw*M_PI*2 / 360;
  989.     
  990.     move[0] = cos(yaw)*dist;
  991.     move[1] = sin(yaw)*dist;
  992.     move[2] = 0;
  993.  
  994. // save program state, because SV_movestep may call other progs
  995.     oldf = pr_xfunction;
  996.     oldself = pr_global_struct->self;
  997.     
  998.     G_FLOAT(OFS_RETURN) = SV_movestep(ent, move, true);
  999.     
  1000.     
  1001. // restore program state
  1002.     pr_xfunction = oldf;
  1003.     pr_global_struct->self = oldself;
  1004. }
  1005.  
  1006. /*
  1007. ===============
  1008. PF_droptofloor
  1009.  
  1010. void() droptofloor
  1011. ===============
  1012. */
  1013. void PF_droptofloor (void)
  1014. {
  1015.     edict_t        *ent;
  1016.     vec3_t        end;
  1017.     trace_t        trace;
  1018.     
  1019.     ent = PROG_TO_EDICT(pr_global_struct->self);
  1020.  
  1021.     VectorCopy (ent->v.origin, end);
  1022.     end[2] -= 256;
  1023.     
  1024.     trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, false, ent);
  1025.  
  1026.     if (trace.fraction == 1 || trace.allsolid)
  1027.         G_FLOAT(OFS_RETURN) = 0;
  1028.     else
  1029.     {
  1030.         VectorCopy (trace.endpos, ent->v.origin);
  1031.         SV_LinkEdict (ent, false);
  1032.         ent->v.flags = (int)ent->v.flags | FL_ONGROUND;
  1033.         ent->v.groundentity = EDICT_TO_PROG(trace.ent);
  1034.         G_FLOAT(OFS_RETURN) = 1;
  1035.     }
  1036. }
  1037.  
  1038. /*
  1039. ===============
  1040. PF_lightstyle
  1041.  
  1042. void(float style, string value) lightstyle
  1043. ===============
  1044. */
  1045. void PF_lightstyle (void)
  1046. {
  1047.     int        style;
  1048.     char    *val;
  1049.     client_t    *client;
  1050.     int            j;
  1051.     
  1052.     style = G_FLOAT(OFS_PARM0);
  1053.     val = G_STRING(OFS_PARM1);
  1054.  
  1055. // change the string in sv
  1056.     sv.lightstyles[style] = val;
  1057.     
  1058. // send message to all clients on this server
  1059.     if (sv.state != ss_active)
  1060.         return;
  1061.     
  1062.     for (j=0, client = svs.clients ; j<MAX_CLIENTS ; j++, client++)
  1063.         if ( client->state == cs_spawned )
  1064.         {
  1065.             ClientReliableWrite_Begin (client, svc_lightstyle, strlen(val)+3);
  1066.             ClientReliableWrite_Char (client, style);
  1067.             ClientReliableWrite_String (client, val);
  1068.         }
  1069. }
  1070.  
  1071. void PF_rint (void)
  1072. {
  1073.     float    f;
  1074.     f = G_FLOAT(OFS_PARM0);
  1075.     if (f > 0)
  1076.         G_FLOAT(OFS_RETURN) = (int)(f + 0.5);
  1077.     else
  1078.         G_FLOAT(OFS_RETURN) = (int)(f - 0.5);
  1079. }
  1080. void PF_floor (void)
  1081. {
  1082.     G_FLOAT(OFS_RETURN) = floor(G_FLOAT(OFS_PARM0));
  1083. }
  1084. void PF_ceil (void)
  1085. {
  1086.     G_FLOAT(OFS_RETURN) = ceil(G_FLOAT(OFS_PARM0));
  1087. }
  1088.  
  1089.  
  1090. /*
  1091. =============
  1092. PF_checkbottom
  1093. =============
  1094. */
  1095. void PF_checkbottom (void)
  1096. {
  1097.     edict_t    *ent;
  1098.     
  1099.     ent = G_EDICT(OFS_PARM0);
  1100.  
  1101.     G_FLOAT(OFS_RETURN) = SV_CheckBottom (ent);
  1102. }
  1103.  
  1104. /*
  1105. =============
  1106. PF_pointcontents
  1107. =============
  1108. */
  1109. void PF_pointcontents (void)
  1110. {
  1111.     float    *v;
  1112.     
  1113.     v = G_VECTOR(OFS_PARM0);
  1114.  
  1115.     G_FLOAT(OFS_RETURN) = SV_PointContents (v);    
  1116. }
  1117.  
  1118. /*
  1119. =============
  1120. PF_nextent
  1121.  
  1122. entity nextent(entity)
  1123. =============
  1124. */
  1125. void PF_nextent (void)
  1126. {
  1127.     int        i;
  1128.     edict_t    *ent;
  1129.     
  1130.     i = G_EDICTNUM(OFS_PARM0);
  1131.     while (1)
  1132.     {
  1133.         i++;
  1134.         if (i == sv.num_edicts)
  1135.         {
  1136.             RETURN_EDICT(sv.edicts);
  1137.             return;
  1138.         }
  1139.         ent = EDICT_NUM(i);
  1140.         if (!ent->free)
  1141.         {
  1142.             RETURN_EDICT(ent);
  1143.             return;
  1144.         }
  1145.     }
  1146. }
  1147.  
  1148. /*
  1149. =============
  1150. PF_aim
  1151.  
  1152. Pick a vector for the player to shoot along
  1153. vector aim(entity, missilespeed)
  1154. =============
  1155. */
  1156. //cvar_t    sv_aim = {"sv_aim", "0.93"};
  1157. cvar_t    sv_aim = {"sv_aim", "2"};
  1158. void PF_aim (void)
  1159. {
  1160.     edict_t    *ent, *check, *bestent;
  1161.     vec3_t    start, dir, end, bestdir;
  1162.     int        i, j;
  1163.     trace_t    tr;
  1164.     float    dist, bestdist;
  1165.     float    speed;
  1166.     char    *noaim;
  1167.  
  1168.     ent = G_EDICT(OFS_PARM0);
  1169.     speed = G_FLOAT(OFS_PARM1);
  1170.  
  1171.     VectorCopy (ent->v.origin, start);
  1172.     start[2] += 20;
  1173.  
  1174. // noaim option
  1175.     i = NUM_FOR_EDICT(ent);
  1176.     if (i>0 && i<MAX_CLIENTS)
  1177.     {
  1178.         noaim = Info_ValueForKey (svs.clients[i-1].userinfo, "noaim");
  1179.         if (atoi(noaim) > 0)
  1180.         {
  1181.             VectorCopy (pr_global_struct->v_forward, G_VECTOR(OFS_RETURN));
  1182.             return;
  1183.         }
  1184.     }
  1185.  
  1186. // try sending a trace straight
  1187.     VectorCopy (pr_global_struct->v_forward, dir);
  1188.     VectorMA (start, 2048, dir, end);
  1189.     tr = SV_Move (start, vec3_origin, vec3_origin, end, false, ent);
  1190.     if (tr.ent && tr.ent->v.takedamage == DAMAGE_AIM
  1191.     && (!teamplay.value || ent->v.team <=0 || ent->v.team != tr.ent->v.team) )
  1192.     {
  1193.         VectorCopy (pr_global_struct->v_forward, G_VECTOR(OFS_RETURN));
  1194.         return;
  1195.     }
  1196.  
  1197.  
  1198. // try all possible entities
  1199.     VectorCopy (dir, bestdir);
  1200.     bestdist = sv_aim.value;
  1201.     bestent = NULL;
  1202.     
  1203.     check = NEXT_EDICT(sv.edicts);
  1204.     for (i=1 ; i<sv.num_edicts ; i++, check = NEXT_EDICT(check) )
  1205.     {
  1206.         if (check->v.takedamage != DAMAGE_AIM)
  1207.             continue;
  1208.         if (check == ent)
  1209.             continue;
  1210.         if (teamplay.value && ent->v.team > 0 && ent->v.team == check->v.team)
  1211.             continue;    // don't aim at teammate
  1212.         for (j=0 ; j<3 ; j++)
  1213.             end[j] = check->v.origin[j]
  1214.             + 0.5*(check->v.mins[j] + check->v.maxs[j]);
  1215.         VectorSubtract (end, start, dir);
  1216.         VectorNormalize (dir);
  1217.         dist = DotProduct (dir, pr_global_struct->v_forward);
  1218.         if (dist < bestdist)
  1219.             continue;    // to far to turn
  1220.         tr = SV_Move (start, vec3_origin, vec3_origin, end, false, ent);
  1221.         if (tr.ent == check)
  1222.         {    // can shoot at this one
  1223.             bestdist = dist;
  1224.             bestent = check;
  1225.         }
  1226.     }
  1227.     
  1228.     if (bestent)
  1229.     {
  1230.         VectorSubtract (bestent->v.origin, ent->v.origin, dir);
  1231.         dist = DotProduct (dir, pr_global_struct->v_forward);
  1232.         VectorScale (pr_global_struct->v_forward, dist, end);
  1233.         end[2] = dir[2];
  1234.         VectorNormalize (end);
  1235.         VectorCopy (end, G_VECTOR(OFS_RETURN));    
  1236.     }
  1237.     else
  1238.     {
  1239.         VectorCopy (bestdir, G_VECTOR(OFS_RETURN));
  1240.     }
  1241. }
  1242.  
  1243. /*
  1244. ==============
  1245. PF_changeyaw
  1246.  
  1247. This was a major timewaster in progs, so it was converted to C
  1248. ==============
  1249. */
  1250. void PF_changeyaw (void)
  1251. {
  1252.     edict_t        *ent;
  1253.     float        ideal, current, move, speed;
  1254.     
  1255.     ent = PROG_TO_EDICT(pr_global_struct->self);
  1256.     current = anglemod( ent->v.angles[1] );
  1257.     ideal = ent->v.ideal_yaw;
  1258.     speed = ent->v.yaw_speed;
  1259.     
  1260.     if (current == ideal)
  1261.         return;
  1262.     move = ideal - current;
  1263.     if (ideal > current)
  1264.     {
  1265.         if (move >= 180)
  1266.             move = move - 360;
  1267.     }
  1268.     else
  1269.     {
  1270.         if (move <= -180)
  1271.             move = move + 360;
  1272.     }
  1273.     if (move > 0)
  1274.     {
  1275.         if (move > speed)
  1276.             move = speed;
  1277.     }
  1278.     else
  1279.     {
  1280.         if (move < -speed)
  1281.             move = -speed;
  1282.     }
  1283.     
  1284.     ent->v.angles[1] = anglemod (current + move);
  1285. }
  1286.  
  1287. /*
  1288. ===============================================================================
  1289.  
  1290. MESSAGE WRITING
  1291.  
  1292. ===============================================================================
  1293. */
  1294.  
  1295. #define    MSG_BROADCAST    0        // unreliable to all
  1296. #define    MSG_ONE            1        // reliable to one (msg_entity)
  1297. #define    MSG_ALL            2        // reliable to all
  1298. #define    MSG_INIT        3        // write to the init string
  1299. #define    MSG_MULTICAST    4        // for multicast()
  1300.  
  1301. sizebuf_t *WriteDest (void)
  1302. {
  1303.     int        entnum;
  1304.     int        dest;
  1305.     edict_t    *ent;
  1306.  
  1307.     dest = G_FLOAT(OFS_PARM0);
  1308.     switch (dest)
  1309.     {
  1310.     case MSG_BROADCAST:
  1311.         return &sv.datagram;
  1312.     
  1313.     case MSG_ONE:
  1314.         SV_Error("Shouldn't be at MSG_ONE");
  1315. #if 0
  1316.         ent = PROG_TO_EDICT(pr_global_struct->msg_entity);
  1317.         entnum = NUM_FOR_EDICT(ent);
  1318.         if (entnum < 1 || entnum > MAX_CLIENTS)
  1319.             PR_RunError ("WriteDest: not a client");
  1320.         return &svs.clients[entnum-1].netchan.message;
  1321. #endif
  1322.         
  1323.     case MSG_ALL:
  1324.         return &sv.reliable_datagram;
  1325.     
  1326.     case MSG_INIT:
  1327.         if (sv.state != ss_loading)
  1328.             PR_RunError ("PF_Write_*: MSG_INIT can only be written in spawn functions");
  1329.         return &sv.signon;
  1330.  
  1331.     case MSG_MULTICAST:
  1332.         return &sv.multicast;
  1333.  
  1334.     default:
  1335.         PR_RunError ("WriteDest: bad destination");
  1336.         break;
  1337.     }
  1338.     
  1339.     return NULL;
  1340. }
  1341.  
  1342. static client_t *Write_GetClient(void)
  1343. {
  1344.     int        entnum;
  1345.     edict_t    *ent;
  1346.  
  1347.     ent = PROG_TO_EDICT(pr_global_struct->msg_entity);
  1348.     entnum = NUM_FOR_EDICT(ent);
  1349.     if (entnum < 1 || entnum > MAX_CLIENTS)
  1350.         PR_RunError ("WriteDest: not a client");
  1351.     return &svs.clients[entnum-1];
  1352. }
  1353.  
  1354.  
  1355. void PF_WriteByte (void)
  1356. {
  1357.     if (G_FLOAT(OFS_PARM0) == MSG_ONE) {
  1358.         client_t *cl = Write_GetClient();
  1359.         ClientReliableCheckBlock(cl, 1);
  1360.         ClientReliableWrite_Byte(cl, G_FLOAT(OFS_PARM1));
  1361.     } else
  1362.         MSG_WriteByte (WriteDest(), G_FLOAT(OFS_PARM1));
  1363. }
  1364.  
  1365. void PF_WriteChar (void)
  1366. {
  1367.     if (G_FLOAT(OFS_PARM0) == MSG_ONE) {
  1368.         client_t *cl = Write_GetClient();
  1369.         ClientReliableCheckBlock(cl, 1);
  1370.         ClientReliableWrite_Char(cl, G_FLOAT(OFS_PARM1));
  1371.     } else
  1372.         MSG_WriteChar (WriteDest(), G_FLOAT(OFS_PARM1));
  1373. }
  1374.  
  1375. void PF_WriteShort (void)
  1376. {
  1377.     if (G_FLOAT(OFS_PARM0) == MSG_ONE) {
  1378.         client_t *cl = Write_GetClient();
  1379.         ClientReliableCheckBlock(cl, 2);
  1380.         ClientReliableWrite_Short(cl, G_FLOAT(OFS_PARM1));
  1381.     } else
  1382.         MSG_WriteShort (WriteDest(), G_FLOAT(OFS_PARM1));
  1383. }
  1384.  
  1385. void PF_WriteLong (void)
  1386. {
  1387.     if (G_FLOAT(OFS_PARM0) == MSG_ONE) {
  1388.         client_t *cl = Write_GetClient();
  1389.         ClientReliableCheckBlock(cl, 4);
  1390.         ClientReliableWrite_Long(cl, G_FLOAT(OFS_PARM1));
  1391.     } else
  1392.         MSG_WriteLong (WriteDest(), G_FLOAT(OFS_PARM1));
  1393. }
  1394.  
  1395. void PF_WriteAngle (void)
  1396. {
  1397.     if (G_FLOAT(OFS_PARM0) == MSG_ONE) {
  1398.         client_t *cl = Write_GetClient();
  1399.         ClientReliableCheckBlock(cl, 1);
  1400.         ClientReliableWrite_Angle(cl, G_FLOAT(OFS_PARM1));
  1401.     } else
  1402.         MSG_WriteAngle (WriteDest(), G_FLOAT(OFS_PARM1));
  1403. }
  1404.  
  1405. void PF_WriteCoord (void)
  1406. {
  1407.     if (G_FLOAT(OFS_PARM0) == MSG_ONE) {
  1408.         client_t *cl = Write_GetClient();
  1409.         ClientReliableCheckBlock(cl, 2);
  1410.         ClientReliableWrite_Coord(cl, G_FLOAT(OFS_PARM1));
  1411.     } else
  1412.         MSG_WriteCoord (WriteDest(), G_FLOAT(OFS_PARM1));
  1413. }
  1414.  
  1415. void PF_WriteString (void)
  1416. {
  1417.     if (G_FLOAT(OFS_PARM0) == MSG_ONE) {
  1418.         client_t *cl = Write_GetClient();
  1419.         ClientReliableCheckBlock(cl, 1+strlen(G_STRING(OFS_PARM1)));
  1420.         ClientReliableWrite_String(cl, G_STRING(OFS_PARM1));
  1421.     } else
  1422.         MSG_WriteString (WriteDest(), G_STRING(OFS_PARM1));
  1423. }
  1424.  
  1425.  
  1426. void PF_WriteEntity (void)
  1427. {
  1428.     if (G_FLOAT(OFS_PARM0) == MSG_ONE) {
  1429.         client_t *cl = Write_GetClient();
  1430.         ClientReliableCheckBlock(cl, 2);
  1431.         ClientReliableWrite_Short(cl, G_EDICTNUM(OFS_PARM1));
  1432.     } else
  1433.         MSG_WriteShort (WriteDest(), G_EDICTNUM(OFS_PARM1));
  1434. }
  1435.  
  1436. //=============================================================================
  1437.  
  1438. int SV_ModelIndex (char *name);
  1439.  
  1440. void PF_makestatic (void)
  1441. {
  1442.     edict_t    *ent;
  1443.     int        i;
  1444.     
  1445.     ent = G_EDICT(OFS_PARM0);
  1446.  
  1447.     MSG_WriteByte (&sv.signon,svc_spawnstatic);
  1448.  
  1449.     MSG_WriteByte (&sv.signon, SV_ModelIndex(PR_GetString(ent->v.model)));
  1450.  
  1451.     MSG_WriteByte (&sv.signon, ent->v.frame);
  1452.     MSG_WriteByte (&sv.signon, ent->v.colormap);
  1453.     MSG_WriteByte (&sv.signon, ent->v.skin);
  1454.     for (i=0 ; i<3 ; i++)
  1455.     {
  1456.         MSG_WriteCoord(&sv.signon, ent->v.origin[i]);
  1457.         MSG_WriteAngle(&sv.signon, ent->v.angles[i]);
  1458.     }
  1459.  
  1460. // throw the entity away now
  1461.     ED_Free (ent);
  1462. }
  1463.  
  1464. //=============================================================================
  1465.  
  1466. /*
  1467. ==============
  1468. PF_setspawnparms
  1469. ==============
  1470. */
  1471. void PF_setspawnparms (void)
  1472. {
  1473.     edict_t    *ent;
  1474.     int        i;
  1475.     client_t    *client;
  1476.  
  1477.     ent = G_EDICT(OFS_PARM0);
  1478.     i = NUM_FOR_EDICT(ent);
  1479.     if (i < 1 || i > MAX_CLIENTS)
  1480.         PR_RunError ("Entity is not a client");
  1481.  
  1482.     // copy spawn parms out of the client_t
  1483.     client = svs.clients + (i-1);
  1484.  
  1485.     for (i=0 ; i< NUM_SPAWN_PARMS ; i++)
  1486.         (&pr_global_struct->parm1)[i] = client->spawn_parms[i];
  1487. }
  1488.  
  1489. /*
  1490. ==============
  1491. PF_changelevel
  1492. ==============
  1493. */
  1494. void PF_changelevel (void)
  1495. {
  1496.     char    *s;
  1497.     static    int    last_spawncount;
  1498.  
  1499. // make sure we don't issue two changelevels
  1500.     if (svs.spawncount == last_spawncount)
  1501.         return;
  1502.     last_spawncount = svs.spawncount;
  1503.     
  1504.     s = G_STRING(OFS_PARM0);
  1505.     Cbuf_AddText (va("map %s\n",s));
  1506. }
  1507.  
  1508.  
  1509. /*
  1510. ==============
  1511. PF_logfrag
  1512.  
  1513. logfrag (killer, killee)
  1514. ==============
  1515. */
  1516. void PF_logfrag (void)
  1517. {
  1518.     edict_t    *ent1, *ent2;
  1519.     int        e1, e2;
  1520.     char    *s;
  1521.  
  1522.     ent1 = G_EDICT(OFS_PARM0);
  1523.     ent2 = G_EDICT(OFS_PARM1);
  1524.  
  1525.     e1 = NUM_FOR_EDICT(ent1);
  1526.     e2 = NUM_FOR_EDICT(ent2);
  1527.     
  1528.     if (e1 < 1 || e1 > MAX_CLIENTS
  1529.     || e2 < 1 || e2 > MAX_CLIENTS)
  1530.         return;
  1531.     
  1532.     s = va("\\%s\\%s\\\n",svs.clients[e1-1].name, svs.clients[e2-1].name);
  1533.  
  1534.     SZ_Print (&svs.log[svs.logsequence&1], s);
  1535.     if (sv_fraglogfile) {
  1536.         fprintf (sv_fraglogfile, s);
  1537.         fflush (sv_fraglogfile);
  1538.     }
  1539. }
  1540.  
  1541.  
  1542. /*
  1543. ==============
  1544. PF_infokey
  1545.  
  1546. string(entity e, string key) infokey
  1547. ==============
  1548. */
  1549. void PF_infokey (void)
  1550. {
  1551.     edict_t    *e;
  1552.     int        e1;
  1553.     char    *value;
  1554.     char    *key;
  1555.     static    char ov[256];
  1556.  
  1557.     e = G_EDICT(OFS_PARM0);
  1558.     e1 = NUM_FOR_EDICT(e);
  1559.     key = G_STRING(OFS_PARM1);
  1560.  
  1561.     if (e1 == 0) {
  1562.         if ((value = Info_ValueForKey (svs.info, key)) == NULL ||
  1563.             !*value)
  1564.             value = Info_ValueForKey(localinfo, key);
  1565.     } else if (e1 <= MAX_CLIENTS) {
  1566.         if (!strcmp(key, "ip"))
  1567.             value = strcpy(ov, NET_BaseAdrToString (svs.clients[e1-1].netchan.remote_address));
  1568.         else if (!strcmp(key, "ping")) {
  1569.             int ping = SV_CalcPing (&svs.clients[e1-1]);
  1570.             sprintf(ov, "%d", ping);
  1571.             value = ov;
  1572.         } else
  1573.             value = Info_ValueForKey (svs.clients[e1-1].userinfo, key);
  1574.     } else
  1575.         value = "";
  1576.  
  1577.     RETURN_STRING(value);
  1578. }
  1579.  
  1580. /*
  1581. ==============
  1582. PF_stof
  1583.  
  1584. float(string s) stof
  1585. ==============
  1586. */
  1587. void PF_stof (void)
  1588. {
  1589.     char    *s;
  1590.  
  1591.     s = G_STRING(OFS_PARM0);
  1592.  
  1593.     G_FLOAT(OFS_RETURN) = atof(s);
  1594. }
  1595.  
  1596.  
  1597. /*
  1598. ==============
  1599. PF_multicast
  1600.  
  1601. void(vector where, float set) multicast
  1602. ==============
  1603. */
  1604. void PF_multicast (void)
  1605. {
  1606.     float    *o;
  1607.     int        to;
  1608.  
  1609.     o = G_VECTOR(OFS_PARM0);
  1610.     to = G_FLOAT(OFS_PARM1);
  1611.  
  1612.     SV_Multicast (o, to);
  1613. }
  1614.  
  1615.  
  1616. void PF_Fixme (void)
  1617. {
  1618.     PR_RunError ("unimplemented bulitin");
  1619. }
  1620.  
  1621.  
  1622.  
  1623. builtin_t pr_builtin[] =
  1624. {
  1625.     PF_Fixme,
  1626. PF_makevectors,    // void(entity e)    makevectors         = #1;
  1627. PF_setorigin,    // void(entity e, vector o) setorigin    = #2;
  1628. PF_setmodel,    // void(entity e, string m) setmodel    = #3;
  1629. PF_setsize,    // void(entity e, vector min, vector max) setsize = #4;
  1630. PF_Fixme,    // void(entity e, vector min, vector max) setabssize = #5;
  1631. PF_break,    // void() break                        = #6;
  1632. PF_random,    // float() random                        = #7;
  1633. PF_sound,    // void(entity e, float chan, string samp) sound = #8;
  1634. PF_normalize,    // vector(vector v) normalize            = #9;
  1635. PF_error,    // void(string e) error                = #10;
  1636. PF_objerror,    // void(string e) objerror                = #11;
  1637. PF_vlen,    // float(vector v) vlen                = #12;
  1638. PF_vectoyaw,    // float(vector v) vectoyaw        = #13;
  1639. PF_Spawn,    // entity() spawn                        = #14;
  1640. PF_Remove,    // void(entity e) remove                = #15;
  1641. PF_traceline,    // float(vector v1, vector v2, float tryents) traceline = #16;
  1642. PF_checkclient,    // entity() clientlist                    = #17;
  1643. PF_Find,    // entity(entity start, .string fld, string match) find = #18;
  1644. PF_precache_sound,    // void(string s) precache_sound        = #19;
  1645. PF_precache_model,    // void(string s) precache_model        = #20;
  1646. PF_stuffcmd,    // void(entity client, string s)stuffcmd = #21;
  1647. PF_findradius,    // entity(vector org, float rad) findradius = #22;
  1648. PF_bprint,    // void(string s) bprint                = #23;
  1649. PF_sprint,    // void(entity client, string s) sprint = #24;
  1650. PF_dprint,    // void(string s) dprint                = #25;
  1651. PF_ftos,    // void(string s) ftos                = #26;
  1652. PF_vtos,    // void(string s) vtos                = #27;
  1653. PF_coredump,
  1654. PF_traceon,
  1655. PF_traceoff,
  1656. PF_eprint,    // void(entity e) debug print an entire entity
  1657. PF_walkmove, // float(float yaw, float dist) walkmove
  1658. PF_Fixme, // float(float yaw, float dist) walkmove
  1659. PF_droptofloor,
  1660. PF_lightstyle,
  1661. PF_rint,
  1662. PF_floor,
  1663. PF_ceil,
  1664. PF_Fixme,
  1665. PF_checkbottom,
  1666. PF_pointcontents,
  1667. PF_Fixme,
  1668. PF_fabs,
  1669. PF_aim,
  1670. PF_cvar,
  1671. PF_localcmd,
  1672. PF_nextent,
  1673. PF_Fixme,
  1674. PF_changeyaw,
  1675. PF_Fixme,
  1676. PF_vectoangles,
  1677.  
  1678. PF_WriteByte,
  1679. PF_WriteChar,
  1680. PF_WriteShort,
  1681. PF_WriteLong,
  1682. PF_WriteCoord,
  1683. PF_WriteAngle,
  1684. PF_WriteString,
  1685. PF_WriteEntity,
  1686.  
  1687. PF_Fixme,
  1688. PF_Fixme,
  1689. PF_Fixme,
  1690. PF_Fixme,
  1691. PF_Fixme,
  1692. PF_Fixme,
  1693. PF_Fixme,
  1694.  
  1695. SV_MoveToGoal,
  1696. PF_precache_file,
  1697. PF_makestatic,
  1698.  
  1699. PF_changelevel,
  1700. PF_Fixme,
  1701.  
  1702. PF_cvar_set,
  1703. PF_centerprint,
  1704.  
  1705. PF_ambientsound,
  1706.  
  1707. PF_precache_model,
  1708. PF_precache_sound,        // precache_sound2 is different only for qcc
  1709. PF_precache_file,
  1710.  
  1711. PF_setspawnparms,
  1712.  
  1713. PF_logfrag,
  1714.  
  1715. PF_infokey,
  1716. PF_stof,
  1717. PF_multicast
  1718. };
  1719.  
  1720. builtin_t *pr_builtins = pr_builtin;
  1721. int pr_numbuiltins = sizeof(pr_builtin)/sizeof(pr_builtin[0]);
  1722.  
  1723.