BVB Source Codes

CRYENGINE Show ScriptBind_GameStatistics.cpp Source code

Return Download CRYENGINE: download ScriptBind_GameStatistics.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 "ScriptBind_GameStatistics.h"
  5. #include "GameStatistics.h"
  6. #include "CryActionCVars.h"
  7.  
  8. static const char* GLOBAL_NAME = "GameStatistics";
  9. static const size_t MAX_SCRIPT_MATCH_FEATURES = 20;
  10.  
  11. void SaveLuaStatToXML(XmlNodeRef& node, const ScriptAnyValue& value);
  12. void SaveLuaToXML(XmlNodeRef node, const char* name, const ScriptAnyValue& value);
  13.  
  14. CScriptBind_GameStatistics::CScriptBind_GameStatistics(CGameStatistics* pGS) : m_pGS(pGS), m_pSS(gEnv->pScriptSystem)
  15. {
  16.         Init(m_pSS, gEnv->pSystem, 1);
  17.         RegisterMethods();
  18.         RegisterGlobals();
  19.  
  20.         SmartScriptTable t(m_pSS);
  21.         t->SetValue("__this", ScriptHandle(m_pGS));
  22.         t->Delegate(GetMethodsTable());
  23.         m_pSS->SetGlobalValue(GLOBAL_NAME, t);
  24. }
  25.  
  26. CScriptBind_GameStatistics::~CScriptBind_GameStatistics()
  27. {
  28.         m_pSS->SetGlobalToNull(GLOBAL_NAME);
  29. }
  30.  
  31. void CScriptBind_GameStatistics::RegisterMethods()
  32. {
  33. #undef SCRIPT_REG_CLASSNAME
  34. #define SCRIPT_REG_CLASSNAME &CScriptBind_GameStatistics::
  35.         SCRIPT_REG_TEMPLFUNC(PushGameScope, "scopeID");
  36.         SCRIPT_REG_TEMPLFUNC(PopGameScope, "");
  37.         SCRIPT_REG_TEMPLFUNC(AddGameElement, "");
  38.         SCRIPT_REG_TEMPLFUNC(CurrentScope, "");
  39.         SCRIPT_REG_TEMPLFUNC(RemoveGameElement, "");
  40.         SCRIPT_REG_TEMPLFUNC(Event, "event, params");
  41.         SCRIPT_REG_TEMPLFUNC(StateValue, "state, value");
  42. #undef SCRIPT_REG_CLASSNAME
  43. }
  44.  
  45. void CScriptBind_GameStatistics::RegisterGlobals()
  46. {
  47.         size_t numEventTypes = m_pGS->GetEventCount();
  48.         for (size_t i = 0; i != numEventTypes; ++i)
  49.                 gEnv->pScriptSystem->SetGlobalValue(m_pGS->GetEventDesc(i)->scriptName, static_cast<int>(i));
  50.  
  51.         size_t numStateTypes = m_pGS->GetStateCount();
  52.         for (size_t i = 0; i != numStateTypes; ++i)
  53.                 gEnv->pScriptSystem->SetGlobalValue(m_pGS->GetStateDesc(i)->scriptName, static_cast<int>(i));
  54.  
  55.         size_t numScopeTypes = m_pGS->GetScopeCount();
  56.         for (size_t i = 0; i != numScopeTypes; ++i)
  57.                 gEnv->pScriptSystem->SetGlobalValue(m_pGS->GetScopeDesc(i)->scriptName, static_cast<int>(i));
  58.  
  59.         size_t numElemTypes = m_pGS->GetElementCount();
  60.         for (size_t i = 0; i != numElemTypes; ++i)
  61.         {
  62.                 const SGameElementDesc* desc = m_pGS->GetElementDesc(i);
  63.                 gEnv->pScriptSystem->SetGlobalValue(desc->scriptName, static_cast<int>(i));
  64.                 gEnv->pScriptSystem->SetGlobalValue(desc->locatorName, static_cast<int>(desc->locatorID));
  65.         }
  66. }
  67.  
  68. IGameStatistics* CScriptBind_GameStatistics::GetStats(IFunctionHandler* pH)
  69. {
  70.         if (void* pThis = pH->GetThis())
  71.                 return static_cast<IGameStatistics*>(pThis);
  72.         return 0;
  73. }
  74.  
  75. bool CScriptBind_GameStatistics::BindTracker(IScriptTable* pT, const char* name, IStatsTracker* tracker)
  76. {
  77. #if STATISTICS_CHECK_BINDING
  78.         m_boundTrackers.insert(tracker);
  79. #endif
  80.         SmartScriptTable t(m_pSS);
  81.         t->SetValue("__this", ScriptHandle(tracker));
  82.         t->Delegate(GetMethodsTable());
  83.         pT->SetValue(name, t);
  84.         return true;
  85. }
  86.  
  87. bool CScriptBind_GameStatistics::UnbindTracker(IScriptTable* pT, const char* name, IStatsTracker* tracker)
  88. {
  89. #if STATISTICS_CHECK_BINDING
  90.         stl::member_find_and_erase(m_boundTrackers, tracker);
  91. #endif
  92.         if (pT)
  93.         {
  94.                 ScriptHandle h;
  95.                 SmartScriptTable tr;
  96.                 if (pT->GetValue(name, tr) && tr->GetValue("__this", h) && tracker == h.ptr)
  97.                 {
  98.                         pT->SetToNull(name);
  99.                         return true;
  100.                 }
  101.                 else
  102.                 {
  103.                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "[Telemetry] Error unbinding tracker");
  104.                         return false;
  105.                 }
  106.         }
  107.         return false;
  108. }
  109.  
  110. int CScriptBind_GameStatistics::PushGameScope(IFunctionHandler* pH, int scopeID)
  111. {
  112.         if (GetStats(pH) == m_pGS)
  113.         {
  114.                 m_pGS->PushGameScope(static_cast<size_t>(scopeID));
  115.         }
  116.         else
  117.         {
  118.                 m_pSS->RaiseError("[Telemetry] Error: PushGameScope() method is supported only by global %s object", GLOBAL_NAME);
  119.         }
  120.  
  121.         return pH->EndFunction();
  122. }
  123.  
  124. int CScriptBind_GameStatistics::PopGameScope(IFunctionHandler* pH)
  125. {
  126.         if (GetStats(pH) != m_pGS)
  127.         {
  128.                 m_pSS->RaiseError("[Telemetry] Error: PopGameScope() method is supported only by global %s object", GLOBAL_NAME);
  129.         }
  130.         else if (pH->GetParamCount() == 0)
  131.         {
  132.                 m_pGS->PopGameScope(INVALID_STAT_ID);
  133.         }
  134.         else if (pH->GetParamCount() == 1)
  135.         {
  136.                 int scopeID;
  137.                 pH->GetParam(1, scopeID);
  138.                 m_pGS->PopGameScope(static_cast<size_t>(scopeID));
  139.         }
  140.         else
  141.         {
  142.                 m_pSS->RaiseError("[Telemetry] Error: PopGameScope() expects 0 or 1 params.");
  143.         }
  144.  
  145.         return pH->EndFunction();
  146. }
  147.  
  148. //////////////////////////////////////////////////////////////////////////
  149.  
  150. int CScriptBind_GameStatistics::CurrentScope(IFunctionHandler* pH)
  151. {
  152.         int scope = m_pGS->GetScopeStackSize() != 0 ? (int)m_pGS->GetScopeID() : -1;
  153.         return pH->EndFunction(scope);
  154. }
  155.  
  156. //////////////////////////////////////////////////////////////////////////
  157.  
  158. // Syntax: GameStatistics.AddGameElement( scopeID, elementID, locatorID, locatorValue, table )
  159. int CScriptBind_GameStatistics::AddGameElement(IFunctionHandler* pH)
  160. {
  161.         if (GetStats(pH) != m_pGS)
  162.         {
  163.                 m_pSS->RaiseError("[Telemetry] Error: AddGameElement() method is supported only by global %s object", GLOBAL_NAME);
  164.         }
  165.         else if (pH->GetParamCount() != 4 && pH->GetParamCount() != 5)
  166.         {
  167.                 m_pSS->RaiseError("[Telemetry] Error: AddGameElement() expected 4 or 5 params.");
  168.         }
  169.         else
  170.         {
  171.                 if (pH->GetParamType(1) != svtNumber)
  172.                 {
  173.                         m_pSS->RaiseError("[Telemetry] AddGameElement() Param #1 expected Number.");
  174.                 }
  175.                 else if (pH->GetParamType(2) != svtNumber)
  176.                 {
  177.                         m_pSS->RaiseError("[Telemetry] AddGameElement() Param #2 expected Number.");
  178.                 }
  179.                 else if (pH->GetParamType(3) != svtNumber)
  180.                 {
  181.                         m_pSS->RaiseError("[Telemetry] AddGameElement() Param #3 expected Number.");
  182.                 }
  183.                 else if (pH->GetParamType(4) != svtNumber && pH->GetParamType(4) != svtPointer)
  184.                 {
  185.                         m_pSS->RaiseError("[Telemetry] AddGameElement() Param #4 expected Number or EntityID.");
  186.                 }
  187.                 else
  188.                 {
  189.                         uint32 scope, elem, locID;
  190.                         ScriptAnyValue anydata;
  191.                         pH->GetParam(1, scope);
  192.                         pH->GetParam(2, elem);
  193.                         pH->GetParam(3, locID);
  194.  
  195.                         ScriptAnyValue locVal;
  196.                         pH->GetParamAny(4, locVal);
  197.                         uint32 lv = locVal.type == ANY_TNUMBER ? (uint32)locVal.number : (uint32) reinterpret_cast<TRUNCATE_PTR>(locVal.ptr);
  198.  
  199.                         if (pH->GetParamCount() == 5)
  200.                                 pH->GetParamAny(5, anydata);
  201.  
  202.                         if (pH->GetParamCount() == 4 || anydata.type == ANY_TNIL)
  203.                         {
  204.                                 m_pGS->AddGameElement(SNodeLocator(elem, scope, locID, lv), 0);
  205.                         }
  206.                         else if (anydata.type == ANY_TTABLE)
  207.                         {
  208.                                 IStatsTracker* tracker = m_pGS->AddGameElement(SNodeLocator(elem, scope, locID, lv), anydata.table);
  209.                         }
  210.                         else
  211.                         {
  212.                                 m_pSS->RaiseError("[Telemetry] AddGameElement() Param #5 expected Table or Nil.");
  213.                         }
  214.                 }
  215.         }
  216.  
  217.         return pH->EndFunction();
  218. }
  219.  
  220. // Syntax: GameStatistics.RemoveGameElement( scopeID, elementID, locatorID, locatorValue )
  221. int CScriptBind_GameStatistics::RemoveGameElement(IFunctionHandler* pH)
  222. {
  223.         if (GetStats(pH) != m_pGS)
  224.         {
  225.                 m_pSS->RaiseError("[Telemetry] Error: RemoveGameElement() method is supported only by global %s object", GLOBAL_NAME);
  226.         }
  227.         else if (pH->GetParamCount() != 4 && pH->GetParamCount() != 5)
  228.         {
  229.                 m_pSS->RaiseError("[Telemetry] Error: RemoveGameElement() expected 4 params.");
  230.         }
  231.         else
  232.         {
  233.                 if (pH->GetParamType(1) != svtNumber)
  234.                 {
  235.                         m_pSS->RaiseError("[Telemetry] RemoveGameElement() Param #1 expected Number.");
  236.                 }
  237.                 else if (pH->GetParamType(2) != svtNumber)
  238.                 {
  239.                         m_pSS->RaiseError("[Telemetry] RemoveGameElement() Param #2 expected Number.");
  240.                 }
  241.                 else if (pH->GetParamType(3) != svtNumber)
  242.                 {
  243.                         m_pSS->RaiseError("[Telemetry] RemoveGameElement() Param #3 expected Number.");
  244.                 }
  245.                 else if (pH->GetParamType(4) != svtNumber && pH->GetParamType(4) != svtPointer)
  246.                 {
  247.                         m_pSS->RaiseError("[Telemetry] RemoveGameElement() Param #4 expected Number or EntityID.");
  248.                 }
  249.                 else
  250.                 {
  251.                         uint32 scope, elem, locID;
  252.                         pH->GetParam(1, scope);
  253.                         pH->GetParam(2, elem);
  254.                         pH->GetParam(3, locID);
  255.  
  256.                         ScriptAnyValue locVal;
  257.                         pH->GetParamAny(4, locVal);
  258.                         uint32 lv = locVal.type == ANY_TNUMBER ? (uint32)locVal.number : (uint32) reinterpret_cast<TRUNCATE_PTR>(locVal.ptr);
  259.  
  260.                         m_pGS->RemoveElement(SNodeLocator(elem, scope, locID, lv));
  261.                 }
  262.         }
  263.  
  264.         return pH->EndFunction();
  265. }
  266.  
  267. IStatsTracker* CScriptBind_GameStatistics::GetTracker(IFunctionHandler* pH)
  268. {
  269.         if (void* pThis = pH->GetThis())
  270.                 return static_cast<IStatsTracker*>(pThis);
  271.  
  272.         return 0;
  273. }
  274.  
  275. int CScriptBind_GameStatistics::Event(IFunctionHandler* pH)
  276. {
  277. #if STATS_MODE_CVAR
  278.         if (CCryActionCVars::Get().g_statisticsMode != 2)
  279.                 return pH->EndFunction();
  280. #endif
  281.  
  282.         IStatsTracker* tracker = GetTracker(pH);
  283.         if (!tracker)
  284.         {
  285.                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "[Telemetry] Event() tracker is nil");
  286.         }
  287. #if STATISTICS_CHECK_BINDING
  288.         else if (m_boundTrackers.find(tracker) == m_boundTrackers.end())
  289.         {
  290.                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "[Telemetry] Event() tracker is not bound");
  291.         }
  292. #endif
  293.         else if (pH->GetParamCount() != 2)
  294.         {
  295.                 m_pSS->RaiseError("[Telemetry] Error: Event() expected 2 params.");
  296.         }
  297.         else
  298.         {
  299.                 if (pH->GetParamType(1) != svtNumber && pH->GetParamType(1) != svtString)
  300.                 {
  301.                         m_pSS->RaiseError("[Telemetry] Event() Param #1 expected String or Number.");
  302.                 }
  303.                 else if (pH->GetParamType(2) == svtNull)
  304.                 {
  305.                         m_pSS->RaiseError("[Telemetry] Event() Param #2 is Null");
  306.                 }
  307.                 else if (pH->GetParamType(1) == svtNumber)
  308.                 {
  309.                         int id;
  310.                         pH->GetParam(1, id);
  311.                         ScriptAnyValue p;
  312.                         pH->GetParamAny(2, p);
  313.  
  314.                         if ((p.type == ANY_TTABLE || p.type == ANY_TVECTOR))
  315.                         {
  316.                                 XmlNodeRef node = m_pGS->CreateStatXMLNode();
  317.                                 SaveLuaStatToXML(node, p);
  318.                                 if (XmlNodeRef ch = (node->getChildCount() > 0) ? node->getChild(0) : XmlNodeRef(0))
  319.                                 {
  320.                                         SStatAnyValue statVal(m_pGS->WrapXMLNode(ch));
  321.                                         m_pGS->PreprocessScriptedEventParameter(id, statVal);
  322.                                         tracker->Event(id, statVal);
  323.                                 }
  324.                         }
  325.                         else
  326.                         {
  327.                                 SStatAnyValue statVal(p);
  328.                                 m_pGS->PreprocessScriptedEventParameter(id, statVal);
  329.                                 tracker->Event(id, statVal);
  330.                         }
  331.                 }
  332.                 else if (pH->GetParamType(1) == svtString)
  333.                 {
  334.                         const char* name = 0;
  335.                         pH->GetParam(1, name);
  336.                         ScriptAnyValue p;
  337.                         pH->GetParamAny(2, p);
  338.  
  339.                         size_t ev = m_pGS->GetEventID(name);
  340.                         if (ev == static_cast<size_t>(-1))
  341.                         {
  342.                                 ev = m_pGS->RegisterGameEvent(name, name);
  343.                                 if (ev == static_cast<size_t>(-1))
  344.                                         return pH->EndFunction();
  345.                         }
  346.  
  347.                         if ((p.type == ANY_TTABLE || p.type == ANY_TVECTOR))
  348.                         {
  349.                                 XmlNodeRef node = m_pGS->CreateStatXMLNode();
  350.                                 SaveLuaStatToXML(node, p);
  351.                                 if (XmlNodeRef ch = (node->getChildCount() > 0) ? node->getChild(0) : XmlNodeRef(0))
  352.                                 {
  353.                                         SStatAnyValue statVal(m_pGS->WrapXMLNode(ch));
  354.                                         m_pGS->PreprocessScriptedEventParameter(ev, statVal);
  355.                                         tracker->Event(ev, statVal);
  356.                                 }
  357.                         }
  358.                         else
  359.                         {
  360.                                 SStatAnyValue statVal(p);
  361.                                 m_pGS->PreprocessScriptedEventParameter(ev, statVal);
  362.                                 tracker->Event(ev, statVal);
  363.                         }
  364.                 }
  365.         }
  366.         return pH->EndFunction();
  367. }
  368.  
  369. int CScriptBind_GameStatistics::StateValue(IFunctionHandler* pH)
  370. {
  371. #if STATS_MODE_CVAR
  372.         if (CCryActionCVars::Get().g_statisticsMode != 2)
  373.                 return pH->EndFunction();
  374. #endif
  375.         IStatsTracker* tracker = GetTracker(pH);
  376.         if (!tracker)
  377.         {
  378.                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "[Telemetry] StateValue() tracker is nil");
  379.         }
  380. #if STATISTICS_CHECK_BINDING
  381.         else if (m_boundTrackers.find(tracker) == m_boundTrackers.end())
  382.         {
  383.                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "[Telemetry] StateValue() tracker is not bound");
  384.         }
  385. #endif
  386.         else if (pH->GetParamCount() != 2)
  387.         {
  388.                 m_pSS->RaiseError("[Telemetry] Error: StateValue() expected 2 params.");
  389.         }
  390.         else
  391.         {
  392.                 if (pH->GetParamType(1) != svtNumber && pH->GetParamType(1) != svtString)
  393.                 {
  394.                         m_pSS->RaiseError("[Telemetry] StateValue() Param #1 expected String or Number.");
  395.                 }
  396.                 else if (pH->GetParamType(2) == svtNull)
  397.                 {
  398.                         m_pSS->RaiseError("[Telemetry] StateValue() Param #2 is Null");
  399.                 }
  400.                 else if (pH->GetParamType(1) == svtNumber)
  401.                 {
  402.                         int id;
  403.                         pH->GetParam(1, id);
  404.                         ScriptAnyValue p;
  405.                         pH->GetParamAny(2, p);
  406.  
  407.                         if ((p.type == ANY_TTABLE || p.type == ANY_TVECTOR))
  408.                         {
  409.                                 XmlNodeRef node = m_pGS->CreateStatXMLNode();
  410.                                 SaveLuaStatToXML(node, p);
  411.                                 if (XmlNodeRef ch = (node->getChildCount() > 0) ? node->getChild(0) : XmlNodeRef(0))
  412.                                 {
  413.                                         SStatAnyValue statVal(m_pGS->WrapXMLNode(ch));
  414.                                         m_pGS->PreprocessScriptedStateParameter(id, statVal);
  415.                                         tracker->StateValue(id, statVal);
  416.                                 }
  417.                         }
  418.                         else
  419.                         {
  420.                                 SStatAnyValue statVal(p);
  421.                                 m_pGS->PreprocessScriptedStateParameter(id, statVal);
  422.                                 tracker->StateValue(id, statVal);
  423.                         }
  424.                 }
  425.                 else if (pH->GetParamType(1) == svtString)
  426.                 {
  427.                         const char* name = 0;
  428.                         pH->GetParam(1, name);
  429.                         ScriptAnyValue p;
  430.                         pH->GetParamAny(2, p);
  431.  
  432.                         size_t st = m_pGS->GetStateID(name);
  433.                         if (st == static_cast<size_t>(-1))
  434.                         {
  435.                                 st = m_pGS->RegisterGameState(name, name);
  436.                                 if (st == static_cast<size_t>(-1))
  437.                                         return pH->EndFunction();
  438.                         }
  439.  
  440.                         if ((p.type == ANY_TTABLE || p.type == ANY_TVECTOR))
  441.                         {
  442.                                 XmlNodeRef node = m_pGS->CreateStatXMLNode();
  443.                                 SaveLuaStatToXML(node, p);
  444.                                 if (XmlNodeRef ch = (node->getChildCount() > 0) ? node->getChild(0) : XmlNodeRef(0))
  445.                                 {
  446.                                         SStatAnyValue statVal(m_pGS->WrapXMLNode(ch));
  447.                                         m_pGS->PreprocessScriptedStateParameter(st, statVal);
  448.                                         tracker->StateValue(st, m_pGS->WrapXMLNode(ch));
  449.                                 }
  450.                         }
  451.                         else
  452.                         {
  453.                                 SStatAnyValue statVal(p);
  454.                                 m_pGS->PreprocessScriptedStateParameter(st, statVal);
  455.                                 tracker->StateValue(st, statVal);
  456.                         }
  457.                 }
  458.         }
  459.         return pH->EndFunction();
  460. }
  461.  
  462. void SaveLuaToXML(XmlNodeRef node, const char* name, const SmartScriptTable& table)
  463. {
  464.         XmlNodeRef c = gEnv->pSystem->CreateXmlNode(name);
  465.         IScriptTable::Iterator it = table->BeginIteration();
  466.         bool attributes = false;
  467.         while (table->MoveNext(it))
  468.         {
  469.                 if (it.sKey)
  470.                 {
  471.                         SaveLuaToXML(c, it.sKey, it.value);
  472.                         attributes = true;
  473.                 }
  474.                 else
  475.                 {
  476.                         //XmlNodeRef sub = gEnv->pSystem->CreateXmlNode(name);
  477.                         SmartScriptTable t;
  478.                         it.value.CopyTo(t);
  479.                         SaveLuaToXML(node, name, it.value);
  480.                         //node->addChild(sub);
  481.                 }
  482.         }
  483.         table->EndIteration(it);
  484.         if (attributes)
  485.                 node->addChild(c);
  486. }
  487.  
  488. void SaveVec3ToXML(XmlNodeRef node, const Vec3& a)
  489. {
  490.         node->setAttr("x", a.x);
  491.         node->setAttr("y", a.y);
  492.         node->setAttr("z", a.z);
  493. }
  494.  
  495. void SaveLuaToXML(XmlNodeRef node, const char* name, const ScriptAnyValue& value)
  496. {
  497.         switch (value.type)
  498.         {
  499.         case ANY_TBOOLEAN:
  500.                 node->setAttr(name, value.b);
  501.                 break;
  502.         case ANY_TNUMBER:
  503.                 node->setAttr(name, value.number);
  504.                 break;
  505.         case ANY_TSTRING:
  506.                 node->setAttr(name, value.str);
  507.                 break;
  508.         case ANY_THANDLE:
  509.                 node->setAttr(name, (UINT_PTR)(value.ud.ptr)); //[SergiyY] : ud.nRef contains trash atm; FIXME
  510.                 break;
  511.         case ANY_TVECTOR:
  512.                 {
  513.                         XmlNodeRef c = gEnv->pSystem->CreateXmlNode(name);
  514.                         SaveVec3ToXML(c, Vec3(value.vec3.x, value.vec3.y, value.vec3.z));
  515.                         node->addChild(c);
  516.                 }
  517.                 break;
  518.         case ANY_TTABLE:
  519.                 {
  520.                         SmartScriptTable t;
  521.                         value.CopyTo(t);
  522.                         SaveLuaToXML(node, name, t);
  523.                 }
  524.                 break;
  525.         }
  526. }
  527.  
  528. void SaveLuaStatToXML(XmlNodeRef& node, const ScriptAnyValue& value)
  529. {
  530.         if (!node)
  531.                 return;
  532.  
  533.         SaveLuaToXML(node, "param", value);
  534. }
  535.  
downloadScriptBind_GameStatistics.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