GEEKING

App/include/script/script.h

@@ -0,0 +1,192 @@
+#pragma once
+
+#include "V8Tree/Instance.h"
+#include "Script/ThreadRef.h"
+#include "Util/ScriptInformationProvider.h"
+#include "Util/ProtectedString.h"
+#include "script/LuaSourceContainer.h"
+#include "rbx/atomic.h"
+#include <boost/function.hpp>
+#include <boost/flyweight.hpp>
+
+struct lua_State;
+
+namespace RBX
+{
+	class IScriptOwner;
+	class ScriptContext;
+	class RuntimeScriptService;
+	class ScriptInformationProvider;
+	class ContentProvider;
+
+	namespace Network
+	{
+		class Player;
+	}
+
+	typedef ContentId ScriptId;
+	extern const char* const sBaseScript;
+	class BaseScript 
+		: public DescribedNonCreatable<BaseScript, LuaSourceContainer, sBaseScript>
+	{
+	private:
+		typedef DescribedNonCreatable<BaseScript, LuaSourceContainer, sBaseScript> Super;
+
+	public:
+		class Slot;
+
+		// Used for development only. It allows you to load CoreScripts from your local disk
+		static std::string adminScriptsPath;
+		static bool hasCoreScriptReplacements();
+
+		void restartScript();
+	protected:
+		RuntimeScriptService* workspace;
+
+		///////////////////////////////////
+		// Instance
+		/*override*/ void onServiceProvider(ServiceProvider* oldProvider, ServiceProvider* newProvider);
+		/*override*/ void onAncestorChanged(const AncestorChanged& event);
+		/*override*/ void onScriptIdChanged();
+
+	private:
+		static const std::string emptyString;
+
+		weak_ptr<RBX::Network::Player> localPlayer;
+
+		bool disabled;
+		bool badLinkedScript;
+		
+		RuntimeScriptService* computeNewWorkspace();
+
+	public:
+		struct Code
+		{
+			bool loaded;
+			boost::flyweight<ProtectedString> script;
+
+			Code()
+				:loaded(false)
+			{}
+			Code(const boost::flyweight<ProtectedString>& script)
+				:loaded(true)
+				,script(script)
+			{}
+		};
+		BaseScript();
+		~BaseScript();
+
+
+		static const Reflection::PropDescriptor<BaseScript, ScriptId> prop_SourceCodeId;
+
+		weak_ptr<RBX::Network::Player> getLocalPlayer() { return localPlayer; }
+		void setLocalPlayer(const shared_ptr<RBX::Network::Player>& localPlayer) { this->localPlayer = localPlayer; }
+
+		// Thread management
+		boost::intrusive_ptr<Lua::WeakThreadRef::Node> threadNode;
+		rbx::signal<void(lua_State*)> starting;
+		rbx::signal<void()> stopped;
+
+		bool isDisabled() const { return disabled; }
+		static const Reflection::PropDescriptor<BaseScript, bool> prop_Disabled;
+
+		virtual Code requestCode(ScriptInformationProvider* scriptInfoProvider=NULL);
+
+		virtual void extraErrorReporting(lua_State *thread) {}
+
+		//Properties
+		bool getDisabled() const { return disabled; }
+		void setDisabled(bool value);
+
+		virtual const std::string& requestHash() const;
+	};
+	// A BaseScript is started when a containing IScriptOwner sends it to the ScriptContext service
+	extern const char* const sScript;
+	class Script 
+		: public DescribedCreatable<Script, BaseScript, sScript>
+	{
+	private:
+		typedef DescribedCreatable<Script, BaseScript, sScript> Super;
+
+	private:
+		boost::flyweight<ProtectedString> embeddedSource;
+        std::string embeddedSourceHash;
+
+	public:
+		Script();
+		~Script();
+
+		static const Reflection::PropDescriptor<Script, ProtectedString> prop_EmbeddedSourceCode;
+	
+		/*override*/ XmlElement* writeXml(const boost::function<bool(Instance*)>& isInScope, RBX::CreatorRole creatorRole)
+		{
+			return Super::writeXml(isInScope, creatorRole);
+		}
+
+		/*override*/ bool askSetParent(const Instance* instance) const
+		{
+			// Scripts can be anywhere
+			return true;
+		}
+
+		bool isCodeEmbedded() const { return getScriptId().isNull(); }
+
+		/*override*/ Code requestCode(ScriptInformationProvider* scriptInfoProvider=NULL);
+
+		/*override*/ const std::string& requestHash() const;
+
+		void setEmbeddedCode(const ProtectedString& value);
+		const boost::flyweight<ProtectedString>& getEmbeddedCode() const;
+		const ProtectedString& getEmbeddedCodeSafe() const;
+		/*override*/ int getPersistentDataCost() const;
+		/*override*/ void fireSourceChanged();
+
+	private:
+		std::string getHash() { return requestHash(); }
+
+		static const Reflection::BoundFuncDesc<Script, std::string()> func_GetHash;
+	};
+
+	// Only runs on a local machine if either
+	// a) Inside a tool which is inside a local character
+	// b) Inside the local backpack
+
+	// Local scripts have the full power of a normal script, but can also interact with the Mouse.
+	// While they are currently run client side, this is a large security hole that will have to be addressed.
+	// The plan is to have them execute server side, but with an adapter taking the place of the "Mouse" object and abstracting it per-user
+	//
+	// A better name would be GuiScript or UserScript, if we could redo this work.
+	extern const char* const sLocalScript;
+	class LocalScript
+		: public DescribedCreatable<LocalScript, Script, sLocalScript>
+	{
+	public:
+
+		LocalScript();
+		~LocalScript() {}
+    };
+
+	class BaseScript::Slot
+	{
+		rbx::signals::connection connection;
+	public:
+		// A Slot must keep a reference to its connection, because it
+		// must be capable of disconnecting itself. 
+		void assignConnection(const rbx::signals::connection& connection)
+		{
+			this->connection = connection;
+		}
+	protected:
+		Slot()
+		{
+		}
+		~Slot()
+		{
+			// TODO: Disconnect here???
+		}
+		void disconnect()
+		{
+			connection.disconnect();
+		}
+	};
+}