engine_docs.h

Go to the documentation of this file.

// Auto-generated engine docs

typedef void AnyType;

class string
{
public:
  string operator=(const string&);
  string operator+=(const string&);
  bool operator==(const string&);
  int32 operator<(const string&);
  string operator+(string, const string&);
  uint32 length();
  void resize(uint32);
  uint32 get_length();
  void set_length(uint32);
  bool isEmpty();
  uint8 operator[](uint32);
  uint8 operator[](uint32);
  string operator=(double);
  string operator+=(double);
  string operator+(string, double);
  string operator+(double, string);
  string operator=(float);
  string operator+=(float);
  string operator+(string, float);
  string operator+(float, string);
  string operator=(int64);
  string operator+=(int64);
  string operator+(string, int64);
  string operator+(int64, string);
  string operator=(uint64);
  string operator+=(uint64);
  string operator+(string, uint64);
  string operator+(uint64, string);
  string operator=(bool);
  string operator+=(bool);
  string operator+(string, bool);
  string operator+(bool, string);
  string substr(uint32 start = 0, int32 count = -1);
  int32 findFirst(const string&, uint32 start = 0);
  int32 findFirstOf(const string&, uint32 start = 0);
  int32 findFirstNotOf(const string&, uint32 start = 0);
  int32 findLast(const string&, int32 start = -1);
  int32 findLastOf(const string&, int32 start = -1);
  int32 findLastNotOf(const string&, int32 start = -1);
  void insert(uint32 pos, const string& other);
  void erase(uint32 pos, int32 count = -1);
  array<string>* split(const string&);
  string toUpper();
  string toLower();
  void insert(int32 index, string str);
  void erase(int32 start, int32 length);
};
template<class T>
class array
{
public:
  T operator[](uint32 index);
  T operator[](uint32 index);
  array<T> operator=(const array<T>&);
  void insertAt(uint32 index, const T& value);
  void insertAt(uint32 index, const array<T>& arr);
  void insertLast(const T& value);
  void removeAt(uint32 index);
  void removeLast();
  void removeRange(uint32 start, uint32 count);
  uint32 length();
  void reserve(uint32 length);
  void resize(uint32 length);
  void sortAsc();
  void sortAsc(uint32 startAt, uint32 count);
  void sortDesc();
  void sortDesc(uint32 startAt, uint32 count);
  void reverse();
  int32 find(const T& value);
  int32 find(uint32 startAt, const T& value);
  int32 findByRef(const T& value);
  int32 findByRef(uint32 startAt, const T& value);
  bool operator==(const array<T>&);
  bool isEmpty();
  uint32 get_length();
  void set_length(uint32);
};
class dictionaryValue
{
public:
  dictionaryValue operator=(const dictionaryValue&);
  dictionaryValue opHndlAssign(const AnyType&);
  dictionaryValue operator=(const AnyType&);
  dictionaryValue operator=(double);
  dictionaryValue operator=(int64);
  explicit operator void();
  explicit operator void();
  explicit operator int64();
  explicit operator double();
};
class dictionary
{
public:
  dictionary operator=(const dictionary&);
  void set(const string&, const AnyType&);
  bool get(const string&, AnyType&);
  void set(const string&, const int64&);
  bool get(const string&, int64&);
  void set(const string&, const double&);
  bool get(const string&, double&);
  bool exists(const string&);
  bool isEmpty();
  uint32 getSize();
  bool delete(const string&);
  void deleteAll();
  array<string>* getKeys();
  dictionaryValue operator[](const string&);
  dictionaryValue operator[](const string&);
};
class ref
{
public:
  explicit operator void();
  ref opHndlAssign(const ref&);
  ref opHndlAssign(const AnyType&);
  bool operator==(const ref&);
  bool operator==(const AnyType&);
};
class utf8string
{
public:
  utf8string operator=(const string&);
  utf8string operator+=(const string&);
  utf8string insert(uint32 pos, const string& str);
  utf8string insert(uint32 pos, const utf8string& str);
  utf8string erase(uint32 pos, uint32 len = 1);
  utf8string substr(uint32 pos, uint32 len);
  int32 findFirst(const string&, uint32 start = 0);
  int32 findLast(const string&, int32 start = -1);
  uint32 length();
  uint32 size();
  string plain();
};
  class vec2
  {
  public:
    float x;
    float y;
  public:
    operator string();
    vec2 operator+=(const vec2&);
    vec2 operator-=(const vec2&);
    vec2 operator*=(const vec2&);
    vec2 operator/=(const vec2&);
    vec2 operator+=(const float&);
    vec2 operator-=(const float&);
    vec2 operator*=(const float&);
    vec2 operator/=(const float&);
    vec2 operator-(vec2, const vec2&);
    vec2 operator+(vec2, const vec2&);
    vec2 operator*(vec2, const vec2&);
    vec2 operator/(vec2, const vec2&);
    vec2 operator*(vec2, const float&);
    vec2 operator/(vec2, const float&);
  };
  class vec3
  {
  public:
    float x;
    float y;
    float z;
    float r;
    float g;
    float b;
  public:
    operator string();
    vec3 operator+=(const vec3&);
    vec3 operator-=(const vec3&);
    vec3 operator*=(const vec3&);
    vec3 operator/=(const vec3&);
    vec3 operator+=(const float&);
    vec3 operator-=(const float&);
    vec3 operator*=(const float&);
    vec3 operator/=(const float&);
    vec3 operator-(vec3, const vec3&);
    vec3 operator+(vec3, const vec3&);
    vec3 operator*(vec3, const vec3&);
    vec3 operator/(vec3, const vec3&);
    vec3 operator*(vec3, const float&);
    vec3 operator/(vec3, const float&);
    vec3 operator*(vec3, const mat3&);
  };
  class vec4
  {
  public:
    float x;
    float y;
    float z;
    float w;
    float r;
    float g;
    float b;
    float a;
  public:
    operator string();
    vec4 operator+=(const vec4&);
    vec4 operator-=(const vec4&);
    vec4 operator*=(const vec4&);
    vec4 operator/=(const vec4&);
    vec4 operator+=(const float&);
    vec4 operator-=(const float&);
    vec4 operator*=(const float&);
    vec4 operator/=(const float&);
    vec4 operator-(vec4, const vec4&);
    vec4 operator+(vec4, const vec4&);
    vec4 operator*(vec4, const vec4&);
    vec4 operator/(vec4, const vec4&);
    vec4 operator*(vec4, const float&);
    vec4 operator/(vec4, const float&);
    vec4 operator*(vec4, const mat4&);
  };
  class ivec2
  {
  public:
    int32 x;
    int32 y;
  public:
    operator string();
    ivec2 operator+=(const ivec2&);
    ivec2 operator-=(const ivec2&);
    ivec2 operator*=(const ivec2&);
    ivec2 operator/=(const ivec2&);
    ivec2 operator+=(const float&);
    ivec2 operator-=(const float&);
    ivec2 operator*=(const float&);
    ivec2 operator/=(const float&);
    ivec2 operator-(ivec2, const ivec2&);
    ivec2 operator+(ivec2, const ivec2&);
    ivec2 operator*(ivec2, const ivec2&);
    ivec2 operator/(ivec2, const ivec2&);
    ivec2 operator*(ivec2, const float&);
    ivec2 operator/(ivec2, const float&);
  };
  class ivec3
  {
  public:
    int32 x;
    int32 y;
    int32 z;
  public:
    operator string();
    ivec3 operator+=(const ivec3&);
    ivec3 operator-=(const ivec3&);
    ivec3 operator*=(const ivec3&);
    ivec3 operator/=(const ivec3&);
    ivec3 operator+=(const float&);
    ivec3 operator-=(const float&);
    ivec3 operator*=(const float&);
    ivec3 operator/=(const float&);
    ivec3 operator-(ivec3, const ivec3&);
    ivec3 operator+(ivec3, const ivec3&);
    ivec3 operator*(ivec3, const ivec3&);
    ivec3 operator/(ivec3, const ivec3&);
    ivec3 operator*(ivec3, const float&);
    ivec3 operator/(ivec3, const float&);
  };
  class ivec4
  {
  public:
    int32 x;
    int32 y;
    int32 z;
    int32 w;
  public:
    operator string();
    ivec4 operator+=(const ivec4&);
    ivec4 operator-=(const ivec4&);
    ivec4 operator*=(const ivec4&);
    ivec4 operator/=(const ivec4&);
    ivec4 operator+=(const float&);
    ivec4 operator-=(const float&);
    ivec4 operator*=(const float&);
    ivec4 operator/=(const float&);
    ivec4 operator-(ivec4, const ivec4&);
    ivec4 operator+(ivec4, const ivec4&);
    ivec4 operator*(ivec4, const ivec4&);
    ivec4 operator/(ivec4, const ivec4&);
    ivec4 operator*(ivec4, const float&);
    ivec4 operator/(ivec4, const float&);
  };
  class mat3
  {
  public:
    mat3 operator+=(const mat3&);
    mat3 operator-=(const mat3&);
    mat3 operator*=(const mat3&);
    mat3 operator/=(const mat3&);
    mat3 operator+=(const float&);
    mat3 operator-=(const float&);
    mat3 operator*=(const float&);
    mat3 operator/=(const float&);
    mat3 operator-(mat3, const mat3&);
    mat3 operator+(mat3, const mat3&);
    mat3 operator*(mat3, const mat3&);
    mat3 operator/(mat3, const mat3&);
    mat3 operator*(mat3, const float&);
    mat3 operator/(mat3, const float&);
    vec3 operator*(mat3, const vec3&);
  };
  class mat4
  {
  public:
    mat4 operator+=(const mat4&);
    mat4 operator-=(const mat4&);
    mat4 operator*=(const mat4&);
    mat4 operator/=(const mat4&);
    mat4 operator+=(const float&);
    mat4 operator-=(const float&);
    mat4 operator*=(const float&);
    mat4 operator/=(const float&);
    mat4 operator-(mat4, const mat4&);
    mat4 operator+(mat4, const mat4&);
    mat4 operator*(mat4, const mat4&);
    mat4 operator/(mat4, const mat4&);
    mat4 operator*(mat4, const float&);
    mat4 operator/(mat4, const float&);
    vec4 operator*(mat4, const vec4&);
  };

class ctime
{
public:
  int32 sec;
  int32 min;
  int32 hour;
  int32 mday;
  int32 mon;
  int32 year;
  int32 wday;
  int32 yday;
  int32 isdst;
};
  class UnitPtr
  {
  public:
    bool operator==(const UnitPtr&);

    UnitEventCallbackId RegisterEventCallback(UnitEventType event, ref script, string func);
    void UnregisterEventCallback(UnitEventCallbackId id);
    bool HasCallbacks(UnitEventType event);
    void TriggerCallbacks(UnitEventType event, SValue* args = null);

    void TagAsDebris(uint8 importance);
    bool IsLight();
    bool IsCollider();

    vec3 GetPosition();
    vec3 GetInterpolatedPosition(int32 idt);
    void SetPosition(const vec3& pos, bool smooth = false);
    void SetPosition(float x, float y, float z, bool smooth = false);
    void SetPositionZ(float z, bool smooth = false);
    void SetLayer(int32 layer);

    PhysicsBody* GetPhysicsBody();
    ref GetScriptBehavior();
    uint32 GetRoughPingDistance();
    void SetUpdateDistanceLimit(int32 dist);

    void SetUnitScene(string name, bool resetTime);
    void SetUnitScene(UnitScene* scene, bool resetTime);
    void SetUnitScene(CustomUnitScene* customScene, bool resetTime);
    UnitScene* GetCurrentUnitScene();
    UnitScene* GetUnitScene(string name);
    int32 GetUnitSceneTime();
    void SetUnitSceneTime(int32 time);
    float GetUnitTimeScale();
    void SetUnitTimeScale(float scale);
    vec2 FetchLocator(string name);
    SValue* FetchData(string name);

    int32 GetId();
    bool IsValid();
    vec2 GetMoveDir();
    UnitProducer GetUnitProducer();
    string GetDebugName();
    uint32 GetSlot();
    void SetHidden(bool hidden);
    bool IsHidden();
    void Destroy();
    bool IsDestroyed();

    void SetShouldCollide(bool collides);
    bool ShouldCollide();
    void SetShouldCollideWithSame(bool collides);
    bool ShouldCollideWithSame();
    void SetCollisionTeam(uint16 team);
    uint16 GetCollisionTeam();

    EffectParams* CreateEffectParams(EffectParams* copy = null);
  };
  class UnitSource
  {
  public:
    void Add(UnitPtr unit);
    void Remove(UnitPtr unit);
    void Clear();
    void Replace(UnitPtr unit);
  };
  class UnitFeed
  {
  public:
    array<UnitPtr>* FetchAll();
    UnitPtr FetchFirst();
  };
  class Scene
  {
  public:
    array<RaycastResult>* Raycast(const vec2& from, const vec2& to, uint32 slots, RaycastType type);
    RaycastResult RaycastClosest(const vec2& from, const vec2& to, uint32 slots, RaycastType type);
    bool RaycastQuick(const vec2& from, const vec2& to, uint32 slots, RaycastType type);
    operator RaycastProvider*();
    void EnableLagCompensation(bool enable);
    RaycastProvider* LagCompensation(int32 ms);
    array<UnitPtr>* QueryRect(const vec2& center, uint32 width, uint32 height, uint32 slots, RaycastType type, bool getSensors = false);
    array<UnitPtr>* QueryCircle(const vec2& center, uint32 radius, uint32 slots, RaycastType type, bool getSensors = false);
    uint32 GetTime();
    UnitPtr GetUnit(int32 id);
    void Ping(array<vec2>* pos);
    array<vec2>* Pathfind(const vec2& from, const vec2& to, int32 diameter, float maxDistance = -1, float maxRange = -1);
    void QueuePathfind(UnitPtr owner, const vec2& from, const vec2& to, int32 diameter, float maxDistance = -1, float maxRange = -1);
    array<Tileset*>* FetchTilesets(const vec2& pos);
    array<UnitPtr>* FetchAllUnitsWithBehavior(string behavior, bool includeInherited = false);
    array<UnitPtr>* FetchAllUnitsWithBehavior(string behavior, vec2 center, int32 radius, bool includeInherited = false);
    array<UnitPtr>* FetchActorsWithOtherTeam(uint32 team, vec2 center, uint32 radius);
    array<UnitPtr>* FetchActorsWithTeam(uint32 team, vec2 center, uint32 radius);
    void QueueFetchActorsWithOtherTeam(UnitPtr owner, uint32 team, vec2 center, uint32 radius);
    void QueueFetchActorsWithTeam(UnitPtr owner, uint32 team, vec2 center, uint32 radius);
    array<UnitPtr>* FetchAllActorsWithOtherTeam(uint32 team);
    array<UnitPtr>* FetchAllActorsWithTeam(uint32 team);
    array<WorldScript*>* FetchAllWorldScripts(string type);
    array<WorldScript*>* FetchAllWorldScriptsWithComment(string type, string comment);
  };

  class SValue
  {
  public:
    SValueType GetType();
    array<SValue*>* GetArray();
    dictionary* GetDictionary();
    array<uint8>* GetByteArray();
    bool GetBoolean();
    float GetFloat();
    int32 GetInteger();
    string GetString();
    vec2 GetVector2();
    vec3 GetVector3();
    vec4 GetVector4();
    SValue* GetDictionaryEntry(string name);
    void Dump();
  };
  class SValueBuilder
  {
  public:
    void PushArray();
    void PopArray();
    void PushDictionary();
    void PopDictionary();
    void PushNull();
    void PushBoolean(bool val);
    void PushFloat(float val);
    void PushInteger(int32 val);
    void PushString(const string& val);
    void PushVector2(vec2 val);
    void PushVector3(vec3 val);
    void PushVector4(vec4 val);
    void PushDictionary(string name);
    void PushArray(string name);
    void PushNull(string name);
    void PushBoolean(string name, bool val);
    void PushFloat(string name, float val);
    void PushInteger(string name, int32 val);
    void PushString(string name, const string& val);
    void PushVector2(string name, vec2 val);
    void PushVector3(string name, vec3 val);
    void PushVector4(string name, vec4 val);
    SValue* Build();
  };

  class cvar_t
  {
  public:
    bool GetBool();
    float GetFloat();
    int32 GetInt();
    string GetString();
  };

  class Fixture
  {
  public:
    bool IsSensor();
  };
  class PhysicsBody
  {
  public:
    void SetLinearVelocity(const vec2& velocity);
    void SetLinearVelocity(float x, float y);
    vec2 GetLinearVelocity();
    bool IsStatic();
    void SetStatic(bool static);
    bool IsActive();
    void SetActive(bool static, Scene* scene = null);
    int32 GetEstimatedRadius();
  };
  class CollisionArea
  {
  public:
    void AddOnEnter(ref script, string func);
    void AddOnExit(ref script, string func);
    array<UnitPtr>* FetchAllInside(Scene* scene);
    bool IsEmpty();
  };

  class UnitScene
  {
  public:
    int32 Length();
    string GetName();
    SValue* FetchData(string name);
  };
  class UnitProducer
  {
  public:
    UnitPtr Produce(Scene* scene, const vec3& pos, int32 id = 0, uint32 rnd = 0);
    string GetDebugName();
    uint32 GetResourceHash();
    UnitScene* GetUnitScene(string name);
    array<string>* GetSceneSet(string name);
    NetSyncMode GetNetSyncMode();
  };
  class CustomUnitScene
  {
  public:
    int32 Length();
    string GetName();
    void Clear();
    void AddScene(UnitScene* scene, int32 timeOffset, vec2 posOffset, int16 layerOffset, int16 uLayerOffset);
  };
  class UnitEventCallbackId
  {
  };
  class EffectParams
  {
  public:
    void Set(string name, float value);
  };

  class SoundInstance
  {
  public:
    void SetPosition(vec3 pos);
    int32 GetLength();
    void Stop();
    bool IsPlaying();
    void SetPaused(bool paused);
    bool IsPaused();
    void SetLooped(bool looped);
    bool IsLooped();
    void SetVolume(float volume);
    float GetVolume();
    void SetParameter(string name, float value);
  };
  class SoundEvent
  {
  public:
    void Play();
    void Play(vec3 pos);
    SoundInstance* PlayTracked();
    SoundInstance* PlayTracked(vec3 pos);
    string GetName();
  };

  class Texture2D
  {
  public:
    int32 GetWidth();
    int32 GetHeight();
  };
  class TempTexture2D
  {
  public:
    int32 GetWidth();
    int32 GetHeight();
    Texture2D* GetTexture();
  };
  class Bitmap2D
  {
  public:
    int32 GetWidth();
    int32 GetHeight();
  };
  class BitmapString
  {
  public:
    int32 GetWidth();
    int32 GetHeight();
    void ResetColor();
    void SetColor(const vec4& color);
    void SetColorGradient(const vec4& color1, const vec4& color2, GradientDirection dir);
  };
  class BitmapFont
  {
  public:
    BitmapString* BuildText(const string& text, int32 width = -1, TextAlignment align = TextAlignment::Left);
    vec2 MeasureText(string text, int32 width = -1);
  };
  class Sprite
  {
  public:
    Texture2D* GetTexture2D();
    uint32 GetLength();
    int32 GetWidth();
    int32 GetHeight();
    vec4 GetFrame(int32 time);
  };
  class SpriteBatch
  {
  public:
    void Begin(int32 width, int32 height, float scale, bool grayscale = false);
    void End();
    void SetGrayscale(bool grayscale);
    void PushTransformation(const mat3& transform, const vec2& pivot);
    void PushTransformation(const mat4& transform);
    void PopTransformation();
    void PushClipping(const vec4& rect, bool inverse = false);
    void PopClipping();
    void PauseClipping();
    void ResumeClipping();
    void DrawString(const vec2& pos, BitmapString& string);
    void DrawLine(const vec2& from, const vec2& to, float thickness, const vec4& color);
    void DrawSprite(const vec2& pos, Sprite* sprite, uint32 time, const vec4& color = vec4(1,1,1,1));
    void DrawSprite(Texture2D* tex, const vec4& pos, const vec4& src, const vec4& color = vec4(1,1,1,1));
    void DrawSpriteRadial(const vec2& pos, Sprite* sprite, uint32 time, float r, const vec4& color = vec4(1,1,1,1));
    void DrawSpriteRadial(Texture2D* tex, const vec4& pos, const vec4& src, float r, const vec4& color = vec4(1,1,1,1));
    void DrawRectangle(const vec4& rect, const vec4& color, int32 thickness = 1);
    void FillRectangle(const vec4& rect, const vec4& color);
    void DrawUnitScene(const vec2& pos, const vec2& size, UnitScene* scene, uint32 time);
  };

  class RaycastResult
  {
  public:
    vec2 point;
    vec2 normal;
    float fraction;
  public:
    UnitPtr FetchUnit(Scene& scene);
  };
  class Tileset
  {
  public:
    int16 GetLayer();
    int32 GetTileSize();
    Texture2D* GetTexture();
    SValue* GetData();
  };

  class WorldScript
  {
  public:
    void Execute();
    void ClientExecute(SValue* param);
    bool IsExecutable();
    int32 GetTriggerTimes();
    bool IsEnabled();
    void SetTriggerTimes(int32 triggerTimes);
    void SetEnabled(bool enabled);
    string GetComment();
    UnitPtr GetUnit();
  };

class RaycastProvider
{
public:
  array<RaycastResult>* Raycast(const vec2& from, const vec2& to, uint32 slots, RaycastType type);
  RaycastResult RaycastClosest(const vec2& from, const vec2& to, uint32 slots, RaycastType type);
  bool RaycastQuick(const vec2& from, const vec2& to, uint32 slots, RaycastType type);
};
  class GUIDef
  {
  public:
    Sprite* GetSprite(const string& name);
  };
  class WidgetLoadingContext
  {
  public:
    string GetName();
    GUIDef* GetGUIDef();
    ref GetWidgetHost();
    bool GetBoolean(const string& name, bool required = true, bool def = false);
    float GetFloat(const string& name, bool required = true, float def = 0.);
    int32 GetInteger(const string& name, bool required = true, int32 def = 0);
    string GetString(const string& name, bool required = true, const string& def = "");
    vec2 GetVector2(const string& name, bool required = true, const vec2& def = vec2());
    vec3 GetVector3(const string& name, bool required = true, const vec3& def = vec3());
    vec4 GetVector4(const string& name, bool required = true, const vec4& def = vec4());
    vec3 GetColorRGB(const string& name, bool required = true, const vec3& def = vec3(1,1,1));
    vec4 GetColorRGBA(const string& name, bool required = true, const vec4& def = vec4(1,1,1,1));
    SValue* GetParams(const string& name, bool required = true);
  };
  class GUIBuilder
  {
  public:
    void AddWidgetProducer(string widget, WidgetProducer* prod);
    ref BuildGUI(GUIDef* gui);
    ref BuildGUI(GUIDef* gui, ref host);
  };

  class NetworkMessage
  {
  public:
    void SendToAll();
    void SendToHost();
    void SendToPeer(int32 peer);
    void SendToAllExcept(int32 peer);
    NetworkMessage operator<<(NetworkMessage, const string&);
    NetworkMessage operator<<(NetworkMessage, const int32&);
    NetworkMessage operator<<(NetworkMessage, const uint32&);
    NetworkMessage operator<<(NetworkMessage, const float&);
    NetworkMessage operator<<(NetworkMessage, const vec2&);
    NetworkMessage operator<<(NetworkMessage, const bool&);
    NetworkMessage operator<<(NetworkMessage, SValue*);
    NetworkMessage operator<<(NetworkMessage, const UnitPtr&);
  };

  class GameService
  {
  public:
    string GetMyName();
    uint64 GetMyID();
    void OpenUserProfile(uint64 id);
    void InviteToGame(uint64 id, const string& connString);
    bool IsMultiplayerAvailable();
    void UnlockAchievement(const string& key);
    void SetStatInt(const string& key, int32 set);
    void SetStatFloat(const string& key, float set);
    void IncreaseStatInt(const string& key, int32 add);
    void IncreaseStatFloat(const string& key, float add);
    void ResetAllStats();
    void InMenus(bool menus);
    bool ControllerInterface(uint64 handle);
  };

class pint
{
public:
  operator int32();
  bool operator==(const pint&);
  bool operator==(const int32&);
  int32 operator<(const pint&);
  int32 operator<(const int32&);
  pint operator++();
  pint operator--();
  pint operator+=(const pint&);
  pint operator-=(const pint&);
  pint operator*=(const pint&);
  pint operator/=(const pint&);
  pint operator+(pint, const pint&);
  pint operator-(pint, const pint&);
  pint operator*(pint, const pint&);
  pint operator/(pint, const pint&);
  pint operator+=(const int32&);
  pint operator-=(const int32&);
  pint operator*=(const int32&);
  pint operator/=(const int32&);
  pint operator+(pint, const int32&);
  pint operator-(pint, const int32&);
  pint operator*(pint, const int32&);
  pint operator/(pint, const int32&);
};
class pfloat
{
public:
  operator float();
  bool operator==(const pfloat&);
  bool operator==(const float&);
  int32 operator<(const pfloat&);
  int32 operator<(const float&);
  pfloat operator+=(const pfloat&);
  pfloat operator-=(const pfloat&);
  pfloat operator*=(const pfloat&);
  pfloat operator/=(const pfloat&);
  pfloat operator+(pfloat, const pfloat&);
  pfloat operator-(pfloat, const pfloat&);
  pfloat operator*(pfloat, const pfloat&);
  pfloat operator/(pfloat, const pfloat&);
  pfloat operator+=(const float&);
  pfloat operator-=(const float&);
  pfloat operator*=(const float&);
  pfloat operator/=(const float&);
  pfloat operator+(pfloat, const float&);
  pfloat operator-(pfloat, const float&);
  pfloat operator*(pfloat, const float&);
  pfloat operator/(pfloat, const float&);
};
  class ButtonState
  {
  public:
    bool Down;
    bool Pressed;
    bool Released;
    int32 Delta;
  };
  class TextInputControlEvent
  {
  public:
    utf8string text;
    TextInputControlEventType evt;
    bool select;
  };
  class GameInput
  {
  public:
    ButtonState Attack;
    ButtonState Reload;
    ButtonState Dash;
    ButtonState Use;
    ButtonState Netricsa;
    ButtonState Weapon1;
    ButtonState Weapon2;
    ButtonState Weapon3;
    ButtonState Weapon4;
    ButtonState Weapon5;
    ButtonState Weapon6;
    ButtonState Weapon7;
    ButtonState Weapon8;
    ButtonState NextWeapon;
    ButtonState PreviousWeapon;
    ButtonState ChangeWeapon;
    vec2 MoveDir;
    vec2 AimDir;
    vec2 MousePos;
    vec2 MousePosReal;
    bool MouseIsLocked;
    int32 MouseWheelDelta;
    bool UsingGamepad;
    bool UsingMouseLook;
  public:
    int32 GetTextInputCount();
    TextInputControlEvent* GetTextInput(int32 index);
  };
  class MenuInput
  {
  public:
    ButtonState Up;
    ButtonState Down;
    ButtonState Left;
    ButtonState Right;
    ButtonState Forward;
    vec2 MouseMove;
    ButtonState ChatAll;
    ButtonState ChatTeam;
  };
  class ControlMapBinding
  {
  public:
    string ID;
    string Action;
  };
  class ControlMap
  {
  public:
    string ID;
    int32 Index;
    bool UseMouseLook;
    bool Gamepad;
    bool Joystick;
  public:
    bool get_SteamController();
    uint64 get_Handle();
    array<ControlMapBinding*>* GetBindings();
    array<ControlMapBinding*>* GetStaging();
    void Clear();
    void Remove(ControlMapBinding* bind);
    void Add(ControllerType type, int32 key, const string& action);
    void ClearStaging();
    void RemoveStaging(ControlMapBinding* bind);
    void AddStaging(ControllerType type, int32 key, const string& action);
    void BeginStaging();
    void CommitStaging();
    void Defaults();
  };
  class ControlBindings
  {
  public:
    void Save();
    ControlMap* GetMap(const string& id);
    array<ControlMap*>* GetMaps();
    void ExpectTextInput();
    void StopExpectTextInput();
    void ExpectInput();
    array<string>* GetAvailableActions();
  };

  class ScenarioStartLevel
  {
  public:
    string GetName();
    string GetLevel();
  };
  class ScenarioModification
  {
  public:
    ScenarioModificationVisual GetVisual();
    string GetID();
    string GetName();
    string GetLockedBy();
    bool GetDefaultOn();
    string GetRadioGroup();
  };
  class ScenarioInfo
  {
  public:
    TempTexture2D* LoadLogos();
    string GetID();
    string GetName();
    string GetTag();
    string GetDescription();
    bool Multiplayer();
    bool Official();
    bool Packaged();
    bool Workshop();
    array<ScenarioStartLevel*>* GetStartLevels();
    array<ScenarioModification*>* GetModifications();
    int32 MinPlayers();
    int32 MaxPlayers();
  };

class GameSaveInfo
{
public:
  bool Valid;
  uint64 Timestamp;
  uint32 Version;
  uint32 ScenarioID;
  ScenarioInfo* Scenario;
  GameDifficulty Difficulty;
  uint64 PlaytimeLevel;
  uint64 PlaytimeTotal;
  bool Multiplayer;
  string LevelFilename;
public:
  GameSaveInfo operator=(const GameSaveInfo&);
};
enum SValueType
{
  Null = 0,
  Array = 1,
  Dictionary = 2,
  Boolean = 3,
  Float = 4,
  Integer = 5,
  String = 6,
  ByteArray = 7,
  Vector2 = 8,
  Vector3 = 9,
  Vector4 = 10,
};
enum cvar_type
{
  Bool = 2,
  Float = 1,
  Int = 0,
  String = 3,
};
enum cvar_flags
{
  ConfigOnly = 2,
  Cheat = 4,
};
enum UnitEventType
{
  Destroyed = 1,
  SceneChanged = 2,
  Hidden = 4,
  Damaged = 8,
  Custom = 16,
};
enum NetSyncMode
{
  None = 0,
  Manual = 1,
  Existance = 2,
  Position = 3,
};
enum TextAlignment
{
  Left = 0,
  Center = 1,
  Right = 2,
};
enum GradientDirection
{
  Horizontal = 0,
  Vertical = 1,
};
enum RaycastType
{
  Any = 0,
  Aim = 1,
  Shot = 2,
  Jam = 3,
};
enum TextInputControlEventType
{
  Home = 0,
  End = 1,
  Left = 2,
  Right = 3,
  LeftWord = 4,
  RightWord = 5,
  Backspace = 6,
  Delete = 7,
  Tab = 8,
  Submit = 9,
  Cancel = 10,
  Copy = 11,
  Paste = 12,
  Cut = 13,
  Up = 14,
  Down = 15,
  None = 16,
};
enum ControllerType
{
  None = 0,
  Keyboard = 1,
  Mouse = 2,
  MouseWheel = 3,
  Gamepad = 4,
  GamepadAxis = 5,
  GamepadVector = 6,
  Joystick = 7,
  JoystickAxis = 8,
  JoystickVector = 9,
  JoystickHat = 10,
};
enum MenuState
{
  MainMenu = 0,
  InGameMenu = 1,
  Hidden = 2,
};
enum MenuMessage
{
  LostConnection = 1,
  Saved = 0,
};
enum GameDifficulty
{
  Easy = 1,
  Normal = 2,
  Hard = 4,
  Serious = 8,
};
enum ScenarioModificationVisual
{
  None = 0,
  Separator = 1,
  Header = 2,
};
enum StartMode
{
  StartGame = 0,
  Continue = 1,
  LoadGame = 2,
  DropIn = 3,
};
typedef void (*OnChangedInt)(int32 val);
typedef void (*OnChangedFloat)(float val);
typedef void (*OnChangedBool)(bool val);
typedef void (*OnChangedString)(string val);
typedef void (*OnCFunctionCall0Param)();
typedef void (*OnCFunctionCall1Param)(cvar_t* arg0);
typedef void (*OnCFunctionCall2Param)(cvar_t* arg0, cvar_t* arg1);
typedef void (*OnCFunctionCall3Param)(cvar_t* arg0, cvar_t* arg1, cvar_t* arg2);
typedef void (*OnCFunctionCall4Param)(cvar_t* arg0, cvar_t* arg1, cvar_t* arg2, cvar_t* arg3);
typedef void (*OnCFunctionCall5Param)(cvar_t* arg0, cvar_t* arg1, cvar_t* arg2, cvar_t* arg3, cvar_t* arg4);
typedef void (*OnCFunctionCall6Param)(cvar_t* arg0, cvar_t* arg1, cvar_t* arg2, cvar_t* arg3, cvar_t* arg4, cvar_t* arg5);
typedef void (*OnCFunctionCall7Param)(cvar_t* arg0, cvar_t* arg1, cvar_t* arg2, cvar_t* arg3, cvar_t* arg4, cvar_t* arg5, cvar_t* arg6);
typedef void (*OnCFunctionCall8Param)(cvar_t* arg0, cvar_t* arg1, cvar_t* arg2, cvar_t* arg3, cvar_t* arg4, cvar_t* arg5, cvar_t* arg6, cvar_t* arg7);
typedef void (*OnCFunctionCall9Param)(cvar_t* arg0, cvar_t* arg1, cvar_t* arg2, cvar_t* arg3, cvar_t* arg4, cvar_t* arg5, cvar_t* arg6, cvar_t* arg7, cvar_t* arg8);
typedef void (*OnCFunctionCall10Param)(cvar_t* arg0, cvar_t* arg1, cvar_t* arg2, cvar_t* arg3, cvar_t* arg4, cvar_t* arg5, cvar_t* arg6, cvar_t* arg7, cvar_t* arg8, cvar_t* arg9);
typedef ref (*WidgetProducer)(WidgetLoadingContext& ctx);
string formatInt(int64 val, const string& options = "", uint32 width = 0);
string formatUInt(uint64 val, const string& options = "", uint32 width = 0);
string formatFloat(double val, const string& options = "", uint32 width = 0, uint32 precision = 0);
int64 parseInt(const string&, uint32 base = 10, uint32& byteCount = 0);
uint64 parseUInt(const string&, uint32 base = 10, uint32& byteCount = 0);
double parseFloat(const string&, uint32& byteCount = 0);
string join(const array<string>&, const string&);
void PROFILE_START(const string&);
void PROFILE_STOP();
namespace mat
{
  mat3 shearY(const mat3&, const float x);
  mat3 shearX(const mat3&, const float y);
  mat3 scale(const mat3&, const vec2&);
  mat3 translate(const mat3&, const vec2&);
  mat3 inverse(const mat3&);
  mat4 scale(const mat4&, const vec3&);
  mat4 translate(const mat4&, const vec3&);
  mat4 inverse(const mat4&);
}
ctime gmtime(uint64 time);
float atan(float y, float x);
float sin(float a);
float cos(float a);
float sqrt(float a);
uint32 sqrt(uint32 a);
int32 sqrt(int32 a);
float pow(float a, float e);
float round(float a);
float round(float a, int32 n);
float floor(float a);
float ceil(float a);
vec2 normalize(const vec2&);
vec3 normalize(const vec3&);
vec4 normalize(const vec4&);
float dot(const vec2&, const vec2&);
float dot(const vec3&, const vec3&);
float dot(const vec4&, const vec4&);
float length(const vec2&);
float length(const vec3&);
float length(const vec4&);
float lengthsq(const vec2&);
float lengthsq(const vec3&);
float lengthsq(const vec4&);
float dist(const vec2&, const vec2&);
float dist(const vec3&, const vec3&);
float dist(const vec4&, const vec4&);
float distsq(const vec2&, const vec2&);
float distsq(const vec3&, const vec3&);
float distsq(const vec4&, const vec4&);
float randf();
int32 randi(int32 max);
vec2 randdir();
vec4 tocolor(const vec4& srgb);
vec4 ParseColorRGBA(const string& s);
  void DumpStack();

string EscapeString(const string& s);
int32 GetParamInt(UnitPtr owner, SValue* params, string& name, bool required = true, int32 def = 0);
float GetParamFloat(UnitPtr owner, SValue* params, string& name, bool required = true, float def = 0.);
bool GetParamBool(UnitPtr owner, SValue* params, string& name, bool required = true, bool def = false);
vec2 GetParamVec2(UnitPtr owner, SValue* params, string& name, bool required = true, vec2 def = vec2());
vec3 GetParamVec3(UnitPtr owner, SValue* params, string& name, bool required = true, vec3 def = vec3());
vec4 GetParamVec4(UnitPtr owner, SValue* params, string& name, bool required = true, vec4 def = vec4());
string GetParamString(UnitPtr owner, SValue* params, string& name, bool required = true, string& def = "");
array<SValue*>* GetParamArray(UnitPtr owner, SValue* params, string& name, bool required = true);
SValue* GetParamDictionary(UnitPtr owner, SValue* params, string& name, bool required = true);
  bool VarExists(string name);
  void AddVar(string name, int32 def, OnChangedInt* onChanged = null, uint32 flags = 0);
  void AddVar(string name, float def, OnChangedFloat* onChanged = null, uint32 flags = 0);
  void AddVar(string name, bool def, OnChangedBool* onChanged = null, uint32 flags = 0);
  void AddVar(string name, string def, OnChangedString* onChanged = null, uint32 flags = 0);
  cvar_type GetVarType(string name);
  int32 GetVarInt(string name);
  float GetVarFloat(string name);
  bool GetVarBool(string name);
  string GetVarString(string name);
  ivec2 GetVarIvec2(string name);
  int32 GetVarIntDefault(string name);
  float GetVarFloatDefault(string name);
  bool GetVarBoolDefault(string name);
  string GetVarStringDefault(string name);
  ivec2 GetVarIvec2Default(string name);
  void AddFunction(string name, OnCFunctionCall0Param* onCalled, uint32 flags = 0);
  void AddFunction(string name, array<cvar_type>* params, OnCFunctionCall1Param* onCalled, uint32 flags = 0);
  void AddFunction(string name, array<cvar_type>* params, OnCFunctionCall2Param* onCalled, uint32 flags = 0);
  void AddFunction(string name, array<cvar_type>* params, OnCFunctionCall3Param* onCalled, uint32 flags = 0);
  void AddFunction(string name, array<cvar_type>* params, OnCFunctionCall4Param* onCalled, uint32 flags = 0);
  void AddFunction(string name, array<cvar_type>* params, OnCFunctionCall5Param* onCalled, uint32 flags = 0);
  void AddFunction(string name, array<cvar_type>* params, OnCFunctionCall6Param* onCalled, uint32 flags = 0);
  void AddFunction(string name, array<cvar_type>* params, OnCFunctionCall7Param* onCalled, uint32 flags = 0);
  void AddFunction(string name, array<cvar_type>* params, OnCFunctionCall8Param* onCalled, uint32 flags = 0);
  void AddFunction(string name, array<cvar_type>* params, OnCFunctionCall9Param* onCalled, uint32 flags = 0);
  void AddFunction(string name, array<cvar_type>* params, OnCFunctionCall10Param* onCalled, uint32 flags = 0);
  ivec2 ParseVarIvec2(string str);
  void SetVar(string name, const int32& val);
  void SetVar(string name, const float& val);
  void SetVar(string name, const bool& val);
  void SetVar(string name, const string& val);
  void SetVar(string name, const ivec2& val);

namespace Config
{
    void SaveControls(int32 playerNum, string newControls);
    void SaveVar(string cvar, string value);
    void SaveVar(string cvar);

}
namespace Sound
{
  void SetListener(vec3 pos, vec3 look, vec3 up);
}
namespace WorldScript
{
  WorldScript* GetWorldScript(UnitPtr unit);
  WorldScript* GetWorldScript(Scene& scene, ref script);
}
namespace Network
{
  NetworkMessage Message(const string&);
  bool IsServer();
}
namespace Resources
{
  UnitProducer* GetUnitProducer(string filename);
  SValue* GetSValue(string filename);
  BitmapFont* GetBitmapFont(string filename);
  SoundEvent* GetSoundEvent(string filename);
  UnitScene* GetEffect(string filename);
  GUIDef* GetGUIDef(string filename);
  Texture2D* GetTexture2D(string filename);
  Bitmap2D* GetBitmap2D(string filename);
  Tileset* GetTileset(string filename);
  UnitProducer* GetUnitProducer(uint32 filenameHash);
  SValue* GetSValue(uint32 filenameHash);
  BitmapFont* GetBitmapFont(uint32 filenameHash);
  UnitScene* GetEffect(uint32 filenameHash);
  GUIDef* GetGUIDef(uint32 filenameHash);
  Texture2D* GetTexture2D(uint32 filenameHash);
  Bitmap2D* GetBitmap2D(uint32 filenameHash);
  Tileset* GetTileset(uint32 filenameHash);
  string GetResourceName(uint32 filenameHash);
  uint32 GetSlot(string name);
  string GetString(string str);
  string GetString(string str, const dictionary& params);
}
  void PrintError(string message);

ref InstantiateClass(string name, SValue& val);
ref InstantiateClass(string name, UnitPtr unit, SValue& val);
uint32 HashString(string str);
void print(const string&);
ControlBindings* GetControlBindings();
vec2 ToScreenspace(vec3 pos);
vec3 ToWorldspace(vec2 pos);
uint64 CurrPlaytimeLevel();
uint64 CurrPlaytimeTotal();
namespace Lobby
{
  string GetPlayerName(uint8 peer);
  string GetPlayerSkin(uint8 peer);
  int32 GetPlayerPing(uint8 peer);
  int32 GetHostPing(uint8 peer);
  bool IsInLobby();
}
void StartGame(int32 numPlrs, string level, ScenarioInfo* scenario, GameDifficulty diff, array<string>* mods);
void ChangeLevel(string level);
void RestartLevel();
void SaveGame();
string GetCurrentLevelFilename();
int32 GetRestartCount();
void SetRestartCount(int32 count);
namespace Lobby
{
  void CreateLobby();
  void JoinLobby(uint64 id);
  void LeaveLobby();
  void SendChatMessage(string msg);
  bool IsPlayerHost(uint8 peer);
  bool IsPlayerLocal(uint8 peer);
  int32 GetLocalPeer();
  void SetPrivate(bool priv);
  void KickPlayer(uint8 peer);
  void SetScenario(ScenarioInfo* scenario, GameDifficulty diff, array<string>* mods);
  void SetLevel(string level);
  void StartGame();
  void SetLobbyData(const string& key, const string& value);
  string GetLobbyData(const string&);
  void SetLobbyMemberData(const string& key, const string& value);
  string GetLobbyMemberData(uint8 peer, const string& key);
  ScenarioInfo* GetScenario();
  GameDifficulty GetDifficulty();
  array<string>* GetModifiers();
  void ListLobbies();
  string GetLobbyData(uint64 id, const string& key);
  int32 GetLobbyPing(uint64 id);
  int32 GetLobbyPlayerCount(uint64 id);
  int32 GetLobbyPlayerCountMax(uint64 id);
}
namespace Saves
{
  array<string>* GetSaves();
  GameSaveInfo ReadInfo(string filename);
  bool Load(string filename);
  void Rename(string filename, string newname);
  void Delete(string filename);
}
void QuitGame();
void StopScenario();
void ResumeGame();
void PauseGame(bool pause, bool localOnly);
uint64 GetUniquePeerId(uint8 peer);
void RumbleGamepad(float strength, int32 length);
void RumbleGamepadStop();
namespace Platform
{
  void HideCursor();
  void ShowCursor();
  vec2 GetMousePosition();
  array<ivec2>* GetResolutions();
  array<ScenarioInfo*>* GetAllScenarios();
  ScenarioInfo* GetScenario(string id);
  ScenarioInfo* GetScenario(uint32 id);
  array<uint32>* GetCampaignLevelsPlayed();
}
const float PI;
const float TwoPI;
namespace Platform
{
  GameService* Service;
}