BVB Source Codes

CRYENGINE Show FlowVehicleSeat.cpp Source code

Return Download CRYENGINE: download FlowVehicleSeat.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #include "StdAfx.h"
  4. #include "FlowVehicleSeat.h"
  5.  
  6. #include "CryAction.h"
  7. #include "IVehicleSystem.h"
  8. #include "VehicleSystem/Vehicle.h"
  9. #include "VehicleSystem/VehicleSeat.h"
  10.  
  11. #include <CryFlowGraph/IFlowBaseNode.h>
  12.  
  13. IFlowNodePtr CFlowVehicleSeat::Clone(SActivationInfo* pActivationInfo)
  14. {
  15.         IFlowNode* pNode = new CFlowVehicleSeat(pActivationInfo);
  16.         return pNode;
  17. }
  18.  
  19. void CFlowVehicleSeat::GetConfiguration(SFlowNodeConfig& nodeConfig)
  20. {
  21.         CFlowVehicleBase::GetConfiguration(nodeConfig);
  22.  
  23.         static const SInputPortConfig pInConfig[] =
  24.         {
  25.                 InputPortConfig_Void("Trigger",  _HELP("Activates the node")),
  26.                 InputPortConfig<string>("Seat",  _HELP("Seat to (un)lock")),
  27.                 InputPortConfig<bool>("Lock",    _HELP("Action to perform, set to 1 to Lock and 0 to Unlock"),_HELP("(Un)Lock")),
  28.                 InputPortConfig<int>("LockType", 0,                                                           _HELP("Who to lock the vehicle for"), NULL,_UICONFIG("enum_int:All=0,Players=1,AI=2")),
  29.                 { 0 }
  30.         };
  31.  
  32.         static const SOutputPortConfig pOutConfig[] =
  33.         {
  34.                 OutputPortConfig<bool>("Success", _HELP("Activated when the seat (un)lock is successful or fails")),
  35.                 { 0 }
  36.         };
  37.  
  38.         nodeConfig.sDescription = _HELP("Lock and Unlock specific vehicle seats for AI or the Player");
  39.         nodeConfig.nFlags |= EFLN_TARGET_ENTITY;
  40.         nodeConfig.pInputPorts = pInConfig;
  41.         nodeConfig.pOutputPorts = pOutConfig;
  42.         nodeConfig.SetCategory(EFLN_APPROVED);
  43. }
  44.  
  45. void CFlowVehicleSeat::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  46. {
  47.         CFlowVehicleBase::ProcessEvent(event, pActInfo); // handles eFE_SetEntityId
  48.  
  49.         if (event == eFE_Activate)
  50.         {
  51.                 if (IsPortActive(pActInfo, eIn_Trigger))
  52.                 {
  53.                         bool bSuccess = false;
  54.  
  55.                         CVehicle* pVehicle = static_cast<CVehicle*>(GetVehicle());
  56.                         if (pVehicle)
  57.                         {
  58.                                 const string seatName = GetPortString(pActInfo, eIn_Seat);
  59.                                 CVehicleSeat* pSeat = static_cast<CVehicleSeat*>(pVehicle->GetSeatById(pVehicle->GetSeatId(seatName)));
  60.                                 if (pSeat)
  61.                                 {
  62.                                         bool bLock = GetPortBool(pActInfo, eIn_Lock);
  63.                                         if (bLock)
  64.                                         {
  65.                                                 EVehicleSeatLockStatus enumLockType = eVSLS_Locked;
  66.                                                 int intLockType = GetPortInt(pActInfo, eIn_LockType);
  67.                                                 switch (intLockType)
  68.                                                 {
  69.                                                 case 0:
  70.                                                         enumLockType = eVSLS_Locked;
  71.                                                         break;
  72.                                                 case 1:
  73.                                                         enumLockType = eVSLS_LockedForPlayers;
  74.                                                         break;
  75.                                                 case 2:
  76.                                                         enumLockType = eVSLS_LockedForAI;
  77.                                                         break;
  78.                                                 default:
  79.                                                         assert(false);
  80.                                                         break;
  81.                                                 }
  82.                                                 pSeat->SetLocked(enumLockType);
  83.                                                 bSuccess = true;
  84.                                         }
  85.                                         else
  86.                                         {
  87.                                                 pSeat->SetLocked(eVSLS_Unlocked);
  88.                                                 bSuccess = true;
  89.                                         }
  90.                                 }
  91.                         }
  92.  
  93.                         ActivateOutput(pActInfo, eOut_Success, bSuccess);
  94.                 }
  95.         }
  96. }
  97.  
  98. //////////////////////////////////////////////////////////////////////////
  99. class CFlowVehicleChangeSeat : public CFlowBaseNode<eNCT_Singleton>
  100. {
  101.         enum EInputPorts
  102.         {
  103.                 eINP_Trigger,
  104.                 eINP_VehicleId,
  105.                 eINP_Seat
  106.         };
  107.  
  108.         enum EOutputPorts
  109.         {
  110.                 eOUT_Success,
  111.         };
  112. public:
  113.         CFlowVehicleChangeSeat(SActivationInfo* pActInfo) {}
  114.         ~CFlowVehicleChangeSeat() {}
  115.  
  116.         virtual void GetConfiguration(SFlowNodeConfig& config)
  117.         {
  118.                 static const SInputPortConfig inp_config[] = {
  119.                         InputPortConfig_Void("Sync",           _HELP("Triggers the seat change"),                   _HELP("Trigger")),
  120.                         InputPortConfig<EntityId>("VehicleId", _HELP("Id of the vehicle which contains the seat")),
  121.                         InputPortConfig<string>("SeatNumber",  _HELP("New seat"),                                   _HELP("Seat"),    _UICONFIG("dt=vehicleSeats, ref_entity=VehicleId")),
  122.                         { 0 }
  123.                 };
  124.                 static const SOutputPortConfig out_config[] = {
  125.                         OutputPortConfig<bool>("Success", _HELP("Triggers when the node is processed, outputing 0 or 1 representing fail or success")),
  126.                         { 0 }
  127.                 };
  128.  
  129.                 config.sDescription = _HELP("Moves an actor from a seat to another one. Only works if the actor is already inside a vehicle");
  130.                 config.pInputPorts = inp_config;
  131.                 config.pOutputPorts = out_config;
  132.                 config.nFlags |= EFLN_TARGET_ENTITY;
  133.                 config.SetCategory(EFLN_APPROVED);
  134.         }
  135.  
  136.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  137.         {
  138.                 switch (event)
  139.                 {
  140.                 case eFE_Activate:
  141.                         {
  142.                                 if (IsPortActive(pActInfo, eINP_Trigger))
  143.                                 {
  144.                                         bool success = false;
  145.  
  146.                                         if (pActInfo->pEntity)
  147.                                         {
  148.                                                 EntityId actorEntityId = pActInfo->pEntity->GetId();
  149.                                                 EntityId vehicleId = GetPortInt(pActInfo, eINP_VehicleId);
  150.                                                 CVehicle* pVehicle = static_cast<CVehicle*>(CCryAction::GetCryAction()->GetIVehicleSystem()->GetVehicle(vehicleId));
  151.                                                 if (actorEntityId && pVehicle)
  152.                                                 {
  153.                                                         IActor* pActor = gEnv->pGameFramework->GetIActorSystem()->GetActor(actorEntityId);
  154.                                                         if (pActor && pActor->GetLinkedVehicle() == pVehicle)
  155.                                                         {
  156.                                                                 const string seatName = GetPortString(pActInfo, eINP_Seat);
  157.                                                                 TVehicleSeatId newSeatId = pVehicle->GetSeatId(seatName);
  158.  
  159.                                                                 pVehicle->ChangeSeat(actorEntityId, 0, newSeatId);
  160.                                                                 IVehicleSeat* pNewSeat = pVehicle->GetSeatForPassenger(actorEntityId);
  161.                                                                 success = pNewSeat && pNewSeat->GetSeatId() == newSeatId;
  162.                                                         }
  163.                                                 }
  164.                                         }
  165.                                         ActivateOutput(pActInfo, eOUT_Success, success);
  166.                                 }
  167.                                 break;
  168.                         }
  169.                 }
  170.         }
  171.  
  172.         virtual void GetMemoryUsage(ICrySizer* s) const
  173.         {
  174.                 s->Add(*this);
  175.         }
  176.  
  177. };
  178.  
  179. //////////////////////////////////////////////////////////////////////////
  180. class CFlowVehicleLock : public CFlowBaseNode<eNCT_Singleton>
  181. {
  182.         enum EInputPorts
  183.         {
  184.                 eINP_Lock = 0,
  185.                 eINP_Unlock,
  186.                 eINP_LockFor,
  187.         };
  188.  
  189. public:
  190.         CFlowVehicleLock(SActivationInfo* pActInfo) {}
  191.         ~CFlowVehicleLock() {}
  192.  
  193.         virtual void GetConfiguration(SFlowNodeConfig& config)
  194.         {
  195.                 static const SInputPortConfig inp_config[] = {
  196.                         InputPortConfig_Void("Lock",     _HELP("Locks the vehicle")),
  197.                         InputPortConfig_Void("Unlock",   _HELP("Unlocks the vehicle")),
  198.                         InputPortConfig<int>("LockType", 0,                            _HELP("Who to lock the vehicle for"),NULL, _UICONFIG("enum_int:All=0,Players=1,AI=2")),
  199.                         { 0 }
  200.                 };
  201.                 static const SOutputPortConfig out_config[] = {
  202.                         { 0 }
  203.                 };
  204.  
  205.                 config.sDescription = _HELP("Locks/Unlocks all seats of a vehicle");
  206.                 config.pInputPorts = inp_config;
  207.                 config.pOutputPorts = out_config;
  208.                 config.nFlags |= EFLN_TARGET_ENTITY;
  209.                 config.SetCategory(EFLN_APPROVED);
  210.         }
  211.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  212.         {
  213.                 switch (event)
  214.                 {
  215.                 case eFE_Activate:
  216.                         {
  217.                                 IVehicle* pVehicle = pActInfo->pEntity ? CCryAction::GetCryAction()->GetIVehicleSystem()->GetVehicle(pActInfo->pEntity->GetId()) : NULL;
  218.  
  219.                                 if (pVehicle)
  220.                                 {
  221.                                         int lockFor = GetPortInt(pActInfo, eINP_LockFor);
  222.  
  223.                                         if (IsPortActive(pActInfo, eINP_Lock))
  224.                                                 Lock(pVehicle, true, lockFor);
  225.                                         if (IsPortActive(pActInfo, eINP_Unlock))
  226.                                                 Lock(pVehicle, false, 0);
  227.                                 }
  228.                                 break;
  229.                         }
  230.                 }
  231.         }
  232.  
  233.         void Lock(IVehicle* pVehicle, bool lock, int lockFor)
  234.         {
  235.                 EVehicleSeatLockStatus lockType = eVSLS_Unlocked;
  236.                 if (lock)
  237.                 {
  238.                         switch (lockFor)
  239.                         {
  240.                         case 0:
  241.                                 lockType = eVSLS_Locked;
  242.                                 break;
  243.                         case 1:
  244.                                 lockType = eVSLS_LockedForPlayers;
  245.                                 break;
  246.                         case 2:
  247.                                 lockType = eVSLS_LockedForAI;
  248.                                 break;
  249.  
  250.                         default:
  251.                                 assert(false);
  252.                                 break;
  253.                         }
  254.                 }
  255.  
  256.                 for (uint32 i = 0; i < pVehicle->GetSeatCount(); ++i)
  257.                 {
  258.                         CVehicleSeat* pSeat = static_cast<CVehicleSeat*>(pVehicle->GetSeatById(i + 1));         // vehicle seats start at id 1
  259.                         if (pSeat)
  260.                         {
  261.                                 pSeat->SetLocked(lockType);
  262.                         }
  263.                 }
  264.         }
  265.  
  266.         virtual void GetMemoryUsage(ICrySizer* s) const
  267.         {
  268.                 s->Add(*this);
  269.         }
  270.  
  271. };
  272.  
  273. REGISTER_FLOW_NODE("Vehicle:Seat", CFlowVehicleSeat);
  274. REGISTER_FLOW_NODE("Vehicle:ChangeSeat", CFlowVehicleChangeSeat)
  275. REGISTER_FLOW_NODE("Vehicle:Lock", CFlowVehicleLock)
  276.  
downloadFlowVehicleSeat.cpp 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