BVB Source Codes

CRYENGINE Show IGameRulesSystem.h Source code

Return Download CRYENGINE: download IGameRulesSystem.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /*************************************************************************
  4.    -------------------------------------------------------------------------
  5.    $Id$
  6.    $DateTime$
  7.    Description:
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 20:10:2004   10:30 : Created by Craig Tiller
  12.  
  13. *************************************************************************/
  14. #ifndef __IGAMERULES_H__
  15. #define __IGAMERULES_H__
  16.  
  17. #pragma once
  18.  
  19. #include "IGameObject.h"
  20. #include <CryParticleSystem/IParticles.h>
  21.  
  22. // Summary
  23. //   Types for the different kind of messages.
  24. enum ETextMessageType
  25. {
  26.         eTextMessageCenter = 0,
  27.         eTextMessageConsole, // Console message.
  28.         eTextMessageError,   // Error message.
  29.         eTextMessageInfo,    // Info message.
  30.         eTextMessageServer,
  31.         eTextMessageAnnouncement
  32. };
  33.  
  34. // Summary
  35. //   Types for the different kind of chat messages.
  36. enum EChatMessageType
  37. {
  38.         eChatToTarget = 0, // The message is to be sent to the target entity.
  39.         eChatToTeam,       // The message is to be sent to the team of the sender.
  40.         eChatToAll         // The message is to be sent to all client connected.
  41. };
  42.  
  43. // Summary
  44. //      Friendly fire types for explosions
  45. enum EFriendyFireType
  46. {
  47.         eFriendyFireNone = 0,
  48.         eFriendyFireSelf,   //doesn't hurt shooter
  49.         eFriendyFireTeam,   //doesn't hurt shooter or shooter's teammates
  50. };
  51.  
  52. // Summary
  53. //      Types of resources to cache
  54. enum EGameResourceType
  55. {
  56.         eGameResourceType_Loadout = 0,
  57.         eGameResourceType_Item,
  58. };
  59.  
  60. // Summary
  61. //  Structure containing name of hit and associated flags.
  62. struct HitTypeInfo
  63. {
  64.         HitTypeInfo()
  65.                 : m_flags(0) {}
  66.         HitTypeInfo(const char* pName, int flags = 0)
  67.                 : m_name(pName)
  68.                 , m_flags(flags) {}
  69.  
  70.         string m_name;
  71.         int    m_flags;
  72. };
  73.  
  74. // Summary
  75. //   Structure to describe an hit
  76. // Description
  77. //   This structure is used with the GameRules to create an hit.
  78. // See Also
  79. //   ExplosionInfo
  80. struct HitInfo
  81. {
  82.         EntityId shooterId;    // EntityId of the shooter
  83.         EntityId targetId;     // EntityId of the target which got shot
  84.         EntityId weaponId;     // EntityId of the weapon
  85.         EntityId projectileId; // 0 if hit was not caused by a projectile
  86.  
  87.         float    damage;       // damage count of the hit
  88.         float    impulseScale; // If this is non zero, this impulse will be applied to the partId set below.
  89.         float    radius;       // radius of the hit
  90.         float    angle;
  91.         int      material;   // material id of the surface which got hit
  92.         int      type;       // type id of the hit, see IGameRules::GetHitTypeId for more information
  93.         int      bulletType; //type of bullet, if hit was of type bullet
  94.  
  95.         float    damageMin;
  96.  
  97.         int      partId;
  98.  
  99.         Vec3     pos; // position of the hit
  100.         Vec3     dir; // direction of the hit
  101.         Vec3     normal;
  102.  
  103.         uint16   projectileClassId;
  104.         uint16   weaponClassId;
  105. #if USE_LAGOMETER
  106.         uint8    lagOMeterHitId;
  107. #endif
  108.  
  109.         bool remote;
  110.         bool aimed;          // set to true if shot was aimed - i.e. first bullet, zoomed in etc.
  111.         bool knocksDown;     // true if the hit should knockdown
  112.         bool knocksDownLeg;  // true if the hit should knockdown when hit in a leg
  113.         bool hitViaProxy;    // true if the 'shooter' didn't actually shoot, ie. a weapon acting on their behalf did (team perks)
  114.         bool explosion;      // true if this hit directly results from an explosion
  115.         bool forceLocalKill; // forces the hit to kill the victim + start hitdeathreaction/ragdoll NOT NET SERIALISED
  116.  
  117.         int  penetrationCount;    // number of surfaces the bullet has penetrated
  118.  
  119.         HitInfo()
  120.                 : shooterId(0),
  121.                 targetId(0),
  122.                 weaponId(0),
  123.                 projectileId(0),
  124.                 damage(0),
  125.                 impulseScale(0),
  126.                 damageMin(0),
  127.                 radius(0),
  128.                 angle(0),
  129.                 material(-1),
  130.                 partId(-1),
  131.                 type(0),
  132.                 pos(ZERO),
  133.                 dir(FORWARD_DIRECTION),
  134.                 normal(FORWARD_DIRECTION),
  135. #if USE_LAGOMETER
  136.                 lagOMeterHitId(0),
  137. #endif
  138.                 remote(false),
  139.                 bulletType(-1),
  140.                 aimed(false),
  141.                 knocksDown(false),
  142.                 knocksDownLeg(false),
  143.                 hitViaProxy(false),
  144.                 explosion(false),
  145.                 projectileClassId(~uint16(0)),
  146.                 weaponClassId(~uint16(0)),
  147.                 penetrationCount(0),
  148.                 forceLocalKill(false)
  149.         {}
  150.  
  151.         HitInfo(EntityId shtId, EntityId trgId, EntityId wpnId, float dmg, float rd, int mat, int part, int typ)
  152.                 : shooterId(shtId),
  153.                 targetId(trgId),
  154.                 weaponId(wpnId),
  155.                 projectileId(0),
  156.                 damage(dmg),
  157.                 impulseScale(0),
  158.                 radius(rd),
  159.                 angle(0),
  160.                 material(mat),
  161.                 partId(part),
  162.                 type(typ),
  163.                 pos(ZERO),
  164.                 dir(FORWARD_DIRECTION),
  165.                 normal(FORWARD_DIRECTION),
  166. #if USE_LAGOMETER
  167.                 lagOMeterHitId(0),
  168. #endif
  169.                 remote(false),
  170.                 bulletType(-1),
  171.                 aimed(false),
  172.                 damageMin(0),
  173.                 knocksDown(false),
  174.                 knocksDownLeg(false),
  175.                 hitViaProxy(false),
  176.                 explosion(false),
  177.                 projectileClassId(~uint16(0)),
  178.                 weaponClassId(~uint16(0)),
  179.                 penetrationCount(0),
  180.                 forceLocalKill(false)
  181.         {}
  182.  
  183.         HitInfo(EntityId shtId, EntityId trgId, EntityId wpnId, float dmg, float rd, int mat, int part, int typ, const Vec3& p, const Vec3& d, const Vec3& n)
  184.                 : shooterId(shtId),
  185.                 targetId(trgId),
  186.                 weaponId(wpnId),
  187.                 projectileId(0),
  188.                 damage(dmg),
  189.                 impulseScale(0),
  190.                 radius(rd),
  191.                 angle(0),
  192.                 material(mat),
  193.                 partId(part),
  194.                 type(typ),
  195.                 pos(p),
  196.                 dir(d),
  197.                 normal(n),
  198. #if USE_LAGOMETER
  199.                 lagOMeterHitId(0),
  200. #endif
  201.                 remote(false),
  202.                 bulletType(-1),
  203.                 aimed(false),
  204.                 damageMin(0),
  205.                 knocksDown(false),
  206.                 knocksDownLeg(false),
  207.                 hitViaProxy(false),
  208.                 explosion(false),
  209.                 projectileClassId(~uint16(0)),
  210.                 weaponClassId(~uint16(0)),
  211.                 penetrationCount(0),
  212.                 forceLocalKill(false)
  213.         {}
  214.  
  215.         // not all fields are serialized because this is used only for sending data over the net
  216.         void SerializeWith(TSerialize ser)
  217.         {
  218.                 ser.Value("shooterId", shooterId, 'eid');
  219.                 ser.Value("targetId", targetId, 'eid');
  220.                 ser.Value("weaponId", weaponId, 'eid');
  221.                 ser.Value("projectileId", projectileId, 'ui32'); //'eid');
  222.                 ser.Value("damage", damage, 'dmg');
  223.                 ser.Value("radius", radius, 'hRad');
  224.                 ser.Value("material", material, 'mat');
  225. #ifndef _RELEASE
  226.                 if (IsPartIDInvalid())
  227.                 {
  228.                         CryFatalError("HitInfo::SerializeWith - partId %i is out of range.", partId);
  229.                 }
  230. #endif
  231.                 ser.Value("partId", partId, 'part');
  232.                 ser.Value("type", type, 'hTyp');
  233.                 ser.Value("pos", pos, 'wrld');
  234.                 ser.Value("dir", dir, 'dir1');
  235.                 ser.Value("normal", normal, 'dir1');
  236. #if USE_LAGOMETER
  237.                 ser.Value("lagOMeterHitId", lagOMeterHitId, 'ui4');
  238. #endif
  239.                 ser.Value("bulletType", bulletType);
  240.                 //ser.Value("aimed", aimed);
  241.                 ser.Value("damageMin", damageMin);
  242.                 ser.Value("projectileClass", projectileClassId, 'ui16');
  243.                 ser.Value("weaponClass", weaponClassId, 'ui16');
  244.                 ser.Value("penetrationCount", penetrationCount, 'ui8');
  245.                 ser.Value("impulseScale", impulseScale, 'impS');
  246.         }
  247.  
  248.         void GetMemoryUsage(ICrySizer* pSizer) const
  249.         {
  250.                 pSizer->AddObject(this, sizeof(*this));
  251.         }
  252.  
  253. #ifndef _RELEASE
  254.         bool IsPartIDInvalid();
  255. #endif
  256. };
  257.  
  258. // Summary
  259. //   Structure to describe an explosion
  260. // Description
  261. //   This structure is used with the GameRules to create an explosion.
  262. // See Also
  263. //   HitInfo
  264. struct ExplosionInfo
  265. {
  266.         EntityId         shooterId; // Id of the shooter who triggered the explosion
  267.         EntityId         weaponId;  // Id of the weapon used to create the explosion
  268.         EntityId         projectileId;//Id of the "bullet" (grenade, claymore...) to create the explosion
  269.         uint16           projectileClassId;
  270.  
  271.         float            damage; // damage created by the explosion
  272.  
  273.         Vec3             pos;       // position of the explosion
  274.         Vec3             dir;       // direction of the explosion
  275.         float            minRadius; // min radius of the explosion
  276.         float            radius;    // max radius of the explosion
  277.         float            soundRadius;
  278.         float            minPhysRadius;
  279.         float            physRadius;
  280.         float            angle;
  281.         float            pressure; // pressure created by the explosion
  282.         float            hole_size;
  283.         IParticleEffect* pParticleEffect;
  284.         string           effect_name; // this is needed because we don't load particle effects on the dedicated server,
  285.                                       // so we need to store the name if we are going to send it
  286.         string           effect_class;
  287.         float            effect_scale;
  288.         int              type; // type id of the hit, see IGameRules::GetHitTypeId for more information
  289.  
  290.         bool             impact;
  291.         bool             propogate;
  292.         bool             explosionViaProxy; // true if the 'shooter' didn't actually shoot, ie. a weapon acting on their behalf did (team perks)
  293.  
  294.         Vec3             impact_normal;
  295.         Vec3             impact_velocity;
  296.         EntityId         impact_targetId;
  297.         float            maxblurdistance;
  298.         int              friendlyfire;
  299.  
  300.         //Flashbang params
  301.         float blindAmount;
  302.         float flashbangScale;
  303.  
  304.         int   firstPassPhysicsEntities; // Specify which physics types to hit on the first pass. defaults to 'ent_living', set to zero to disable
  305.  
  306.         ExplosionInfo()
  307.                 : shooterId(0),
  308.                 weaponId(0),
  309.                 projectileId(0),
  310.                 projectileClassId(~uint16(0)),
  311.                 damage(0),
  312.                 pos(ZERO),
  313.                 dir(FORWARD_DIRECTION),
  314.                 minRadius(2.5f),
  315.                 radius(5.0f),
  316.                 soundRadius(0.0f),
  317.                 minPhysRadius(2.5f),
  318.                 physRadius(5.0f),
  319.                 angle(0.0f),
  320.                 pressure(200.0f),
  321.                 hole_size(5.0f),
  322.                 pParticleEffect(0),
  323.                 type(0),
  324.                 effect_scale(1.0f),
  325.                 maxblurdistance(0.0f),
  326.                 friendlyfire(eFriendyFireNone),
  327.                 impact(false),
  328.                 impact_normal(FORWARD_DIRECTION),
  329.                 impact_velocity(ZERO),
  330.                 impact_targetId(0),
  331.                 blindAmount(0.0f),
  332.                 flashbangScale(1.0f),
  333.                 propogate(true),
  334.                 firstPassPhysicsEntities(ent_living),
  335.                 explosionViaProxy(false)
  336.         {
  337.         }
  338.  
  339.         ExplosionInfo(EntityId shtId, EntityId wpnId, EntityId prjId, float dmg, const Vec3& p, const Vec3& d, float minR, float r,
  340.                       float minPhysR, float physR, float a, float press, float holesize, int typ)
  341.                 : shooterId(shtId),
  342.                 weaponId(wpnId),
  343.                 projectileId(prjId),
  344.                 projectileClassId(~uint16(0)),
  345.                 damage(dmg),
  346.                 pos(p),
  347.                 dir(d),
  348.                 minRadius(minR),
  349.                 radius(r),
  350.                 soundRadius(0.0f),
  351.                 minPhysRadius(minPhysR),
  352.                 physRadius(physR),
  353.                 angle(a),
  354.                 pressure(press),
  355.                 hole_size(holesize),
  356.                 pParticleEffect(0),
  357.                 type(typ),
  358.                 effect_scale(1.0f),
  359.                 maxblurdistance(0.0f),
  360.                 friendlyfire(eFriendyFireNone),
  361.                 impact(false),
  362.                 impact_normal(FORWARD_DIRECTION),
  363.                 impact_velocity(ZERO),
  364.                 impact_targetId(0),
  365.                 blindAmount(0.0f),
  366.                 flashbangScale(1.0f),
  367.                 propogate(true),
  368.                 firstPassPhysicsEntities(ent_living),
  369.                 explosionViaProxy(false)
  370.         {
  371.  
  372.         }
  373.  
  374.         void SetImpact(const Vec3& normal, const Vec3& velocity, EntityId targetId)
  375.         {
  376.                 impact = true;
  377.                 impact_normal = normal;
  378.                 impact_velocity = velocity;
  379.                 impact_targetId = targetId;
  380.         }
  381.  
  382.         void SetEffect(const char* effectName, float scale, float maxblurdistance, float blindAmount = 0.0f, float flashbangScale = 1.0f)
  383.         {
  384.                 effect_name = effectName;
  385.                 effect_scale = scale;
  386.                 if (!effect_name.empty())
  387.                         pParticleEffect = gEnv->pParticleManager->FindEffect(effect_name.c_str());
  388.                 this->maxblurdistance = maxblurdistance;
  389.                 this->blindAmount = blindAmount;
  390.                 this->flashbangScale = flashbangScale;
  391.         }
  392.  
  393.         void SetEffectName(const char* effectName)
  394.         {
  395.                 this->effect_name = effectName;
  396.         }
  397.  
  398.         void SetEffectClass(const char* cls)
  399.         {
  400.                 effect_class = cls;
  401.         }
  402.  
  403.         void SetFriendlyFire(EFriendyFireType friendlyFireType)
  404.         {
  405.                 friendlyfire = friendlyFireType;
  406.         }
  407.  
  408.         void SerializeWith(TSerialize ser)
  409.         {
  410.                 const bool bNetwork = (ser.GetSerializationTarget() == eST_Network);
  411.                 ser.Value("shooterId", shooterId, 'eid');
  412.                 ser.Value("weaponId", weaponId, 'eid');
  413.                 ser.Value("projectileId", projectileId, 'eid');
  414.                 ser.Value("damage", damage, 'dmg');
  415.                 ser.Value("pos", pos, 'wrld');
  416.                 ser.Value("dir", dir, 'dir1');
  417.                 ser.Value("minRadius", minRadius, 'hRad');
  418.                 ser.Value("radius", radius, 'hRad');
  419.                 ser.Value("soundRadius", soundRadius, 'hRad');
  420.                 ser.Value("minPhysRadius", minPhysRadius, 'hRad');
  421.                 ser.Value("physRadius", physRadius, 'hRad');
  422.  
  423.                 if (!bNetwork)
  424.                 {
  425.                         ser.Value("angle", angle, 'hAng');
  426.                 }
  427.                 else
  428.                 {
  429.                         CRY_ASSERT_MESSAGE(angle == 0.0f, "Non zero explosion angles are not supported in multiplayer");
  430.                 }
  431.  
  432.                 ser.Value("pressure", pressure, 'hPrs');
  433.                 ser.Value("hole_size", hole_size, 'hHSz');
  434.                 ser.Value("type", type, 'hTyp');
  435.  
  436.                 ser.Value("effect_class", effect_class);
  437.                 ser.Value("friendlyfire", friendlyfire, 'spec');
  438.  
  439.                 //UK R&D working on CRCs / indicies for effects & materials
  440.                 if (ser.BeginOptionalGroup("effect", !effect_name.empty()))
  441.                 {
  442.                         if (ser.IsWriting())
  443.                         {
  444.                                 ser.Value("effect_name", effect_name);
  445.                         }
  446.                         else
  447.                         {
  448.                                 ser.Value("effect_name", effect_name);
  449.                                 pParticleEffect = gEnv->pParticleManager->FindEffect(effect_name.c_str());
  450.                         }
  451.                         ser.Value("effect_scale", effect_scale, 'hESc');
  452.                         ser.Value("maxblurdistance", maxblurdistance, 'iii');
  453.                         ser.EndGroup();
  454.                 }
  455.  
  456.                 if (ser.BeginOptionalGroup("flashbang", blindAmount != 0.0f))
  457.                 {
  458.                         ser.Value("blindAmount", blindAmount, 'hESc');
  459.                         ser.Value("flashbangScale", flashbangScale, 'hESc');
  460.                         ser.EndGroup();
  461.                 }
  462.  
  463.                 if (ser.BeginOptionalGroup("impact", impact))
  464.                 {
  465.                         if (ser.IsReading())
  466.                                 impact = true;
  467.                         ser.Value("impact_normal", impact_normal, 'dir1');
  468.                         ser.Value("impact_velocity", impact_velocity, 'pPVl');
  469.                         ser.Value("impact_targetId", impact_targetId, 'eid');
  470.                         ser.EndGroup();
  471.                 }
  472.         };
  473. };
  474.  
  475. // Summary
  476. //   Interface to implement an hit listener
  477. // See Also
  478. //   IGameRules, IGameRules::AddHitListener, IGameRules::RemoveHitListener
  479. struct IHitListener
  480. {
  481.         virtual ~IHitListener(){}
  482.         // Summary
  483.         //   Function called when the GameRules process an hit
  484.         // See Also
  485.         //   IGameRules
  486.         virtual void OnHit(const HitInfo&) = 0;
  487.  
  488.         // Summary
  489.         //   Function called when the GameRules process an explosion (client side)
  490.         // See Also
  491.         //   IGameRules
  492.         virtual void OnExplosion(const ExplosionInfo&) = 0;
  493.  
  494.         // Summary
  495.         //      Function called when the GameRules process an explosion (server side)
  496.         // See Also
  497.         //      IGameRules
  498.         virtual void OnServerExplosion(const ExplosionInfo&) = 0;
  499. };
  500.  
  501. // Summary
  502. //   Interface used to implement the game rules
  503. struct IGameRules : public IGameObjectExtension
  504. {
  505.         struct SGameCollision
  506.         {
  507.                 const EventPhysCollision* pCollision;
  508.                 IGameObject*              pSrc;
  509.                 IGameObject*              pTrg;
  510.                 IEntity*                  pSrcEntity;
  511.                 IEntity*                  pTrgEntity;
  512.         };
  513.         // Summary
  514.         //   Returns wether the disconnecting client should be kept for a few more moments or not.
  515.         virtual bool ShouldKeepClient(int channelId, EDisconnectionCause cause, const char* desc) const = 0;
  516.  
  517.         // Summary
  518.         //   Called after level loading, to precache anything needed.
  519.         virtual void PrecacheLevel() = 0;
  520.  
  521.         // Summary
  522.         //   Called from different subsystem to pre-cache needed game resources for the level
  523.         virtual void PrecacheLevelResource(const char* resourceName, EGameResourceType resourceType) = 0;
  524.  
  525.         // Summary
  526.         //       Checks to see whether the xml node ref exists in the precache map, keyed by filename. If it does, it returns it. If it doesn't, it returns a NULL ref
  527.         virtual XmlNodeRef FindPrecachedXmlFile(const char* sFilename) = 0;
  528.  
  529.         // client notification
  530.         virtual void OnConnect(struct INetChannel* pNetChannel) = 0;
  531.         virtual void OnDisconnect(EDisconnectionCause cause, const char* desc) = 0; // notification to the client that he has been disconnected
  532.  
  533.         // Summary
  534.         //   Notifies the server when a client is connecting
  535.         virtual bool OnClientConnect(int channelId, bool isReset) = 0;
  536.  
  537.         // Summary
  538.         //   Notifies the server when a client is disconnecting
  539.         virtual void OnClientDisconnect(int channelId, EDisconnectionCause cause, const char* desc, bool keepClient) = 0;
  540.  
  541.         // Summary
  542.         //   Notifies the server when a client has entered the current game
  543.         virtual bool OnClientEnteredGame(int channelId, bool isReset) = 0;
  544.  
  545.         // Summary
  546.         //   Notifies when an entity has spawn
  547.         virtual void OnEntitySpawn(IEntity* pEntity) = 0;
  548.  
  549.         // Summary
  550.         //   Notifies when an entity has been removed
  551.         virtual void OnEntityRemoved(IEntity* pEntity) = 0;
  552.  
  553.         // Summary
  554.         //   Notifies when an entity has been reused
  555.         virtual void OnEntityReused(IEntity* pEntity, SEntitySpawnParams& params, EntityId prevId) = 0;
  556.  
  557.         // Summary
  558.         //   Broadcasts a message to the clients in the game
  559.         // Parameters
  560.         //   type - indicated the message type
  561.         //   msg - the message to be sent
  562.         virtual void SendTextMessage(ETextMessageType type, const char* msg, uint32 to = eRMI_ToAllClients, int channelId = -1,
  563.                                      const char* p0 = 0, const char* p1 = 0, const char* p2 = 0, const char* p3 = 0) = 0;
  564.  
  565.         // Summary
  566.         //   Broadcasts a chat message to the clients in the game which are part of the target
  567.         // Parameters
  568.         //   type - indicated the message type
  569.         //   sourceId - EntityId of the sender of this message
  570.         //   targetId - EntityId of the target, used in case type is set to eChatToTarget
  571.         //   msg - the message to be sent
  572.         virtual void SendChatMessage(EChatMessageType type, EntityId sourceId, EntityId targetId, const char* msg) = 0;
  573.  
  574.         // Summary
  575.         //   Performs client tasks needed for an hit
  576.         // Parameters
  577.         //   hitInfo - structure holding all the information about the hit
  578.         // See Also
  579.         //   ServerHit, ServerSimpleHit
  580.         virtual void ClientHit(const HitInfo& hitInfo) = 0;
  581.  
  582.         // Summary
  583.         //   Performs server tasks needed for an hit
  584.         // Parameters
  585.         //   hitInfo - structure holding all the information about the hit
  586.         // See Also
  587.         //   ClientHit, ServerSimpleHit
  588.         virtual void ServerHit(const HitInfo& hitInfo) = 0;
  589.  
  590.         // Summary
  591.         //   Returns the Id of an HitType from its name
  592.         // Parameters
  593.         //   type - name of the HitType
  594.         // Returns
  595.         //   Id of the HitType
  596.         // See Also
  597.         //   HitInfo, GetHitType
  598.         virtual int GetHitTypeId(const uint32 crc) const = 0;
  599.         virtual int GetHitTypeId(const char* type) const = 0;
  600.  
  601.         // Summary
  602.         //   Returns the name of an HitType from its id
  603.         // Parameters
  604.         //   id - Id of the HitType
  605.         // Returns
  606.         //   Name of the HitType
  607.         // See Also
  608.         //   HitInfo, GetHitTypeId
  609.         virtual const char* GetHitType(int id) const = 0;
  610.  
  611.         // Summary
  612.         //   Notifies that a vehicle got destroyed
  613.         virtual void OnVehicleDestroyed(EntityId id) = 0;
  614.  
  615.         // Summary
  616.         //   Notifies that a vehicle got submerged
  617.         virtual void OnVehicleSubmerged(EntityId id, float ratio) = 0;
  618.  
  619.         // Summary
  620.         //   Check if a player should be able to enter a vehicle
  621.         // Parameters
  622.         //   playerId - Id of the player attempting to enter a vehicle
  623.         virtual bool CanEnterVehicle(EntityId playerId) = 0;
  624.  
  625.         // Summary
  626.         //   Prepares an entity to be allowed to respawn
  627.         // Parameters
  628.         //   entityId - Id of the entity which needs to respawn
  629.         // See Also
  630.         //   HasEntityRespawnData, ScheduleEntityRespawn, AbortEntityRespawn
  631.         virtual void CreateEntityRespawnData(EntityId entityId) = 0;
  632.  
  633.         // Summary
  634.         //   Indicates if an entity has respawn data
  635.         // Description
  636.         //   Respawn data can be created used the function CreateEntityRespawnData.
  637.         // Parameters
  638.         //   entityId - Id of the entity which needs to respawn
  639.         // See Also
  640.         //   CreateEntityRespawnData, ScheduleEntityRespawn, AbortEntityRespawn
  641.         virtual bool HasEntityRespawnData(EntityId entityId) const = 0;
  642.  
  643.         // Summary
  644.         //   Schedules an entity to respawn
  645.         // Parameters
  646.         //   entityId - Id of the entity which needs to respawn
  647.         //   unique - if set to true, this will make sure the entity isn't spawn a
  648.         //            second time in case it currently exist
  649.         //   timer - time in second until the entity is respawned
  650.         // See Also
  651.         //   CreateEntityRespawnData, HasEntityRespawnData, AbortEntityRespawn
  652.         virtual void ScheduleEntityRespawn(EntityId entityId, bool unique, float timer) = 0;
  653.  
  654.         // Summary
  655.         //   Aborts a scheduled respawn of an entity
  656.         // Parameters
  657.         //   entityId - Id of the entity which needed to respawn
  658.         //   destroyData - will force the respawn data set by CreateEntityRespawnData
  659.         //                 to be removed
  660.         // See Also
  661.         //   CreateEntityRespawnData, CreateEntityRespawnData, ScheduleEntityRespawn
  662.         virtual void AbortEntityRespawn(EntityId entityId, bool destroyData) = 0;
  663.  
  664.         // Summary
  665.         //   Schedules an entity to be removed from the level
  666.         // Parameters
  667.         //   entityId - EntityId of the entity to be removed
  668.         //   timer - time in seconds until which the entity should be removed
  669.         //   visibility - performs a visibility check before removing the entity
  670.         // Remarks
  671.         //   If the visibility check has been requested, the timer will be restarted
  672.         //   in case the entity is visible at the time the entity should have been
  673.         //   removed.
  674.         // See Also
  675.         //   AbortEntityRemoval
  676.         virtual void ScheduleEntityRemoval(EntityId entityId, float timer, bool visibility) = 0;
  677.  
  678.         // Summary
  679.         //   Cancel the scheduled removal of an entity
  680.         // Parameters
  681.         //   entityId - EntityId of the entity which was scheduled to be removed
  682.         virtual void AbortEntityRemoval(EntityId entityId) = 0;
  683.  
  684.         // Summary
  685.         //   Registers a listener which will be called every time for every hit.
  686.         // Parameters
  687.         //   pHitListener - a pointer to the hit listener
  688.         // See Also
  689.         //   RemoveHitListener, IHitListener
  690.         virtual void AddHitListener(IHitListener* pHitListener) = 0;
  691.  
  692.         // Summary
  693.         //   Removes a registered hit listener
  694.         // Parameters
  695.         //   pHitListener - a pointer to the hit listener
  696.         // See Also
  697.         //   AddHitListener
  698.         virtual void RemoveHitListener(IHitListener* pHitListener) = 0;
  699.  
  700.         // Summary
  701.         //              Gets called when two entities collide, gamerules should dispatch this
  702.         //              call also to Script functions
  703.         // Parameters
  704.         //  pEvent - physics event containing the necessary info
  705.         virtual bool OnCollision(const SGameCollision& event) = 0;
  706.  
  707.         // Summary
  708.         //              Gets called when two entities collide, and determines if AI should receive stiulus
  709.         // Parameters
  710.         //  pEvent - physics event containing the necessary info
  711.         virtual void OnCollision_NotifyAI(const EventPhys* pEvent) = 0;
  712.  
  713.         // allows gamerules to extend the 'status' command
  714.         virtual void ShowStatus() = 0;
  715.  
  716.         // Summary
  717.         //    Checks if game time is limited
  718.         virtual bool IsTimeLimited() const = 0;
  719.  
  720.         // Summary
  721.         //    Gets remaining game time
  722.         virtual float GetRemainingGameTime() const = 0;
  723.  
  724.         // Summary
  725.         //    Sets remaining game time
  726.         virtual void SetRemainingGameTime(float seconds) = 0;
  727.  
  728.         // Clear all migrating players' details
  729.         virtual void ClearAllMigratingPlayers(void) = 0;
  730.  
  731.         // Summary
  732.         // Set the game channel for a migrating player name, returns the entityId for that player
  733.         virtual EntityId SetChannelForMigratingPlayer(const char* name, uint16 channelID) = 0;
  734.  
  735.         // Summary
  736.         // Store the details of a migrating player
  737.         virtual void StoreMigratingPlayer(IActor* pActor) = 0;
  738.  
  739.         // Summary
  740.         // Get the name of the team with the specified ID, or NULL if no team with that ID is known
  741.         virtual const char* GetTeamName(int teamId) const = 0;
  742. };
  743.  
  744. // Summary:
  745. //   Vehicle System interface
  746. // Description:
  747. //   Interface used to implement the vehicle system.
  748. struct IGameRulesSystem
  749. {
  750.         virtual ~IGameRulesSystem(){}
  751.         // Summary
  752.         //   Registers a new GameRules
  753.         // Parameters
  754.         //   pRulesName - The name of the GameRules, which should also be the name of the GameRules script
  755.         //   pExtensionName - The name of the IGameRules implementation which should be used by the GameRules
  756.         //   bUseScript - Whether or not to load and use a Lua script
  757.         // Returns
  758.         //   The value true will be returned if the GameRules could have been registered.
  759.         virtual bool RegisterGameRules(const char* pRulesName, const char* pExtensionName, bool bUseScript = true) = 0;
  760.  
  761.         // Summary
  762.         //   Creates a new instance for a GameRules
  763.         // Description
  764.         //   The EntitySystem will be requested to spawn a new entity representing the GameRules.
  765.         // Parameters
  766.         //   pRulesName - Name of the GameRules
  767.         // Returns
  768.         //   If it succeeds, true will be returned.
  769.         virtual bool CreateGameRules(const char* pRulesName) = 0;
  770.  
  771.         // Summary
  772.         //   Removes the currently active game from memory
  773.         // Descriptions
  774.         //   This function will request the EntitySystem to release the GameRules
  775.         //   entity. Additionally, the global g_gameRules script table will be freed.
  776.         // Returns
  777.         //   The value true will be returned upon completion.
  778.         virtual bool DestroyGameRules() = 0;
  779.  
  780.         // Summary
  781.         //   Adds an alias name for the specified game rules
  782.         virtual void AddGameRulesAlias(const char* gamerules, const char* alias) = 0;
  783.  
  784.         // Summary
  785.         //   Adds a default level location for the specified game rules. Level system will look up levels here.
  786.         virtual void AddGameRulesLevelLocation(const char* gamerules, const char* mapLocation) = 0;
  787.  
  788.         // Summary
  789.         //       Returns the ith map location for the specified game rules
  790.         virtual const char* GetGameRulesLevelLocation(const char* gamerules, int i) = 0;
  791.  
  792.         // Sumarry
  793.         //       Returns the correct gamerules name from an alias
  794.         virtual const char* GetGameRulesName(const char* alias) const = 0;
  795.  
  796.         // Summary
  797.         //   Determines if the specified GameRules has been registered
  798.         // Parameters
  799.         //   pRulesName - Name of the GameRules
  800.         virtual bool HaveGameRules(const char* pRulesName) = 0;
  801.  
  802.         // Summary
  803.         //   Sets one GameRules instance as the one which should be currently be used
  804.         // Parameters
  805.         //   pGameRules - a pointer to a GameRules instance
  806.         // Remarks
  807.         //   Be warned that this function won't set the script GameRules table. The
  808.         //   CreateGameRules will have to be called to do this.
  809.         virtual void SetCurrentGameRules(IGameRules* pGameRules) = 0;
  810.  
  811.         // Summary
  812.         //   Gets the currently used GameRules
  813.         // Returns
  814.         //   A pointer to the GameRules instance which is currently being used.
  815.         virtual IGameRules* GetCurrentGameRules() const = 0;
  816.  
  817.         ILINE IEntity*      GetCurrentGameRulesEntity()
  818.         {
  819.                 IGameRules* pGameRules = GetCurrentGameRules();
  820.  
  821.                 if (pGameRules)
  822.                         return pGameRules->GetEntity();
  823.  
  824.                 return 0;
  825.         }
  826. };
  827.  
  828. #endif
  829.  
downloadIGameRulesSystem.h Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top