Add misc files

Minecraft.World/C4JThread.h

@@ -0,0 +1,227 @@
+#pragma once
+#include <queue>
+
+typedef int (C4JThreadStartFunc)(void* lpThreadParameter);
+
+class Level;
+
+#if defined(_XBOX_ONE) || defined(__ORBIS__)
+
+#define CPU_CORE_MAIN_THREAD 0
+
+#define CPU_CORE_SERVER 1
+
+#define CPU_CORE_CHUNK_UPDATE 2
+#define CPU_CORE_REMOVE_PLAYER 2
+
+#define CPU_CORE_CHUNK_REBUILD_A 3
+#define CPU_CORE_SAVE_THREAD_A 3
+#define CPU_CORE_UI_SCENE 3
+#define CPU_CORE_POST_PROCESSING 3
+#define CPU_CORE_DQR_REALTIMESESSION 3
+
+#define CPU_CORE_CHUNK_REBUILD_B 4
+#define CPU_CORE_SAVE_THREAD_B 4
+#define CPU_CORE_TILE_UPDATE 4
+#define CPU_CORE_CONNECTIONS 4
+
+#define CPU_CORE_CHUNK_REBUILD_C 5
+#define CPU_CORE_SAVE_THREAD_C 5
+#define CPU_CORE_LEADERBOARDS 5 // Orbis only
+
+#else
+
+#define CPU_CORE_MAIN_THREAD 0
+
+#define CPU_CORE_CHUNK_REBUILD_A 1
+#define CPU_CORE_SAVE_THREAD_A 1
+#define CPU_CORE_TILE_UPDATE 1
+#define CPU_CORE_CONNECTIONS 1
+
+#define CPU_CORE_CHUNK_UPDATE 2
+#define CPU_CORE_REMOVE_PLAYER 2
+
+#define CPU_CORE_CHUNK_REBUILD_B 3
+#define CPU_CORE_SAVE_THREAD_B 3
+#define CPU_CORE_UI_SCENE 3
+#define CPU_CORE_POST_PROCESSING 3
+
+#define CPU_CORE_SERVER 4
+
+#define CPU_CORE_CHUNK_REBUILD_C 5
+#define CPU_CORE_SAVE_THREAD_C 5
+#define CPU_CORE_LEADERBOARDS 5 // Sony only
+
+#endif
+
+#include <Windows.h>
+
+class C4JThread
+{
+public:
+
+	class Event
+	{
+	public:
+		enum EMode
+		{
+			e_modeAutoClear,
+			e_modeManualClear
+		};
+		Event(EMode mode = e_modeAutoClear);	
+		~Event();
+		void Set();
+		void Clear();
+		DWORD WaitForSignal(int timeoutMs);
+
+	private:
+		EMode	m_mode;
+	#ifdef __PS3__
+		sys_event_flag_t m_event; 
+	#elif defined __ORBIS__
+		SceKernelEventFlag m_event;
+	#elif defined __PSVITA__
+		SceUID m_event;
+	#else
+		HANDLE m_event;
+	#endif // __PS3__
+	};
+
+	class EventArray
+	{
+	public:
+		enum EMode
+		{
+			e_modeAutoClear,
+			e_modeManualClear
+		};
+
+		EventArray(int size, EMode mode = e_modeAutoClear);
+
+		void Set(int index);
+		void Clear(int index);
+		void SetAll();
+		void ClearAll();
+		DWORD WaitForAll(int timeoutMs);
+		DWORD WaitForAny(int timeoutMs);
+		DWORD WaitForSingle(int index, int timeoutMs);
+#ifdef __PS3__
+		void Cancel();
+#endif
+
+	private:
+		int		m_size;
+		EMode	m_mode;
+#ifdef __PS3__
+		sys_event_flag_t	m_events; 
+#elif defined __ORBIS__
+		SceKernelEventFlag	m_events;
+#elif defined __PSVITA__
+		SceUID m_events;
+#else
+		HANDLE*				m_events;
+#endif // __PS3__
+	};
+
+
+
+	class EventQueue
+	{
+		typedef void (UpdateFunc)(void* lpParameter);
+		typedef void (ThreadInitFunc)();
+
+		C4JThread*				m_thread;
+		std::queue<void*>		m_queue; 
+		C4JThread::EventArray*	m_startEvent;
+		C4JThread::Event*		m_finishedEvent;
+		CRITICAL_SECTION		m_critSect;
+		UpdateFunc*				m_updateFunc;
+		ThreadInitFunc*			m_threadInitFunc;
+		char					m_threadName[64];
+		int						m_processor;
+		int						m_priority;
+		void init();
+		static int threadFunc(void* lpParam);
+		void threadPoll();
+
+	public:
+		EventQueue(UpdateFunc* updateFunc, ThreadInitFunc threadInitFunc, const char* szThreadName);
+		void setProcessor(int proc) { m_processor = proc; if(m_thread) m_thread->SetProcessor(proc); }
+		void setPriority(int priority) { m_priority = priority; if(m_thread) m_thread->SetPriority(priority); }
+		void sendEvent(Level* pLevel);
+		void waitForFinish();
+	};
+
+
+
+	C4JThread(C4JThreadStartFunc* startFunc, void* param, const char* threadName, int stackSize = 0);
+	C4JThread( const char* mainThreadName ); // only used for the main thread
+	~C4JThread();
+
+	void Run();
+	bool isRunning() { return m_isRunning; }
+	bool hasStarted() { return m_hasStarted; }
+	void SetProcessor(int proc);
+	void SetPriority(int priority);
+	DWORD WaitForCompletion(int timeoutMs);
+	int GetExitCode();
+	char* getName() { return m_threadName; }
+	static void Sleep(int millisecs);
+	static C4JThread* getCurrentThread();
+	static bool isMainThread();
+	static char* getCurrentThreadName() { return getCurrentThread()->getName(); }
+
+#ifdef __ORBIS__
+	static void PushAffinityAllCores();		 // PS4 only
+	static void PopAffinity();
+	static __thread SceKernelCpumask m_oldAffinityMask;
+#endif // __ORBIS__
+
+#ifdef _XBOX_ONE
+	static void StaticInit();
+#endif
+
+private:
+	void*				m_threadParam;
+	C4JThreadStartFunc*	m_startFunc;
+	int					m_stackSize;
+	char				m_threadName[64];
+	bool				m_isRunning;
+	bool				m_hasStarted;
+	int					m_exitCode;
+	__int64				m_lastSleepTime;
+	static std::vector<C4JThread*> ms_threadList;
+	static CRITICAL_SECTION ms_threadListCS;
+
+#ifdef _XBOX_ONE
+	// 4J Stu - On XboxOne the main thread is not the one that does all the static init, so we have to set this up later
+	static C4JThread *m_mainThread;
+#else
+	static C4JThread	m_mainThread;
+#endif
+
+#ifdef __PS3__
+	sys_ppu_thread_t m_threadID;
+	Event			*m_completionFlag;
+	int				m_priority;
+	static void entryPoint(uint64_t);
+#elif defined __ORBIS__
+	ScePthreadAttr	m_threadAttr;
+	ScePthread		m_threadID;
+	Event			*m_completionFlag;
+	int				m_priority;
+	static void *entryPoint(void *);
+#elif defined __PSVITA__
+	SceUID		m_threadID;
+	Event			*m_completionFlag;
+	int				m_priority;
+	static SceInt32	entryPoint(SceSize argSize, void *pArgBlock);
+#else
+	DWORD m_threadID;
+	HANDLE m_threadHandle;
+	Event			*m_completionFlag;
+	static DWORD WINAPI	entryPoint(LPVOID lpParam);
+#endif
+};
+void SetThreadName( DWORD dwThreadID, LPCSTR szThreadName );
+

Minecraft.World/DisconnectPacket.h

@@ -0,0 +1,72 @@
+#pragma once
+
+#include "Packet.h"
+
+class DisconnectPacket : public Packet, public std::enable_shared_from_this<DisconnectPacket>
+{
+public:
+
+	enum eDisconnectReason
+	{
+		eDisconnect_None = 0,
+		eDisconnect_Quitting,
+		eDisconnect_Closed,
+
+		eDisconnect_LoginTooLong,
+		eDisconnect_IllegalStance,
+		eDisconnect_IllegalPosition,
+		eDisconnect_MovedTooQuickly,
+		eDisconnect_NoFlying,
+		eDisconnect_Kicked,
+
+		eDisconnect_TimeOut,
+		eDisconnect_Overflow,
+		eDisconnect_EndOfStream,
+		eDisconnect_ServerFull,
+		eDisconnect_OutdatedServer,
+		eDisconnect_OutdatedClient,
+		eDisconnect_UnexpectedPacket,
+
+		eDisconnect_ConnectionCreationFailed,
+		eDisconnect_NoMultiplayerPrivilegesHost,
+		eDisconnect_NoMultiplayerPrivilegesJoin,
+
+		eDisconnect_NoUGC_AllLocal,
+		eDisconnect_NoUGC_Single_Local,
+		eDisconnect_ContentRestricted_AllLocal,
+		eDisconnect_ContentRestricted_Single_Local,
+#ifndef __PS3__
+		eDisconnect_NoUGC_Remote,
+#endif
+
+		eDisconnect_NoFriendsInGame,
+		eDisconnect_Banned,
+		eDisconnect_NotFriendsWithHost,
+		eDisconnect_NATMismatch,
+#ifdef __ORBIS__
+		eDisconnect_NetworkError,
+#endif
+#ifdef _XBOX_ONE
+		eDisconnect_ExitedGame,
+#endif
+	};
+
+	// 4J Stu - The reason was a string, but we need to send a non-locale specific reason
+	eDisconnectReason reason;
+
+	DisconnectPacket();
+	DisconnectPacket(eDisconnectReason reason);
+
+	virtual void read(DataInputStream *dis);
+	virtual void write(DataOutputStream *dos);
+	virtual void handle(PacketListener *listener);
+	virtual int getEstimatedSize();
+	virtual bool canBeInvalidated();
+	virtual bool isInvalidatedBy(std::shared_ptr<Packet> packet);
+
+public:
+	static std::shared_ptr<Packet> create() { return std::shared_ptr<Packet>(new DisconnectPacket()); }
+	virtual int getId() { return 255; }
+};
+
+

Minecraft.World/Minecraft.World.cpp

@@ -0,0 +1,104 @@
+#include "stdafx.h"
+
+#include "Packet.h"
+#include "MaterialColor.h"
+#include "Material.h"
+#include "Tile.h"
+#include "HatchetItem.h"
+#include "PickaxeItem.h"
+#include "ShovelItem.h"
+#include "BlockReplacements.h"
+#include "Biome.h"
+#include "Item.h"
+#include "FurnaceRecipes.h"
+#include "Recipes.h"
+#include "Stats.h"
+#include "Achievements.h"
+#include "Skeleton.h"
+#include "PigZombie.h"
+#include "TileEntity.h"
+#include "EntityIO.h"
+#include "SharedConstants.h"
+#include "MobCategory.h"
+#include "LevelChunk.h"
+#include "MineShaftPieces.h"
+#include "StrongholdFeature.h"
+#include "VillageFeature.h"
+#include "LevelType.h"
+#include "EnderMan.h"
+#include "PotionBrewing.h"
+#include "Enchantment.h"
+#include "VillagePieces.h"
+#include "RandomScatteredLargeFeature.h"
+
+#include "Minecraft.World.h"
+#include "..\Minecraft.Client\ServerLevel.h"
+#include "SparseLightStorage.h"
+#include "SparseDataStorage.h"
+#include "McRegionChunkStorage.h"
+#include "Villager.h"
+#include "LevelSettings.h"
+
+#ifdef _DURANGO
+#include "DurangoStats.h"
+#else
+#include "CommonStats.h"
+#endif
+
+void MinecraftWorld_RunStaticCtors()
+{
+	// The ordering of these static ctors can be important. If they are within statement blocks then
+	// DO NOT CHANGE the ordering - 4J Stu
+
+	Packet::staticCtor();
+
+	{
+		MaterialColor::staticCtor();
+		Material::staticCtor();
+		Tile::staticCtor();
+		HatchetItem::staticCtor();
+		PickaxeItem::staticCtor();
+		ShovelItem::staticCtor();
+		BlockReplacements::staticCtor();
+		Biome::staticCtor();	
+		Item::staticCtor();
+		FurnaceRecipes::staticCtor();
+		Recipes::staticCtor();	
+#ifdef _DURANGO
+		GenericStats::setInstance(new DurangoStats());
+#else
+		GenericStats::setInstance(new CommonStats());
+		Stats::staticCtor();
+#endif
+		//Achievements::staticCtor(); // 4J Stu - This is now called from within the Stats::staticCtor()
+		Skeleton::staticCtor();
+		PigZombie::staticCtor();
+		TileEntity::staticCtor();
+		EntityIO::staticCtor();
+		MobCategory::staticCtor();
+
+		Item::staticInit();
+		LevelChunk::staticCtor();
+
+		LevelType::staticCtor();
+
+		MineShaftPieces::staticCtor();
+		StrongholdFeature::staticCtor();
+		VillagePieces::Smithy::staticCtor();
+		VillageFeature::staticCtor();
+		RandomScatteredLargeFeature::staticCtor();
+	}
+	EnderMan::staticCtor();
+	PotionBrewing::staticCtor();
+	Enchantment::staticCtor();
+
+	SharedConstants::staticCtor();
+
+	ServerLevel::staticCtor();
+	SparseLightStorage::staticCtor();
+	CompressedTileStorage::staticCtor();
+	SparseDataStorage::staticCtor();
+	McRegionChunkStorage::staticCtor();
+	Villager::staticCtor();
+	GameType::staticCtor();
+}

Minecraft.World/Minecraft.World.h

@@ -0,0 +1,3 @@
+#pragma once
+
+void MinecraftWorld_RunStaticCtors();

Minecraft.World/Packet.h

@@ -0,0 +1,112 @@
+#pragma once
+
+class Packet;
+class PacketListener;
+class DataInputStream;
+class DataOutputStream;
+
+#define PACKET_ENABLE_STAT_TRACKING 0
+
+class Packet;
+
+typedef shared_ptr<Packet> (*packetCreateFn)();
+
+class Packet
+{
+public:
+	class PacketStatistics 
+	{
+	private:
+		int count;
+		int totalSize;
+
+		// 4J Added
+		__int64 countSamples[512];
+		__int64 sizeSamples[512];
+		int samplesPos;
+		__int64 firstSampleTime;
+
+
+	public:
+		const int id;
+
+	public:
+		PacketStatistics(int id) : id( id ), count( 0 ), totalSize( 0 ), samplesPos( 0 ), firstSampleTime( 0 ) { countSamples[0] = 0; sizeSamples[0] = 0; }
+		void addPacket(int bytes);
+		int getCount();
+		double getAverageSize();
+
+		// 4J Added
+		void renderStats();
+		__int64 getCountSample(int samplePos);
+		wstring getLegendString();
+	};
+
+	// 4J JEV, replaces the static blocks.
+	static void staticCtor();
+
+public:
+	static unordered_map<int, packetCreateFn> idToCreateMap; // IntHashMap in 1.8.2 ... needed? // Made public in 1.0.1
+
+	static unordered_set<int> clientReceivedPackets;
+	static unordered_set<int> serverReceivedPackets;
+	static unordered_set<int> sendToAnyClientPackets;
+
+	// 4J Stu - Added the sendToAnyClient param so we can limit some packets to be only sent to one player on a system
+	// 4J Stu - Added renderStats param for use in debugging
+	static void map(int id, bool receiveOnClient, bool receiveOnServer, bool sendToAnyClient, bool renderStats, const type_info& clazz, packetCreateFn );
+
+public:
+	const __int64 createTime;
+
+	Packet();
+
+	static shared_ptr<Packet> getPacket(int id);
+
+	// 4J Added
+	static bool canSendToAnyClient(shared_ptr<Packet> packet);
+
+	static void writeBytes(DataOutputStream *dataoutputstream, byteArray bytes);
+	static byteArray readBytes(DataInputStream *datainputstream);
+
+	virtual int getId() = 0;
+
+	bool shouldDelay;
+
+private:
+	// 4J Added to track stats for packets that are going out via QNet
+	static unordered_map<int, PacketStatistics *> outgoingStatistics; // IntHashMap in 1.8.2 ... needed?
+	static vector<PacketStatistics *> renderableStats;
+	static int renderPos;
+public:
+	static void recordOutgoingPacket(shared_ptr<Packet> packet);
+	static void renderPacketStats(int id);
+	static void renderAllPacketStats();
+	static void renderAllPacketStatsKey();
+	static __int64 getIndexedStatValue(unsigned int samplePos, unsigned int renderableId);
+
+private :
+	static unordered_map<int, PacketStatistics *> statistics;
+	//static int nextPrint;
+
+public:
+	static shared_ptr<Packet> readPacket(DataInputStream *dis, bool isServer);
+	static void writePacket(shared_ptr<Packet> packet, DataOutputStream *dos);
+	static void writeUtf(const wstring& value, DataOutputStream *dos);
+	static wstring readUtf(DataInputStream *dis, int maxLength);
+	virtual void read(DataInputStream *dis) = 0; // throws IOException = 0; TODO 4J JEV, should this declare a throws?
+	virtual void write(DataOutputStream *dos) = 0; // throws IOException = 0; TODO 4J JEV, should this declare a throws?
+	virtual void handle(PacketListener *listener) = 0;
+	virtual int getEstimatedSize() = 0;
+	virtual bool canBeInvalidated();
+	virtual bool isInvalidatedBy(shared_ptr<Packet> packet);
+	virtual bool isAync();
+
+	// 4J Stu - Brought these functions forward for enchanting/game rules
+	static shared_ptr<ItemInstance> readItem(DataInputStream *dis);
+	static void writeItem(shared_ptr<ItemInstance> item, DataOutputStream *dos);
+	static CompoundTag *readNbt(DataInputStream *dis);
+
+protected:
+	static void writeNbt(CompoundTag *tag, DataOutputStream *dos);
+};