GEEKING

Network/include/network/Player.h

@@ -0,0 +1,496 @@
+/* Copyright 2003-2007 ROBLOX Corporation, All Rights Reserved */
+
+#pragma once
+
+#include "rbx/rbxTime.h"
+#include "v8tree/instance.h"
+#include "v8datamodel/team.h"
+#include "V8Datamodel/FriendService.h"
+#include "V8DataModel/Camera.h"
+#include "V8DataModel/StarterPlayerService.h"
+#include "Util/BrickColor.h"
+#include "Util/G3DCore.h"
+#include "Util/HeapValue.h"
+#include "Util/Rect.h"
+#include "util/RunningAverage.h"
+
+// for player mouse
+#include "V8Datamodel/Mouse.h"
+
+#include <boost/scoped_ptr.hpp>
+#include "v8datamodel/TeleportService.h"
+
+LOGGROUP(Network)
+LOGGROUP(Player)
+
+namespace RakNet {
+struct SystemAddress;
+}
+
+namespace RBX { 
+	class Visit;
+	class ModelInstance;
+	class Backpack;
+	class TimerService;
+	class Region2;
+	class DataModelMesh;
+	class Adorn;
+	class Primitive;
+	class PartInstance;
+	class Humanoid;
+	class DataModel;
+	class SpawnLocation;
+
+namespace Network {
+	class PersistentDataStore;
+
+	extern const char* const sPlayer;
+
+	class Player
+		: public DescribedCreatable<Player, Instance, sPlayer, Reflection::ClassDescriptor::RUNTIME>
+		, public Diagnostics::Countable<Player>
+	{
+	private:
+		typedef DescribedCreatable<Player, Instance, sPlayer, Reflection::ClassDescriptor::RUNTIME> Super;
+		shared_ptr<ModelInstance> character;		// The ModelInstance that this player is represented by
+		BrickColor teamColor;
+		bool neutral;
+		int loadAppearanceCounter;
+		int dataComplexityLimit;
+		bool dataReady;
+		weak_ptr<SpawnLocation> respawnLocation;
+		CoordinateFrame cloudEditCameraCFrame;
+
+		bool loadedStarterGear;
+
+        // User Profile data
+        bool superSafeChat;
+        bool under13;
+        int userId;
+
+        // For Group Building
+        bool hasGroupBuildTools;
+        HeapValue<int> personalServerRank;
+
+		rbx::signals::scoped_connection characterDiedConnection;
+		rbx::signals::scoped_connection backendDiedSignalConnection;
+		rbx::signals::scoped_connection spawnLocationChangedConnection;
+		rbx::signals::scoped_connection simulationRadiusChangedConnection;
+		rbx::signals::scoped_connection setShutdownMessageConnection;
+		boost::function<void()> teamStatusChangedCallback;
+
+		// CharacterAppearance is the url of a handler that returns a delimited list of asset ids
+		std::string characterAppearance;
+		bool canLoadCharacterAppearance;
+
+		// Distributed Simulation
+		float simulationRadius;
+		float maxSimulationRadius;
+		
+		std::string osPlatform;
+		std::string vrDevice;
+
+		int loadingInstances;
+		bool appearanceDidLoad;
+		bool characterAppearanceLoaded;
+
+        // Only valid on the server!
+		shared_ptr<RakNet::SystemAddress> remoteAddress;
+
+		bool forceEarlySpawnLocationCalculation;
+		bool hasSpawnedAtLeastOnce;
+		std::string teleportSpawnName;
+		bool teleported; // describes whether player is currently in the middle of teleporting out
+		bool teleportedIn; // describes whether player joined current place by teleporting
+
+		std::string gameSessionID;
+
+		struct SpawnData
+		{
+			Vector3 position;
+			int forceFieldDuration;
+			CoordinateFrame cf;
+
+			SpawnData() : position(Vector3::zero()), forceFieldDuration(0) {}
+			SpawnData(Vector3 position, int forceFieldDuration, CoordinateFrame frame) 
+				: position(position), forceFieldDuration(forceFieldDuration), cf(frame)
+			{}
+		};
+
+		boost::scoped_ptr<SpawnData> nextSpawnLocation;
+
+		int followUserId;
+
+		// Instance
+		/*override*/ bool askAddChild(const Instance* instance) const {return true;}
+		/*override*/ void verifySetParent(const Instance* instance) const;
+		/*override*/ void onServiceProvider(ServiceProvider* oldProvider, ServiceProvider* newProvider);
+
+		void onCharacterChangedFrontend();
+
+		void registerLocalPlayerNotIdle();
+
+		void loadInsertPanel(DataModel* dataModel);
+
+		shared_ptr<PersistentDataStore> persistentData;
+		std::list<boost::function<void(bool)> > waitForDataReadyWaiters;
+		void fireWaitForDataReady();
+		static void LoadDataResultHelper(boost::weak_ptr<Player> weakPlayer, shared_ptr<const Reflection::ValueMap> result);
+		void loadDataResult(shared_ptr<const Reflection::ValueMap> result);
+
+		bool autoJumpEnabled;
+
+	public:
+		enum MembershipType
+	    {
+		    MEMBERSHIP_NONE						= 0,
+		    MEMBERSHIP_BUILDERS_CLUB			= 1,
+		    MEMBERSHIP_TURBO_BUILDERS_CLUB		= 2,
+		    MEMBERSHIP_OUTRAGEOUS_BUILDERS_CLUB	= 3
+	    };
+		enum ChatMode
+		{
+			CHAT_MODE_MENU = 0,
+			CHAT_MODE_TEXT_AND_MENU = 1
+		};
+		enum ChatFilterType {
+			CHAT_FILTER_WHITELIST,
+			CHAT_FILTER_BLACKLIST
+		};
+
+		// debug timer
+		RBX::Timer<RBX::Time::Fast> appearanceFetchTimer;
+
+		static Reflection::PropDescriptor<Player, int> prop_userId;
+		static Reflection::PropDescriptor<Player, int> prop_userIdDeprecated;
+		static Reflection::PropDescriptor<Player, bool> prop_SuperSafeChat;
+		static Reflection::BoundProp<float> prop_SimulationRadius;
+		static Reflection::BoundProp<float> prop_MaxSimulationRadius;
+        static Reflection::PropDescriptor<Player, float> prop_DeprecatedMaxSimulationRadius;
+		static Reflection::BoundProp<std::string> prop_OsPlatform;
+		static Reflection::BoundProp<std::string> prop_VRDevice;
+		static Reflection::RemoteEventDesc<Player, void(shared_ptr<const Reflection::ValueArray>)> event_cloudEditSelectionChanged;
+
+		rbx::remote_signal<void(std::string, std::string, std::string)> scriptSecurityErrorSignal;
+		rbx::remote_signal<void(std::string,Vector3)> remoteInsertSignal;
+
+		rbx::remote_signal<void()> connectDiedSignalBackend;
+
+		rbx::remote_signal<void(bool,int)> remoteFriendServiceSignal;
+		rbx::remote_signal<void()> killPlayerSignal;
+		rbx::remote_signal<void(float)> simulationRadiusChangedSignal;
+
+		rbx::remote_signal<void(std::string)> statsSignal;
+		rbx::signals::scoped_connection charChildAddedConnection; 
+		
+		rbx::signal<void(std::string, shared_ptr<Instance>)> chattedSignal;
+		rbx::signal<void(shared_ptr<Instance>)> characterAddedSignal;
+		rbx::remote_signal<void(shared_ptr<Instance>)> CharacterAppearanceLoadedSignal;
+		rbx::signal<void(shared_ptr<Instance>)> characterRemovingSignal;
+		rbx::signal<void(Vector3)> nextSpawnLocationChangedSignal;
+		rbx::signal<void(double)> idledSignal;			
+
+		rbx::signal<void(shared_ptr<Instance>, FriendService::FriendStatus)> friendStatusChangedSignal;
+
+        rbx::remote_signal<void(TeleportService::TeleportState, int, std::string)> onTeleportSignal;
+		rbx::remote_signal<void(TeleportService::TeleportState, shared_ptr<const Reflection::ValueTable>, shared_ptr<Instance>)> onTeleportInternalSignal;
+
+		rbx::remote_signal<void(std::string)> setShutdownMessageSignal;
+		rbx::remote_signal<void(shared_ptr<const Reflection::ValueArray>)> cloudEditSelectionChanged;
+
+		Player();
+		~Player();
+
+		void doFirstSpawnLocationCalculation(const ServiceProvider* serviceProvider, const std::string& preferedSpawnName);
+		void reportScriptSecurityError(const std::string& hash, const std::string& error, const std::string& stack);
+		void killPlayer();		
+
+		void requestFriendship(shared_ptr<Instance> player);
+		void revokeFriendship(shared_ptr<Instance> player);
+
+		// Keyboard/Mouse input API
+		shared_ptr<Mouse> getMouse() { return mouse; }
+		shared_ptr<Instance> getMouseInstance();
+
+		//Persistent Data API
+		void loadData();
+		void saveData();
+		void saveLeaderboardData();
+		int getDataComplexityLimit() const { return dataComplexityLimit; }
+		void setDataComplexityLimit(int value);
+		int getDataComplexity() const;
+
+		bool getDataReady() const { return dataReady; }
+
+		void waitForDataReady(boost::function<void(bool)> resumeFunction, boost::function<void(std::string)> errorFunction);
+		double loadNumber(std::string key);
+		void saveNumber(std::string key, double value);
+		std::string loadString(std::string key);
+		void saveString(std::string key, std::string value);
+		bool loadBoolean(std::string key);
+		void saveBoolean(std::string key, bool value);
+		shared_ptr<Instance> loadInstance(std::string key);
+		void saveInstance(std::string key, shared_ptr<Instance> value);
+		shared_ptr<const Reflection::ValueArray> loadList(std::string key);
+		void saveList(std::string key, shared_ptr<const Reflection::ValueArray> value);
+		shared_ptr<const RBX::Reflection::ValueMap> loadTable(std::string key);
+		void saveTable(std::string key, shared_ptr<const RBX::Reflection::ValueMap> value);
+
+		/*override*/ void setName(const std::string& value);
+		/*override*/ bool canClientCreate() { return true; }
+
+		ModelInstance* getDangerousCharacter() const {return character.get();}
+
+		boost::shared_ptr<ModelInstance> getSharedCharacter() {return character; }
+		ModelInstance* getCharacter() {return character.get();}
+		const ModelInstance* getConstCharacter() const {return character.get();}
+		void setCharacter(ModelInstance* value);
+
+		const SpawnLocation* getConstRespawnLocation() const {
+			if (shared_ptr<SpawnLocation> shared_respawnLocation = respawnLocation.lock())
+				return shared_respawnLocation.get();
+			else 
+				return NULL;
+		}
+		SpawnLocation* getDangerousRespawnLocation() const {
+			if (shared_ptr<SpawnLocation> shared_respawnLocation = respawnLocation.lock())
+				return shared_respawnLocation.get();
+			else 
+				return NULL;
+		}
+		void setRespawnLocation(SpawnLocation* value);
+
+		bool getCanLoadCharacterAppearance() const { return canLoadCharacterAppearance;}
+		void setCanLoadCharacterAppearance(bool value);
+
+		bool getAutoJumpEnabled() const { return autoJumpEnabled; }
+		void setAutoJumpEnabled(bool value);
+
+		const PartInstance* hasCharacterHead(CoordinateFrame& headPos) const;
+
+		bool getHasGroupBuildTools() const { return hasGroupBuildTools; }
+		void setHasGroupBuildTools(bool value);
+
+		void giveBuildTools();
+		void removeBuildTools();
+
+		void setAppearanceLoaded();
+
+		// Personal Server API
+		void getWebPersonalServerRank(boost::function<void(std::string)> resumeFunction, boost::function<void(std::string)> errorFunction);
+		void setWebPersonalServerRank(int newRank, boost::function<void(bool)> resumeFunction, boost::function<void(std::string)> errorFunction);
+
+		int getPersonalServerRank() const { return (personalServerRank > 255) ? 0 : personalServerRank; } // 255 is max rank allowed by setter.
+		void setPersonalServerRank(int value);
+		
+		const Primitive* getConstCharacterRoot() const;
+
+		BrickColor getTeamColor() const {return teamColor;}
+		void setTeamColor(BrickColor value);
+
+		bool getNeutral() const {return neutral;}
+		void setNeutral(bool value);
+
+		std::string getCharacterAppearance() const {return characterAppearance;}
+		void setCharacterAppearance(const std::string& value);
+
+		static void setAppearanceParent(weak_ptr<Player> player, weak_ptr<Instance> instance, bool equipped);
+
+		static void setGearParent(weak_ptr<Player> player, weak_ptr<Instance> instance, bool equipped);
+		
+		bool getSuperSafeChat() const;
+		void setSuperSafeChat(bool value);
+
+        float getDeprecatedMaxSimulationRadius() const {return 0.f;}
+        void setDeprecatedMaxSimulationRadius(float val){}
+
+		ChatMode getChatMode() const;
+
+		void setUnder13(bool value);
+		bool getUnder13() {return under13;};
+
+		void setUserId(int value);
+		int getUserID() const {return userId;}
+
+		void setGameSessionID(std::string value);
+		std::string getGameSessionID() { return gameSessionID; }
+		
+		bool isGuest() const { return userId < 0; }
+		void setMembershipType(MembershipType value);
+		MembershipType getMembershipType() const {return membershipType;}
+
+		void setCameraMode(RBX::Camera::CameraMode value);
+		RBX::Camera::CameraMode getCameraMode() const {return cameraMode;}
+		
+		
+		void setNameDisplayDistance(float value);
+		float getNameDisplayDistance() const		{return nameDisplayDistance;}
+
+		void setHealthDisplayDistance(float value);
+		float getHealthDisplayDistance() const		{return healthDisplayDistance;}
+
+		void setCameraMaxZoomDistance(float _cameraMaxZoomDistance);
+		float getCameraMaxZoomDistance() const		{return cameraMaxZoomDistance;}
+
+		void setCameraMinZoomDistance(float _cameraMinZoomDistance);
+		float getCameraMinZoomDistance() const		{return cameraMinZoomDistance;}
+
+		void setDevEnableMouseLockOption(bool setting);
+		bool getDevEnableMouseLockOption() const		{return enableMouseLockOption;}
+		void setDevTouchCameraMode(StarterPlayerService::DeveloperTouchCameraMovementMode setting);
+		StarterPlayerService::DeveloperTouchCameraMovementMode getDevTouchCameraMode() const		{return touchCameraMovementMode;}
+		void setDevComputerCameraMode(StarterPlayerService::DeveloperComputerCameraMovementMode setting);
+		StarterPlayerService::DeveloperComputerCameraMovementMode getDevComputerCameraMode() const		{return computerCameraMovementMode;}
+		void setDevCameraOcclusionMode(StarterPlayerService::DeveloperCameraOcclusionMode setting);
+		StarterPlayerService::DeveloperCameraOcclusionMode getDevCameraOcclusionMode() const		{return cameraOcclusionMode;}
+
+		void setDevTouchMovementMode(StarterPlayerService::DeveloperTouchMovementMode setting);
+		StarterPlayerService::DeveloperTouchMovementMode getDevTouchMovementMode() const		{return touchMovementMode;}
+		void setDevComputerMovementMode(StarterPlayerService::DeveloperComputerMovementMode setting);
+		StarterPlayerService::DeveloperComputerMovementMode getDevComputerMovementMode() const		{return computerMovementMode;}
+
+		void setAccountAge(int value);
+		int getAccountAge() const {return accountAge;}
+	
+		void updateSimulationRadius(float value);
+		float getSimulationRadius() const {return simulationRadius;}
+		void setSimulationRadius(float value);
+
+		float getMaxSimulationRadius() const {return maxSimulationRadius;}
+		void setMaxSimulationRadius(float value);
+
+		CoordinateFrame getCloudEditCameraCoordinateFrame() const { return cloudEditCameraCFrame; }
+		void setCloudEditCameraCoordinateFrame(const CoordinateFrame& cframe);
+
+		std::string getOsPlatform() const {return osPlatform;}
+
+		void rebuildBackpack();			// Copy the backpack from the StartPack service
+		void rebuildGui();				// Copy the gui from the StarterGui service
+		void rebuildPlayerScripts();	// Copy the LocalScripts from the StarterPlayer/PlayerScripts service
+
+		void createPlayerGui();
+
+		Backpack* getPlayerBackpack();
+		const Backpack* getConstPlayerBackpack() const;
+        
+        void luaJumpCharacter();
+        void luaMoveCharacter(Vector2 walkDirection, float maxWalkDelta);
+
+		void move(Vector3 walkVector, bool relativeToCamera);
+
+		float distanceFromCharacter(Vector3 point);
+
+		void luaLoadCharacter(bool inGame);
+		void loadCharacter(bool inGame, std::string preferedSpawnName);
+
+		void removeCharacter();
+		void removeCharacterAppearance();
+		void removeCharacterAppearanceScript();
+
+		void loadCharacterAppearance(bool blockingCall);
+		void loadCharacterAppearanceScript(shared_ptr<Instance> asset);
+
+		static void onLocalPlayerNotIdle(RBX::ServiceProvider* serviceProvider);
+
+		void renderDPhysicsRegion(Adorn* adorn);
+		void renderStreamedRegion(Adorn* adorn);
+        void renderPartMovementPath(Adorn* adorn);
+
+		static bool physicsOutBandwidthExceeded(const RBX::Instance* context);
+		static double getNetworkBufferHealth(const RBX::Instance* context);
+		void reportStat(std::string stat);
+
+		void addToLoadingInstances(int newInstances) { loadingInstances += newInstances; }
+		void removeFromLoadingInstances(int oldInstances) { loadingInstances -= oldInstances; }
+		int getLoadingInstances() { return loadingInstances; }
+
+		bool getAppearanceDidLoad() const { return appearanceDidLoad; }
+		bool getAppearanceDidLoadNonConst() { return appearanceDidLoad; }
+		void setAppearanceDidLoad(bool value);
+		bool getCharacterAppearanceLoaded() const { return characterAppearanceLoaded; }
+		void setCharacterAppearanceLoaded(bool value);
+		
+		void onFriendStatusChanged(shared_ptr<Instance> player, FriendService::FriendStatus friendStatus);
+		FriendService::FriendStatus getFriendStatus(shared_ptr<Instance> player);
+		void isFriendsWith(int otherUserId, boost::function<void(bool)> resumeFunction, boost::function<void(std::string)> errorFunction);
+		void isBestFriendsWith(int otherUserId, boost::function<void(bool)> resumeFunction, boost::function<void(std::string)> errorFunction);
+		void isInGroup(int groupId, boost::function<void(bool)> resumeFunction, boost::function<void(std::string)> errorFunction);
+		void getRankInGroup(int groupId, boost::function<void(int)> resumeFunction, boost::function<void(std::string)> errorFunction);
+		void getRoleInGroup(int groupId, boost::function<void(std::string)> resumeFunction, boost::function<void(std::string)> errorFunction);
+		void getFriendsOnline(int maxFriends, boost::function<void(shared_ptr<const Reflection::ValueArray>)> resumeFunction, boost::function<void(std::string)> errorFunction); 
+
+		void loadChatInfo();
+		
+		// should be called with at least data model read lock
+		bool isChatInfoValid() const;
+		ChatFilterType getChatFilterType() const;
+
+		// for testing only
+		void setChatInfo(ChatFilterType filterType);
+
+		void kick(std::string msg);
+		void handleTeleportInternalSignal(TeleportService::TeleportState teleportState, shared_ptr<const Reflection::ValueTable> teleportInfo, shared_ptr<Instance> customLoadingGUI);
+		void handleTeleportSignalBackend(TeleportService::TeleportState teleportState);
+		void setForceEarlySpawnLocationCalculation();
+		bool calculatesSpawnLocationEarly() const;
+
+		const RakNet::SystemAddress& getRemoteAddress() const;
+		const SystemAddress getRemoteAddressAsRbxAddress() const;
+		void setRemoteAddress(const RakNet::SystemAddress& address);
+
+		void onTeleport(TeleportService::TeleportState teleportState, int placeId, std::string instanceIdOrSpawnName);
+        void onTeleportInternal(TeleportService::TeleportState teleportState, shared_ptr<const Reflection::ValueTable> teleportInfo, shared_ptr<Instance> customLoadingGUI = shared_ptr<Instance>());
+		bool getTeleported() const { return teleported; }
+		bool getTeleportedIn() const { return teleportedIn; }
+		void setTeleportedIn(bool value);
+
+		int getFollowUserId() const { return followUserId; }
+		void setFollowUserId(int followUserId) { this->followUserId = followUserId; }
+
+		void loadStarterGear();
+		void onCharacterDied();
+
+		/*override*/ void destroy();
+
+	private:
+
+
+		void setupHumanoid(shared_ptr<Humanoid> humanoid);
+		void characterChildAdded(shared_ptr<Instance> child);
+
+		void doPeriodicIdleCheck();
+		void checkContextReadyToSpawnCharacter();
+		static void calculateNextSpawnLocationHelper(
+				weak_ptr<Player>& weakPlayer, const ServiceProvider* serviceProvider);
+		void calculateNextSpawnLocation(const ServiceProvider* serviceProvider);
+		SpawnData calculateSpawnLocation(const std::string& preferedSpawnName);
+
+		static void loadChatInfoInternal(weak_ptr<Player> weakPlayer);
+
+		Time lastActivityTime;
+		
+		MembershipType membershipType;
+		int accountAge;
+
+		bool chatInfoHasBeenLoaded;
+		ChatFilterType chatFilterType;
+
+		shared_ptr<RBX::Mouse> mouse;
+		RBX::Camera::CameraMode cameraMode;
+
+		float nameDisplayDistance;
+		float healthDisplayDistance;
+		float cameraMaxZoomDistance;
+		float cameraMinZoomDistance;
+		bool enableMouseLockOption;
+		RBX::StarterPlayerService::DeveloperTouchCameraMovementMode touchCameraMovementMode;
+		RBX::StarterPlayerService::DeveloperComputerCameraMovementMode computerCameraMovementMode;
+		RBX::StarterPlayerService::DeveloperCameraOcclusionMode cameraOcclusionMode;
+		RBX::StarterPlayerService::DeveloperTouchMovementMode touchMovementMode;
+		RBX::StarterPlayerService::DeveloperComputerMovementMode computerMovementMode;
+
+		bool copiedGuiOnce;
+	};
+
+}  // namespace
+}  // namespace