Open source Star Ruler 2 source code!

source/as_addons/include/scriptany.h

@@ -0,0 +1,76 @@
+#ifndef SCRIPTANY_H
+#define SCRIPTANY_H
+
+#ifndef ANGELSCRIPT_H 
+// Avoid having to inform include path if header is already include before
+#include <angelscript.h>
+#endif
+
+
+BEGIN_AS_NAMESPACE
+
+class CScriptAny 
+{
+public:
+	// Constructors
+	CScriptAny(asIScriptEngine *engine);
+	CScriptAny(void *ref, int refTypeId, asIScriptEngine *engine);
+
+	// Memory management
+	int AddRef() const;
+	int Release() const;
+
+	// Copy the stored value from another any object
+	CScriptAny &operator=(const CScriptAny&);
+	int CopyFrom(const CScriptAny *other);
+
+	// Store the value, either as variable type, integer number, or real number
+	void Store(void *ref, int refTypeId);
+	void Store(asINT64 &value);
+	void Store(double &value);
+
+	// Retrieve the stored value, either as variable type, integer number, or real number
+	bool Retrieve(void *ref, int refTypeId) const;
+	bool Retrieve(asINT64 &value) const;
+	bool Retrieve(double &value) const;
+
+	// Get the type id of the stored value
+	int  GetTypeId() const;
+
+	// GC methods
+	int  GetRefCount();
+	void SetFlag();
+	bool GetFlag();
+	void EnumReferences(asIScriptEngine *engine);
+	void ReleaseAllHandles(asIScriptEngine *engine);
+
+protected:
+	virtual ~CScriptAny();
+	void FreeObject();
+
+	mutable int refCount;
+	mutable bool gcFlag;
+	asIScriptEngine *engine;
+
+	// The structure for holding the values
+    struct valueStruct
+    {
+        union
+        {
+            asINT64 valueInt;
+            double  valueFlt;
+            void   *valueObj;
+        };
+        int   typeId;
+    };
+
+	valueStruct value;
+};
+
+void RegisterScriptAny(asIScriptEngine *engine);
+void RegisterScriptAny_Native(asIScriptEngine *engine);
+void RegisterScriptAny_Generic(asIScriptEngine *engine);
+
+END_AS_NAMESPACE
+
+#endif

source/as_addons/include/scriptarray.h

@@ -0,0 +1,113 @@
+#ifndef SCRIPTARRAY_H
+#define SCRIPTARRAY_H
+
+#ifndef ANGELSCRIPT_H 
+// Avoid having to inform include path if header is already include before
+#include <angelscript.h>
+#endif
+
+#include "../source/as_atomic.h"
+
+// Sometimes it may be desired to use the same method names as used by C++ STL.
+// This may for example reduce time when converting code from script to C++ or
+// back.
+//
+//  0 = off
+//  1 = on
+
+#ifndef AS_USE_STLNAMES
+#define AS_USE_STLNAMES 0
+#endif
+
+BEGIN_AS_NAMESPACE
+
+struct SArrayBuffer;
+struct SArrayCache;
+
+class CScriptArray
+{
+public:
+	CScriptArray(asITypeInfo *ot, void *initBuf); // Called from script when initialized with list
+	CScriptArray(asUINT length, asITypeInfo *ot);
+	CScriptArray(asUINT length, void *defVal, asITypeInfo *ot);
+	CScriptArray(const CScriptArray &other);
+	virtual ~CScriptArray();
+
+	void AddRef() const;
+	void Release() const;
+
+	// Type information
+	asITypeInfo *GetArrayObjectType() const;
+	int            GetArrayTypeId() const;
+	int            GetElementTypeId() const;
+
+	void   Reserve(asUINT maxElements);
+	void   Resize(asUINT numElements);
+	asUINT GetSize() const;
+	bool   IsEmpty() const;
+
+	// Get a pointer to an element. Returns 0 if out of bounds
+	void       *At(asUINT index);
+	const void *At(asUINT index) const;
+
+	// Get a pointer to the last element. Returns 0 if empty array.
+	void       *Last();
+	const void *Last() const;
+
+	// Set value of an element
+	void  SetValue(asUINT index, void *value);
+
+	CScriptArray &operator=(const CScriptArray&);
+	bool operator==(const CScriptArray &) const;
+
+	void InsertAt(asUINT index, void *value);
+	void RemoveAt(asUINT index);
+	void InsertLast(void *value);
+	void RemoveLast();
+	void Remove(void *value);
+	void RemoveAll(void *value);
+	void SortAsc();
+	void SortDesc();
+	void SortAsc(asUINT index, asUINT count);
+	void SortDesc(asUINT index, asUINT count);
+	void Sort(asUINT index, asUINT count, bool asc);
+	void Reverse();
+	int  Find(void *value) const;
+	int  Find(asUINT index, void *value) const;
+
+	// GC methods
+	int  GetRefCount();
+	void SetFlag();
+	bool GetFlag();
+	void EnumReferences(asIScriptEngine *engine);
+	void ReleaseAllHandles(asIScriptEngine *engine);
+
+protected:
+	mutable asCAtomic       refCount;
+	mutable bool      gcFlag;
+	asITypeInfo    *objType;
+	SArrayBuffer     *buffer;
+	int               elementSize;
+	int               subTypeId;
+	int               numElements;
+
+	bool  Less(const void *a, const void *b, bool asc, asIScriptContext *ctx, SArrayCache *cache);
+	void *GetArrayItemPointer(int index);
+	void *GetDataPointer(void *buffer);
+	void  Copy(void *dst, void *src);
+	void  Precache();
+	bool  CheckMaxSize(asUINT numElements);
+	void  Resize(int delta, asUINT at);
+	void  CreateBuffer(SArrayBuffer **buf, asUINT numElements);
+	void  DeleteBuffer(SArrayBuffer *buf);
+	void  CopyBuffer(SArrayBuffer *dst, SArrayBuffer *src);
+	void  Construct(SArrayBuffer *buf, asUINT start, asUINT end);
+	void  Destruct(SArrayBuffer *buf, asUINT start, asUINT end);
+	bool  Equals(const void *a, const void *b, asIScriptContext *ctx, SArrayCache *cache) const;
+};
+
+void RegisterScriptArray(asIScriptEngine *engine, bool defaultArray);
+
+END_AS_NAMESPACE
+
+#endif

source/as_addons/include/scriptdictionary.h

@@ -0,0 +1,184 @@
+#ifndef SCRIPTDICTIONARY_H
+#define SCRIPTDICTIONARY_H
+
+// The dictionary class relies on the script string object, thus the script
+// string type must be registered with the engine before registering the
+// dictionary type
+
+#ifndef ANGELSCRIPT_H 
+// Avoid having to inform include path if header is already include before
+#include <angelscript.h>
+#endif
+
+#include "../source/as_atomic.h"
+
+#include <string>
+
+#ifdef _MSC_VER
+// Turn off annoying warnings about truncated symbol names
+#pragma warning (disable:4786)
+#endif
+
+#if __cplusplus >= 201103
+#include <unordered_map>
+#else
+#include <map>
+#endif
+
+// Sometimes it may be desired to use the same method names as used by C++ STL.
+// This may for example reduce time when converting code from script to C++ or
+// back.
+//
+//  0 = off
+//  1 = on
+
+#ifndef AS_USE_STLNAMES
+#define AS_USE_STLNAMES 0
+#endif
+
+
+BEGIN_AS_NAMESPACE
+
+class CScriptArray;
+
+class CScriptDictionary
+{
+protected:
+	// The structure for holding the values
+    struct valueStruct
+    {
+        union
+        {
+            asINT64 valueInt;
+            double  valueFlt;
+            void   *valueObj;
+        };
+        int   typeId;
+    };
+
+	// The type of the internal map
+#if __cplusplus >= 201103
+	typedef std::unordered_map<std::string, valueStruct> mapType;
+#else
+	typedef std::map<std::string, valueStruct> mapType;
+#endif
+
+public:
+    // Memory management
+    CScriptDictionary(asIScriptEngine *engine);
+    void AddRef() const;
+    void Release() const;
+
+    CScriptDictionary &operator =(const CScriptDictionary &other);
+
+    // Sets/Gets a variable type value for a key
+    void Set(const std::string &key, void *value, int typeId);
+    bool Get(const std::string &key, void *value, int typeId) const;
+
+    // Sets/Gets an integer number value for a key
+    void Set(const std::string &key, asINT64 &value);
+    bool Get(const std::string &key, asINT64 &value) const;
+
+    // Sets/Gets a real number value for a key
+    void Set(const std::string &key, double &value);
+    bool Get(const std::string &key, double &value) const;
+
+    // Returns true if the key is set
+    bool Exists(const std::string &key) const;
+	bool IsEmpty() const;
+	asUINT GetSize() const;
+
+    // Deletes the key
+    void Delete(const std::string &key);
+
+    // Deletes all keys
+    void DeleteAll();
+
+	// Deletes all keys that have null reference values
+	void DeleteNulls();
+
+	// Get an array of all keys
+	CScriptArray *GetKeys() const;
+
+	// Garbage collections behaviours
+	int GetRefCount();
+	void SetGCFlag();
+	bool GetGCFlag();
+	void EnumReferences(asIScriptEngine *engine);
+	void ReleaseAllReferences(asIScriptEngine *engine);
+
+	// An iterator type to wrap for script iteration
+	struct Iterator
+	{
+	public:
+		// Returns the key of the current element or
+		// an error string if the iterator is at the end
+		const std::string &GetKey();
+
+		// Get the value of the current element
+		// Returns true if the value is of the correct type and
+		// the iterator is not at the end
+		bool Iterate(void *value, int typeId);
+		bool Iterate(std::string* key, void *value, int typeId);
+
+		// Returns whether the iterator is not at
+		// the end yet
+		bool IsValid();
+
+		// Copy the iterator
+		Iterator &operator =(const Iterator &other);
+
+		Iterator();
+		Iterator(const CScriptDictionary *container);
+		~Iterator();
+
+		friend CScriptDictionary;
+	protected:
+		bool first;
+		asUINT modCount;
+		const CScriptDictionary *container;
+		mapType::const_iterator it;
+	};
+
+	// Returns an iterator
+	Iterator GetIterator() const;
+
+	// Delete the current element of an iterator
+	void Delete(Iterator& it);
+
+protected:
+	// We don't want anyone to call the destructor directly, it should be called through the Release method
+	virtual ~CScriptDictionary();
+
+	// Helper methods
+    void FreeValue(valueStruct &value);
+	bool Iterator_GetValue(mapType::const_iterator &it, void *value, int typeId) const;
+	
+	// Our properties
+    asIScriptEngine *engine;
+    mutable asCAtomic refCount;
+	mutable bool gcFlag;
+
+	// Whenever we erase or insert a new key, we increment the modification count.
+	// Iterators check whether the modification count has changed, and will fail
+	// when it has. This makes iterator-based iteration safe for scripts.
+	asUINT modCount;
+
+    mapType dict;
+};
+
+// This function will determine the configuration of the engine
+// and use one of the two functions below to register the dictionary object
+void RegisterScriptDictionary(asIScriptEngine *engine);
+
+// Call this function to register the math functions
+// using native calling conventions
+void RegisterScriptDictionary_Native(asIScriptEngine *engine);
+
+// Use this one instead if native calling conventions
+// are not supported on the target platform
+void RegisterScriptDictionary_Generic(asIScriptEngine *engine);
+
+END_AS_NAMESPACE
+
+#endif

source/as_addons/include/scripthandle.h

@@ -0,0 +1,65 @@
+#ifndef SCRIPTHANDLE_H
+#define SCRIPTHANDLE_H
+
+#ifndef ANGELSCRIPT_H 
+// Avoid having to inform include path if header is already include before
+#include <angelscript.h>
+#endif
+
+
+BEGIN_AS_NAMESPACE
+
+class CScriptHandle 
+{
+public:
+	// Constructors
+	CScriptHandle();
+	CScriptHandle(const CScriptHandle &other);
+	CScriptHandle(void *ref, asITypeInfo *type);
+	~CScriptHandle();
+
+	// Copy the stored value from another any object
+	CScriptHandle &operator=(const CScriptHandle &other);
+
+	// Set the reference
+	void Set(void *ref, asITypeInfo *type);
+
+	// Compare equalness
+	bool operator==(const CScriptHandle &o) const;
+	bool operator!=(const CScriptHandle &o) const;
+	bool Equals(void *ref, int typeId) const;
+
+	// Dynamic cast to desired handle type
+	void Cast(void **outRef, int typeId);
+
+	// Returns the type of the reference held
+	asITypeInfo *GetType() const;
+	int          GetTypeId() const;
+
+	// Get the reference
+	void *GetRef();
+
+protected:
+	// These functions need to have access to protected
+	// members in order to call them from the script engine
+	friend void Construct(CScriptHandle *self, void *ref, int typeId);
+	friend void RegisterScriptHandle_Native(asIScriptEngine *engine);
+	friend void CScriptHandle_AssignVar_Generic(asIScriptGeneric *gen);
+
+	void ReleaseHandle();
+	void AddRefHandle();
+
+	// These shouldn't be called directly by the 
+	// application as they requires an active context
+	CScriptHandle(void *ref, int typeId);
+	CScriptHandle &Assign(void *ref, int typeId);
+
+	void        *m_ref;
+	asITypeInfo *m_type;
+};
+
+void RegisterScriptHandle(asIScriptEngine *engine);
+
+END_AS_NAMESPACE
+
+#endif

source/as_addons/include/scripthelper.h

@@ -0,0 +1,48 @@
+#ifndef SCRIPTHELPER_H
+#define SCRIPTHELPER_H
+
+#include <sstream>
+#include <string>
+
+#ifndef ANGELSCRIPT_H
+// Avoid having to inform include path if header is already include before
+#include <angelscript.h>
+#endif
+
+
+BEGIN_AS_NAMESPACE
+
+// Compare relation between two objects of the same type
+int CompareRelation(asIScriptEngine *engine, void *lobj, void *robj, int typeId, int &result);
+
+// Compare equality between two objects of the same type
+int CompareEquality(asIScriptEngine *engine, void *lobj, void *robj, int typeId, bool &result);
+
+// Compile and execute simple statements
+// The module is optional. If given the statements can access the entities compiled in the module.
+// The caller can optionally provide its own context, for example if a context should be reused.
+int ExecuteString(asIScriptEngine *engine, const char *code, asIScriptModule *mod = 0, asIScriptContext *ctx = 0);
+
+// Compile and execute simple statements with option of return value
+// The module is optional. If given the statements can access the entitites compiled in the module.
+// The caller can optionally provide its own context, for example if a context should be reused.
+int ExecuteString(asIScriptEngine *engine, const char *code, void *ret, int retTypeId, asIScriptModule *mod = 0, asIScriptContext *ctx = 0);
+
+// Write the registered application interface to a file for an offline compiler.
+// The format is compatible with the offline compiler in /sdk/samples/asbuild/.
+int WriteConfigToFile(asIScriptEngine *engine, const char *filename);
+
+// Write the registered application interface to a text stream. 
+int WriteConfigToStream(asIScriptEngine *engine, std::ostream &strm); 
+
+// Loads an interface from a text stream and configures the engine with it. This will not 
+// set the correct function pointers, so it is not possible to use this engine to execute
+// scripts, but it can be used to compile scripts and save the byte code.
+int ConfigEngineFromStream(asIScriptEngine *engine, std::istream &strm, const char *nameOfStream = "config");
+
+// Format the details of the script exception into a human readable text
+std::string GetExceptionInfo(asIScriptContext *ctx, bool showStack = false);
+
+END_AS_NAMESPACE
+
+#endif

source/as_addons/include/scriptmap.h

@@ -0,0 +1,180 @@
+#ifndef SCRIPTMAP_H
+#define SCRIPTMAP_H
+
+#ifndef ANGELSCRIPT_H 
+// Avoid having to inform include path if header is already include before
+#include <angelscript.h>
+#endif
+
+#include "../source/as_atomic.h"
+
+#include <string>
+
+#ifdef _MSC_VER
+// Turn off annoying warnings about truncated symbol names
+#pragma warning (disable:4786)
+#endif
+
+#if __cplusplus >= 201103 || _MSC_VER >= 1600
+#include <unordered_map>
+#else
+#include <map>
+#endif
+
+// Sometimes it may be desired to use the same method names as used by C++ STL.
+// This may for example reduce time when converting code from script to C++ or
+// back.
+//
+//  0 = off
+//  1 = on
+
+#ifndef AS_USE_STLNAMES
+#define AS_USE_STLNAMES 0
+#endif
+
+
+BEGIN_AS_NAMESPACE
+
+class CScriptArray;
+
+class CScriptMap
+{
+protected:
+	// The structure for holding the values
+    struct valueStruct
+    {
+        union
+        {
+            asINT64 valueInt;
+            double  valueFlt;
+            void   *valueObj;
+        };
+        int   typeId;
+    };
+
+	// The type of the internal map
+#if __cplusplus >= 201103 || _MSC_VER >= 1600
+	typedef std::unordered_map<asINT64, valueStruct> mapType;
+#else
+	typedef std::map<asINT64, valueStruct> mapType;
+#endif
+
+public:
+    // Memory management
+    CScriptMap(asIScriptEngine *engine);
+    void AddRef() const;
+    void Release() const;
+
+    CScriptMap &operator =(const CScriptMap &other);
+
+    // Sets/Gets a variable type value for a key
+    void Set(asINT64 key, void *value, int typeId);
+    bool Get(asINT64 key, void *value, int typeId) const;
+
+    // Sets/Gets an integer number value for a key
+    void Set(asINT64 key, asINT64 &value);
+    bool Get(asINT64 key, asINT64 &value) const;
+
+    // Sets/Gets a real number value for a key
+    void Set(asINT64 key, double &value);
+    bool Get(asINT64 key, double &value) const;
+
+    // Returns true if the key is set
+    bool Exists(asINT64 key) const;
+	bool IsEmpty() const;
+	asUINT GetSize() const;
+
+    // Deletes the key
+    void Delete(asINT64 key);
+
+    // Deletes all keys
+    void DeleteAll();
+
+	// Deletes all keys that have null reference values
+	void DeleteNulls();
+
+	// Get an array of all keys
+	CScriptArray *GetKeys() const;
+
+	// Garbage collections behaviours
+	int GetRefCount();
+	void SetGCFlag();
+	bool GetGCFlag();
+	void EnumReferences(asIScriptEngine *engine);
+	void ReleaseAllReferences(asIScriptEngine *engine);
+
+	// An iterator type to wrap for script iteration
+	struct Iterator
+	{
+	public:
+		// Returns the key of the current element or
+		// an error string if the iterator is at the end
+		asINT64 GetKey();
+
+		// Get the value of the current element
+		// Returns true if the value is of the correct type and
+		// the iterator is not at the end
+		bool Iterate(void *value, int typeId);
+		bool Iterate(asINT64* key, void *value, int typeId);
+
+		// Returns whether the iterator is not at
+		// the end yet
+		bool IsValid();
+
+		// Copy the iterator
+		Iterator &operator =(const Iterator &other);
+
+		Iterator();
+		Iterator(const CScriptMap *container);
+		~Iterator();
+
+		friend CScriptMap;
+	protected:
+		bool first;
+		asUINT modCount;
+		const CScriptMap *container;
+		mapType::const_iterator it;
+	};
+
+	// Returns an iterator
+	Iterator GetIterator() const;
+
+	// Delete the current element of an iterator
+	void Delete(Iterator& it);
+
+protected:
+	// We don't want anyone to call the destructor directly, it should be called through the Release method
+	virtual ~CScriptMap();
+
+	// Helper methods
+    void FreeValue(valueStruct &value);
+	bool Iterator_GetValue(mapType::const_iterator &it, void *value, int typeId) const;
+	
+	// Our properties
+    asIScriptEngine *engine;
+    mutable asCAtomic refCount;
+	mutable bool gcFlag;
+
+	// Whenever we erase or insert a new key, we increment the modification count.
+	// Iterators check whether the modification count has changed, and will fail
+	// when it has. This makes iterator-based iteration safe for scripts.
+	asUINT modCount;
+
+    mapType dict;
+};
+
+// This function will determine the configuration of the engine
+// and use one of the two functions below to register the map object
+void RegisterScriptMap(asIScriptEngine *engine);
+
+// Call this function to register the math functions
+// using native calling conventions
+void RegisterScriptMap_Native(asIScriptEngine *engine);
+
+// Use this one instead if native calling conventions
+// are not supported on the target platform
+void RegisterScriptMap_Generic(asIScriptEngine *engine);
+
+END_AS_NAMESPACE
+
+#endif

source/as_addons/include/scriptmath.h

@@ -0,0 +1,26 @@
+#ifndef SCRIPTMATH_H
+#define SCRIPTMATH_H
+
+#ifndef ANGELSCRIPT_H 
+// Avoid having to inform include path if header is already include before
+#include <angelscript.h>
+#endif
+
+
+BEGIN_AS_NAMESPACE
+
+// This function will determine the configuration of the engine
+// and use one of the two functions below to register the math functions
+void RegisterScriptMath(asIScriptEngine *engine);
+
+// Call this function to register the math functions
+// using native calling conventions
+void RegisterScriptMath_Native(asIScriptEngine *engine);
+
+// Use this one instead if native calling conventions
+// are not supported on the target platform
+void RegisterScriptMath_Generic(asIScriptEngine *engine);
+
+END_AS_NAMESPACE
+
+#endif

source/as_addons/include/scriptstdstring.h

@@ -0,0 +1,24 @@
+//
+// Script std::string
+//
+// This function registers the std::string type with AngelScript to be used as the default string type.
+//
+// The string type is registered as a value type, thus may have performance issues if a lot of 
+// string operations are performed in the script. However, for relatively few operations, this should
+// not cause any problem for most applications.
+//
+
+#ifndef SCRIPTSTDSTRING_H
+#define SCRIPTSTDSTRING_H
+
+#include <angelscript.h>
+#include <string>
+
+BEGIN_AS_NAMESPACE
+
+void RegisterStdString(asIScriptEngine *engine);
+void RegisterStdStringUtils(asIScriptEngine *engine);
+
+END_AS_NAMESPACE
+
+#endif