API tools faq
paste
Advertisement
CUgopEntity

xrServer_Entities.cpp

CUgopEntity
Jan 23rd, 2019
126
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 12.77 KB | None | 0 0
raw download clone embed print report
  1. #include "stdafx.h"
  2. #pragma hdrstop
  3.  
  4. #ifdef _EDITOR
  5.     #include "xrServer_Entities.h"
  6.     #include "xr_ini.h"
  7.     #include "clsid_game.h"
  8.     #include "xr_tokens.h"
  9.     #include "game_type.h"
  10. #else
  11.     #include "xrServer.h"
  12. #endif
  13.  
  14. // EDITOR, NETWORK, SAVE, LOAD, DEMO
  15. void    xrServerEntity::Spawn_Write     (NET_Packet& P, BOOL bLocal)
  16. {
  17.     // generic
  18.     P.w_begin           (M_SPAWN        );
  19.     P.w_string          (s_name         );
  20.     P.w_string          (s_name_replace );
  21.     P.w_u8              (s_gameid       );
  22.     P.w_u8              (s_RP           );
  23.     P.w_vec3            (o_Position     );
  24.     P.w_vec3            (o_Angle        );
  25.     P.w_u16             (RespawnTime    );
  26.     P.w_u16             (ID             );
  27.     P.w_u16             (ID_Parent      );
  28.     P.w_u16             (ID_Phantom     );
  29.     if (bLocal)         P.w_u16(u16(s_flags|M_SPAWN_OBJECT_LOCAL) );
  30.     else                P.w_u16(u16(s_flags&~(M_SPAWN_OBJECT_LOCAL|M_SPAWN_OBJECT_ASPLAYER)));
  31.  
  32.     // write specific data
  33.     u32 position        = P.w_tell      ();
  34.     P.w_u16             (0              );
  35.     STATE_Write         (P              );
  36.     u16 size            = u16           (P.w_tell()-position);
  37.     P.w_seek            (position,&size,sizeof(u16));
  38. }
  39.  
  40. void    xrServerEntity::Spawn_Read      (NET_Packet& P)
  41. {
  42.     u16                 dummy16;
  43.     // generic
  44.     P.r_begin           (dummy16        );  R_ASSERT(M_SPAWN==dummy16);
  45.     P.r_string          (s_name         );
  46.     P.r_string          (s_name_replace );
  47.     P.r_u8              (s_gameid       );
  48.     P.r_u8              (s_RP           );
  49.     P.r_vec3            (o_Position     );
  50.     P.r_vec3            (o_Angle        );
  51.     P.r_u16             (RespawnTime    );
  52.     P.r_u16             (ID             );
  53.     P.r_u16             (ID_Parent      );
  54.     P.r_u16             (ID_Phantom     );
  55.     P.r_u16             (s_flags        );
  56.  
  57.     // read specific data
  58.     u16                 size;
  59.     P.r_u16             (size           );  // size
  60.     STATE_Read          (P,size         );
  61. }
  62.  
  63. #ifdef _EDITOR
  64. xr_token game_types[]={
  65.     { "Any game",       GAME_ANY        },
  66.     { "Single",         GAME_SINGLE     },
  67.     { "Deathmatch",     GAME_DEATHMATCH },
  68.     { "CTF",            GAME_CTF        },
  69.     { "Assault",        GAME_ASSAULT    },
  70.     { "Counter Strike", GAME_CS         },
  71.     { 0,                0               }
  72. };
  73. void    xrServerEntity::FillProp    (LPCSTR pref, PropValueVec& values)
  74. {
  75.     FILL_PROP_EX(values,    pref, "Game Type",      &s_gameid,      PROP::CreateToken(game_types,1));
  76.     FILL_PROP_EX(values,    pref, "Active",         &s_flags,       PROP::CreateFlag(M_SPAWN_OBJECT_ACTIVE));
  77.     FILL_PROP_EX(values,    pref, "Respawn Time (s)",&RespawnTime,  PROP::CreateU16(0,43200));
  78. }
  79. #endif
  80.  
  81. xrSE_Weapon::xrSE_Weapon()
  82. {
  83.     a_current           = 90;
  84.     a_elapsed           = 30;
  85. }
  86. void xrSE_Weapon::UPDATE_Read       (NET_Packet& P)
  87. {
  88.     P.r_u32             (timestamp);
  89.     P.r_u8              (flags);
  90.     P.r_u8              (state);
  91.  
  92.     P.r_u16             (a_current);
  93.     P.r_u16             (a_elapsed);
  94.  
  95.     P.r_vec3            (o_Position );
  96.     P.r_angle8          (o_Angle.x  );
  97.     P.r_angle8          (o_Angle.y  );
  98.     P.r_angle8          (o_Angle.z  );
  99. }
  100. void    xrSE_Weapon::UPDATE_Write   (NET_Packet& P)
  101. {
  102.     P.w_u32             (timestamp);
  103.     P.w_u8              (flags);
  104.     P.w_u8              (state);
  105.  
  106.     P.w_u16             (a_current);
  107.     P.w_u16             (a_elapsed);
  108.  
  109.     P.w_vec3            (o_Position );
  110.     P.w_angle8          (o_Angle.x  );
  111.     P.w_angle8          (o_Angle.y  );
  112.     P.w_angle8          (o_Angle.z  );
  113. }
  114. void    xrSE_Weapon::STATE_Read     (NET_Packet& P, u16 size)
  115. {
  116.     P.r_u16             (a_current);
  117.     P.r_u16             (a_elapsed);
  118. }
  119. void    xrSE_Weapon::STATE_Write    (NET_Packet& P)
  120. {
  121.     P.w_u16             (a_current);
  122.     P.w_u16             (a_elapsed);
  123. }
  124. #ifdef _EDITOR
  125. void    xrSE_Weapon::FillProp       (LPCSTR pref, PropValueVec& values)
  126.     {
  127.         inherited::FillProp(pref, values);
  128.         FILL_PROP_EX(values,PROP::PrepareKey(pref,s_name), "Ammo: total",       &a_current, PROP::CreateU16(0,1000,1));
  129.         FILL_PROP_EX(values,PROP::PrepareKey(pref,s_name), "Ammo: in magazine", &a_elapsed, PROP::CreateU16(0,30,1));
  130.     }
  131. #endif
  132.  
  133. //
  134. xrSE_Teamed::xrSE_Teamed()
  135. {
  136.     s_team = s_squad = s_group = 0;
  137. }
  138.  
  139. void    xrSE_Teamed::STATE_Read         (NET_Packet& P, u16 size)
  140. {
  141.     P.r_u8              (s_team );
  142.     P.r_u8              (s_squad);
  143.     P.r_u8              (s_group);
  144. }
  145. void    xrSE_Teamed::STATE_Write        (NET_Packet& P)
  146. {
  147.     P.w_u8              (s_team );
  148.     P.w_u8              (s_squad);
  149.     P.w_u8              (s_group);
  150. }
  151. void    xrSE_Teamed::UPDATE_Read        (NET_Packet& P) {};
  152. void    xrSE_Teamed::UPDATE_Write       (NET_Packet& P) {};
  153. #ifdef _EDITOR
  154. void    xrSE_Teamed::FillProp           (LPCSTR pref, PropValueVec& values)
  155. {
  156.     inherited::FillProp(pref,values);
  157.     FILL_PROP_EX(values,PROP::PrepareKey(pref,s_name), "Team",  &s_team,    PROP::CreateU8(0,64,1));
  158.     FILL_PROP_EX(values,PROP::PrepareKey(pref,s_name), "Squad", &s_squad,   PROP::CreateU8(0,64,1));
  159.     FILL_PROP_EX(values,PROP::PrepareKey(pref,s_name), "Group", &s_group,   PROP::CreateU8(0,64,1));
  160. }
  161. #endif
  162.  
  163. //***** Dummy
  164. xrSE_Dummy::xrSE_Dummy()
  165. {
  166.     s_Animation = 0;
  167.     s_Model     = 0;
  168.     s_Particles = 0;
  169.     s_Sound     = 0;
  170. }
  171. xrSE_Dummy::~xrSE_Dummy()
  172. {
  173.     _FREE               (s_Animation    );
  174.     _FREE               (s_Model        );
  175.     _FREE               (s_Particles    );
  176.     _FREE               (s_Sound        );
  177. }
  178. void xrSE_Dummy::STATE_Read         (NET_Packet& P, u16 size)
  179. {
  180.     P.r_u8              (s_style);
  181.  
  182.     if (s_style&esAnimated)     {
  183.         // Load animator
  184.         string256               fn;
  185.         P.r_string              (fn);
  186.         s_Animation             = xr_strdup(fn);
  187.     }
  188.     if (s_style&esModel)            {
  189.         // Load model
  190.         string256               fn;
  191.         P.r_string              (fn);
  192.         s_Model                 = xr_strdup(fn);
  193.     }
  194.     if (s_style&esParticles)        {
  195.         // Load model
  196.         string256               fn;
  197.         P.r_string              (fn);
  198.         s_Particles             = xr_strdup(fn);
  199.     }
  200.     if (s_style&esSound)            {
  201.         // Load model
  202.         string256               fn;
  203.         P.r_string              (fn);
  204.         s_Sound                 = xr_strdup(fn);
  205.     }
  206. }
  207. void xrSE_Dummy::STATE_Write        (NET_Packet& P)
  208. {
  209.     P.w_u8              (s_style        );
  210.     if (s_style&esAnimated)     P.w_string          (s_Animation    );
  211.     if (s_style&esModel)        P.w_string          (s_Model        );
  212.     if (s_style&esParticles)    P.w_string          (s_Particles    );
  213.     if (s_style&esSound)        P.w_string          (s_Sound        );
  214. }
  215. void xrSE_Dummy::UPDATE_Read        (NET_Packet& P) {};
  216. void xrSE_Dummy::UPDATE_Write       (NET_Packet& P) {};
  217. #ifdef _EDITOR
  218. void    xrSE_Dummy::FillProp            (LPCSTR pref, PropValueVec& values)
  219. {
  220.     inherited::FillProp(pref,values);
  221. }
  222. #endif
  223.  
  224. //***** MercuryBall
  225. void    xrSE_MercuryBall::UPDATE_Read   (NET_Packet& P)             {}
  226. void    xrSE_MercuryBall::UPDATE_Write  (NET_Packet& P)             {}
  227. void    xrSE_MercuryBall::STATE_Read    (NET_Packet& P, u16 size)   {}
  228. void    xrSE_MercuryBall::STATE_Write   (NET_Packet& P)             {}
  229.  
  230. #ifdef _EDITOR
  231. void    xrSE_MercuryBall::FillProp  (LPCSTR pref, PropValueVec& values)
  232. {
  233.     FILL_PROP_EX(values,    pref, "Model",      s_Model,        PROP::CreateObject());
  234. }
  235. #endif
  236. //
  237.  
  238.  
  239. //***** Car
  240. void xrSE_Car::STATE_Read           (NET_Packet& P, u16 size)   {inherited::STATE_Read(P,size); };
  241. void xrSE_Car::STATE_Write          (NET_Packet& P)             {inherited::STATE_Write(P);     };
  242. void xrSE_Car::UPDATE_Read          (NET_Packet& P) {};
  243. void xrSE_Car::UPDATE_Write         (NET_Packet& P) {};
  244. #ifdef _EDITOR
  245. void xrSE_Car::FillProp             (LPCSTR pref, PropValueVec& values)
  246. {
  247.     inherited::FillProp(pref,values);
  248. }
  249. #endif
  250.  
  251. //***** Crow
  252. void xrSE_Crow::STATE_Read          (NET_Packet& P, u16 size)   {};
  253. void xrSE_Crow::STATE_Write         (NET_Packet& P)             {};
  254. void xrSE_Crow::UPDATE_Read         (NET_Packet& P)             {};
  255. void xrSE_Crow::UPDATE_Write        (NET_Packet& P)             {};
  256. #ifdef _EDITOR
  257. void xrSE_Crow::FillProp            (LPCSTR pref, PropValueVec& values)
  258. {
  259.     inherited::FillProp(pref,values);
  260. }
  261. #endif
  262.  
  263. //***** Target
  264. void xrSE_Target::STATE_Read        (NET_Packet& P, u16 size)   {};
  265. void xrSE_Target::STATE_Write       (NET_Packet& P)             {};
  266. void xrSE_Target::UPDATE_Read       (NET_Packet& P)             {};
  267. void xrSE_Target::UPDATE_Write      (NET_Packet& P)             {};
  268. #ifdef _EDITOR
  269. void xrSE_Target::FillProp          (LPCSTR pref, PropValueVec& values)
  270. {
  271.     inherited::FillProp(pref,values);
  272. }
  273. #endif
  274.  
  275. //***** Health
  276. void xrSE_Health::STATE_Read        (NET_Packet& P, u16 size)   {   P.r_u8(amount); };
  277. void xrSE_Health::STATE_Write       (NET_Packet& P)             {   P.w_u8(amount); };
  278. void xrSE_Health::UPDATE_Read       (NET_Packet& P)             {};
  279. void xrSE_Health::UPDATE_Write      (NET_Packet& P)             {};
  280. #ifdef _EDITOR
  281. void xrSE_Health::FillProp          (LPCSTR pref, PropValueVec& values)
  282. {
  283.     inherited::FillProp(pref,values);
  284.     FILL_PROP_EX(values,    pref, "Health amount",  &amount,    PROP::CreateU8(0,255));
  285. }
  286. #endif
  287.  
  288. //***** Actor
  289. void xrSE_Actor::STATE_Read         (NET_Packet& P, u16 size)   {inherited::STATE_Read(P,size); };
  290. void xrSE_Actor::STATE_Write        (NET_Packet& P)             {inherited::STATE_Write(P);     };
  291. void xrSE_Actor::UPDATE_Read        (NET_Packet& P)
  292. {
  293.     P.r_u32             (timestamp  );
  294.     P.r_u8              (flags      );
  295.     P.r_vec3            (o_Position );
  296.     P.r_u16             (mstate     );
  297.     P.r_angle8          (model_yaw  );
  298.     P.r_angle8          (torso.yaw  );
  299.     P.r_angle8          (torso.pitch);
  300.     P.r_sdir            (accel      );
  301.     P.r_sdir            (velocity   );
  302.     P.r_float_q16       (fHealth,   -1000,1000);
  303.     P.r_float_q16       (fArmor,    -1000,1000);
  304.     P.r_u8              (weapon     );
  305. };
  306. void xrSE_Actor::UPDATE_Write       (NET_Packet& P)
  307. {
  308.     P.w_u32             (timestamp  );
  309.     P.w_u8              (flags      );
  310.     P.w_vec3            (o_Position );
  311.     P.w_u16             (mstate     );
  312.     P.w_angle8          (model_yaw  );
  313.     P.w_angle8          (torso.yaw  );
  314.     P.w_angle8          (torso.pitch);
  315.     P.w_sdir            (accel      );
  316.     P.w_sdir            (velocity   );
  317.     P.w_float_q16       (fHealth,   -1000,1000);
  318.     P.w_float_q16       (fArmor,    -1000,1000);
  319.     P.w_u8              (weapon     );
  320. }
  321. #ifdef _EDITOR
  322. void    xrSE_Actor::FillProp            (LPCSTR pref, PropValueVec& values)
  323. {
  324.     inherited::FillProp(pref,values);
  325. }
  326. #endif
  327.  
  328. //***** Enemy
  329. void xrSE_Enemy::STATE_Read         (NET_Packet& P, u16 size)   {inherited::STATE_Read(P,size); };
  330. void xrSE_Enemy::STATE_Write        (NET_Packet& P)             {inherited::STATE_Write(P);     };
  331. void xrSE_Enemy::UPDATE_Read        (NET_Packet& P)
  332. {
  333.     P.r_u32             (timestamp      );
  334.     P.r_u8              (flags          );
  335.     P.r_vec3            (o_Position     );
  336.     P.r_angle8          (o_model        );
  337.     P.r_angle8          (o_torso.yaw    );
  338.     P.r_angle8          (o_torso.pitch  );
  339. }
  340. void xrSE_Enemy::UPDATE_Write       (NET_Packet& P)
  341. {
  342.     P.w_u32             (timestamp      );
  343.     P.w_u8              (flags          );
  344.     P.w_vec3            (o_Position     );
  345.     P.w_angle8          (o_model        );
  346.     P.w_angle8          (o_torso.yaw    );
  347.     P.w_angle8          (o_torso.pitch  );
  348. }
  349. #ifdef _EDITOR
  350. void    xrSE_Enemy::FillProp            (LPCSTR pref, PropValueVec& values)
  351. {
  352.     inherited::FillProp(pref,values);
  353. }
  354. #endif
  355.  
  356. //***** CFormed (Base)
  357. class xrSE_CFormed
  358. {
  359. public:
  360.     union shape_data
  361.     {
  362.         Fsphere     sphere;
  363.         Fmatrix     box;
  364.     };
  365.     struct shape_def
  366.     {
  367.         u8          type;
  368.         shape_data  data;
  369.     };
  370.     vector<shape_def>   shapes;
  371. public:
  372.     void                    cform_read          (NET_Packet& P)
  373.     {
  374.         shapes.clear();
  375.         u8  count;  P.r_u8(count);
  376.         while (count) {
  377.             shape_def   S;
  378.             P.r_u8  (S.type);
  379.             switch  (S.type)
  380.             {
  381.             case 0: P.r         (&S.data.sphere,sizeof(S.data.sphere)); break;
  382.             case 1: P.r_matrix  (S.data.box);                           break;
  383.             }
  384.             shapes.push_back    (S);
  385.             count--;
  386.         }
  387.     }
  388.     void                    cform_write         (NET_Packet& P)
  389.     {
  390.         P.w_u8  (u8(shapes.size()));
  391.         for (u32 i=0; i<shapes.size(); i++)
  392.         {
  393.             shape_def&  S   = shapes[i];
  394.             P.w_u8  (S.type);
  395.             switch (S.type)
  396.             {
  397.             case 0: P.w         (&S.data.sphere,sizeof(S.data.sphere)); break;
  398.             case 1: P.w_matrix  (S.data.box);                           break;
  399.             }
  400.         }
  401.     }
  402. };
  403.  
  404. class xrSE_Event : public xrSE_CFormed, public xrServerEntity
  405. {
  406.     typedef xrServerEntity      inherited;
  407. public: // actions
  408.     struct tAction
  409.     {
  410.         u8      type;
  411.         u16     count;
  412.         u64     cls;
  413.         LPSTR   event;
  414.     };
  415.     vector<tAction>         Actions;
  416.  
  417.     void                    Actions_clear()
  418.     {
  419.         for (u32 a=0; a<Actions.size(); a++)
  420.             _FREE(Actions[a].event);
  421.         Actions.clear   ();
  422.     }
  423. public:
  424.     virtual void            UPDATE_Read         (NET_Packet& P)
  425.     {
  426.     }
  427.     virtual void            UPDATE_Write        (NET_Packet& P)
  428.     {
  429.     }
  430.     virtual void            STATE_Read          (NET_Packet& P, u16 size)
  431.     {
  432.         // CForm
  433.         cform_read          (P);
  434.  
  435.         // Actions
  436.         Actions_clear       ();
  437.         u8 count;   P.r_u8  (count);
  438.         while (count)   {
  439.             tAction     A;
  440.             string512   str;
  441.             P.r_u8      (A.type);
  442.             P.r_u16     (A.count);
  443.             P.r_u64     (A.cls);
  444.             P.r_string  (str);
  445.             A.event     = xr_strdup(str);
  446.             Actions.push_back(A);
  447.             count--;
  448.         }
  449.     }
  450.     virtual void            STATE_Write         (NET_Packet& P)
  451.     {
  452.         // CForm
  453.         cform_write         (P);
  454.  
  455.         // Actions
  456.         P.w_u8              (u8(Actions.size()));
  457.         for (u32 i=0; i<Actions.size(); i++)
  458.         {
  459.             tAction&    A = Actions[i];
  460.             P.w_u8      (A.type );
  461.             P.w_u16     (A.count);
  462.             P.w_u64     (A.cls  );
  463.             P.w_string  (A.event);
  464.         }
  465.     }
  466. };
  467.  
  468. //--------------------------------------------------------------------
  469. xrServerEntity* F_entity_Create     (LPCSTR name)
  470. {
  471.     if (!pSettings->SectionExists(name)) return 0;
  472.    
  473.     CLASS_ID cls = pSettings->ReadCLSID(name,"class");
  474.  
  475.     switch (cls){
  476.     case CLSID_OBJECT_ACTOR:        return new  xrSE_Actor;
  477.     case CLSID_OBJECT_DUMMY:        return new  xrSE_Dummy;
  478.     case CLSID_AI_RAT:              return new  xrSE_Enemy;
  479.     case CLSID_AI_SOLDIER:          return new  xrSE_Enemy;
  480.     case CLSID_AI_ZOMBIE:           return new  xrSE_Enemy;
  481.     case CLSID_AI_CROW:             return new  xrSE_Crow;
  482.     case CLSID_EVENT:               return new  xrSE_Event;
  483.     case CLSID_CAR_NIVA:            return new  xrSE_Car;
  484.  
  485.     // Artifacts
  486.     case CLSID_AF_MERCURY_BALL:     return new  xrSE_MercuryBall;
  487.  
  488.     case CLSID_OBJECT_W_M134:       return new  xrSE_Weapon;
  489.     case CLSID_OBJECT_W_FN2000:     return new  xrSE_Weapon;
  490.     case CLSID_OBJECT_W_AK74:       return new  xrSE_Weapon;
  491.     case CLSID_OBJECT_W_LR300:      return new  xrSE_Weapon;
  492.     case CLSID_OBJECT_W_HPSA:       return new  xrSE_Weapon;
  493.     case CLSID_OBJECT_W_PM:         return new  xrSE_Weapon;
  494.     case CLSID_OBJECT_W_FORT:       return new  xrSE_Weapon;
  495.     case CLSID_OBJECT_W_BINOCULAR:  return new  xrSE_Weapon;
  496.     case CLSID_OBJECT_HEALTH:       return new  xrSE_Health;
  497.     case CLSID_TARGET:              return new  xrSE_Target;
  498.     }
  499.     return 0;
  500. }
  501.  
  502. void            F_entity_Destroy    (xrServerEntity* P)
  503. {
  504.     _DELETE     (P);
  505. }
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!