SHARE
TWEET

xrServer_Entities.cpp

CUgopEntity Jan 23rd, 2019 15 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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. }
RAW Paste Data
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
 
Top