the whole game

src/server/ArgumentsSettings.cpp

@@ -0,0 +1,62 @@
+#include "ArgumentsSettings.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+ArgumentsSettings::ArgumentsSettings(int numArguments, char** arguments)
+: externalPath("."), levelName("level"), showHelp(false), port(19132), serverKey(""), cachePath("."), levelDir("level") {
+	for(int a = 0; a < numArguments; ++a) {
+		if(strcmp(arguments[a], "--help") == 0) {
+			showHelp = true;
+		} else if(strcmp(arguments[a], "--externalpath") == 0) {
+			if(a + 1 < numArguments) {
+				externalPath = std::string(arguments[a+1]);
+				a++; // Skip the next argument since it's part of this one.
+			}
+		} else if(strcmp(arguments[a], "--levelname") == 0) {
+			if(a + 1 < numArguments) {
+				levelName = std::string(arguments[a+1]);
+				a++; // Skip the next argument since it's part of this one.
+			}
+		} else if(strcmp(arguments[a], "--leveldir") == 0) {
+			if(a + 1 < numArguments) {
+				levelDir = std::string(arguments[a+1]);
+				a++; // Skip the next argument since it's part of this one.
+			}
+		} else if(strcmp(arguments[a], "--port") == 0) {
+			if(a + 1 < numArguments) {
+				port = atoi(arguments[a+1]);
+				a++; // Skip the next argument since it's part of this one.
+			}
+		} else if(strcmp(arguments[a], "--serverkey") == 0) {
+			if(a + 1 < numArguments) {
+				serverKey = std::string(arguments[a+1]);
+				a++; // Skip the next argument since it's part of this one.
+			}
+		} else if(strcmp(arguments[a], "--cachepath") == 0) {
+			if(a + 1 < numArguments) {
+				cachePath = std::string(arguments[a+1]);
+			}
+		}
+	}
+}
+std::string ArgumentsSettings::getExternalPath() {
+	return externalPath;
+}
+std::string ArgumentsSettings::getLevelName() {
+	return levelName;
+}
+std::string ArgumentsSettings::getServerKey() {
+	return serverKey;
+}
+std::string ArgumentsSettings::getCachePath() {
+	return cachePath;
+}
+std::string ArgumentsSettings::getLevelDir() {
+	return levelDir;
+}
+bool ArgumentsSettings::getShowHelp() {
+	return showHelp;
+}
+int ArgumentsSettings::getPort() {
+	return port;
+}

src/server/ArgumentsSettings.h

@@ -0,0 +1,24 @@
+#ifndef NET_MINECRAFT_WORLD_LEVEL__ArgumentsSettings_H__
+#define NET_MINECRAFT_WORLD_LEVEL__ArgumentsSettings_H__
+#include <string>
+class ArgumentsSettings {
+public:
+	ArgumentsSettings(int numArguments, char** arguments);
+	std::string getExternalPath();
+	std::string getLevelName();
+	std::string getServerKey();
+	std::string getCachePath();
+	std::string getLevelDir();
+	bool getShowHelp();
+	int getPort();
+private:
+	std::string cachePath;
+	std::string externalPath;
+	std::string levelName;
+	std::string levelDir;
+	std::string serverKey;
+	bool showHelp;
+	int port;
+};
+
+#endif

src/server/CreatorLevel.cpp

@@ -0,0 +1,28 @@
+#include "CreatorLevel.h"
+#include "../world/level/chunk/ChunkSource.h"
+#include "../util/PerfTimer.h"
+
+CreatorLevel::CreatorLevel(LevelStorage* levelStorage, const std::string& levelName, const LevelSettings& settings, int generatorVersion, Dimension* fixedDimension /* = NULL */)
+:	super(levelStorage, levelName, settings, generatorVersion, fixedDimension)
+{
+}
+
+void CreatorLevel::tick() {
+	TIMER_PUSH("chunkSource");
+	_chunkSource->tick();
+
+	long time = levelData.getTime() + 1;
+	levelData.setTime(time);
+
+	TIMER_POP_PUSH("tickPending");
+	tickPendingTicks(false);
+
+	TIMER_POP();
+}
+
+/*
+void CreatorLevel::addToTickNextTick(int x, int y, int z, int tileId, int tickDelay) {
+	if (tileId >= Tile::water->id && tileId <= calmLava)
+		super::addToTickNextTick(x, y, z, tileId, tickDelay);
+}
+*/

src/server/CreatorLevel.h

@@ -0,0 +1,15 @@
+#ifndef NET_MINECRAFT_WORLD_LEVEL__CreatorLevel_H__
+#define NET_MINECRAFT_WORLD_LEVEL__CreatorLevel_H__
+
+#include "../world/level/Level.h"
+
+class CreatorLevel: public Level
+{
+	typedef Level super;
+public:
+	CreatorLevel(LevelStorage* levelStorage, const std::string& levelName, const LevelSettings& settings, int generatorVersion, Dimension* fixedDimension = NULL);
+
+	void tick();
+};
+
+#endif /* NET_MINECRAFT_WORLD_LEVEL__CreatorLevel_H__ */

src/server/ServerLevel.cpp

@@ -0,0 +1,67 @@
+#include "ServerLevel.h"
+#include "../network/RakNetInstance.h"
+#include "../network/packet/SetTimePacket.h"
+#include "../network/packet/SetHealthPacket.h"
+#include "../world/level/tile/LevelEvent.h"
+ServerLevel::ServerLevel(LevelStorage* levelStorage, const std::string& levelName, const LevelSettings& settings, int generatorVersion, Dimension* fixedDimension /* = NULL */)
+	: super(levelStorage, levelName, settings, generatorVersion, fixedDimension),
+	allPlayersAreSleeping(false){
+
+}
+
+void ServerLevel::updateSleepingPlayerList() {
+	bool allPlayersWasSleeping = allPlayersAreSleeping;
+	allPlayersAreSleeping = !players.empty();
+	for(PlayerList::iterator it = players.begin(); it != players.end(); ++it) {
+		Player* player = *it;
+		if(!player->isSleeping()) {
+			allPlayersAreSleeping = false;
+			break;
+		}
+	}
+	if(!allPlayersWasSleeping && allPlayersAreSleeping) {
+		levelEvent(NULL, LevelEvent::ALL_PLAYERS_SLEEPING, 0, 0, 0, 0);
+		for(PlayerList::iterator it = players.begin(); it != players.end(); ++it) {
+			(*it)->setAllPlayersSleeping();
+		}
+	}
+}
+
+void ServerLevel::awakenAllPlayers() {
+	allPlayersAreSleeping = false;
+	for(PlayerList::iterator it = players.begin(); it != players.end(); ++it) {
+		Player* player = *it;
+		if(player->isSleeping()) {
+			player->stopSleepInBed(false, false, true);
+			player->health = Player::MAX_HEALTH;
+			player->lastHealth = Player::MAX_HEALTH; 
+		}
+	}
+	SetHealthPacket packet(Player::MAX_HEALTH);
+	raknetInstance->send(packet);
+}
+
+bool ServerLevel::allPlayersSleeping() {
+	if(allPlayersAreSleeping && !isClientSide) {
+		// all players are sleeping, but have they slept long enough?
+		for(PlayerList::iterator it = players.begin(); it != players.end(); ++it) {
+			if(!(*it)->isSleepingLongEnough()) {
+				return false;
+			}
+		}
+		// yep
+		return true;
+	}
+	return false;
+}
+
+void ServerLevel::tick(){
+	super::tick();
+	if(allPlayersSleeping()) {
+		long newTime = levelData.getTime() + TICKS_PER_DAY;
+		levelData.setTime(newTime - (newTime % TICKS_PER_DAY));
+		SetTimePacket packet(levelData.getTime());
+		raknetInstance->send(packet);
+		awakenAllPlayers();
+	}
+}

src/server/ServerLevel.h

@@ -0,0 +1,20 @@
+#ifndef NET_MINECRAFT_WORLD_LEVEL__ServerLevel_H__
+#define NET_MINECRAFT_WORLD_LEVEL__ServerLevel_H__
+
+#include "../world/level/Level.h"
+
+class ServerLevel: public Level
+{
+	typedef Level super;
+public:
+	ServerLevel(LevelStorage* levelStorage, const std::string& levelName, const LevelSettings& settings, int generatorVersion, Dimension* fixedDimension = NULL);
+
+	void updateSleepingPlayerList();
+	void awakenAllPlayers();
+	bool allPlayersSleeping();
+	void tick();
+protected:
+	bool allPlayersAreSleeping;
+};
+
+#endif /* NET_MINECRAFT_WORLD_LEVEL__ServerLevel_H__ */

src/server/ServerPlayer.cpp

@@ -0,0 +1,165 @@
+#include "ServerPlayer.h"
+
+#include "../network/RakNetInstance.h"
+#include "../network/packet/ContainerOpenPacket.h"
+#include "../network/packet/ContainerClosePacket.h"
+#include "../network/packet/ContainerSetDataPacket.h"
+#include "../network/packet/ContainerSetSlotPacket.h"
+#include "../network/packet/ContainerSetContentPacket.h"
+#include "../network/packet/ChatPacket.h"
+#include "../network/packet/EntityEventPacket.h"
+#include "../network/packet/SetHealthPacket.h"
+#include "../network/packet/TakeItemEntityPacket.h"
+#include "../client/Minecraft.h"
+#include "../world/level/tile/entity/FurnaceTileEntity.h"
+#include "../world/inventory/FurnaceMenu.h"
+#include "../world/inventory/FillingContainer.h"
+#include "../world/inventory/ContainerMenu.h"
+#include "../world/entity/EntityEvent.h"
+#include "../network/packet/AnimatePacket.h"
+#include "../world/level/tile/entity/ChestTileEntity.h"
+#include "../network/packet/HurtArmorPacket.h"
+
+ServerPlayer::ServerPlayer( Minecraft* minecraft, Level* level )
+:   super(level, minecraft->isCreativeMode()),
+	_mc(minecraft),
+	_sentHealth(-999),
+	_containerCounter(0)
+{
+	hasFakeInventory = true;
+	footSize = 0;
+}
+
+ServerPlayer::~ServerPlayer() {
+	setContainerMenu(NULL);
+}
+
+void ServerPlayer::stopSleepInBed(bool forcefulWakeUp, bool updateLevelList, bool saveRespawnPoint) {
+	if(isSleeping()) {
+		AnimatePacket packet(AnimatePacket::WAKE_UP, this);
+		_mc->raknetInstance->send(owner, packet);
+	}
+	super::stopSleepInBed(forcefulWakeUp, updateLevelList, saveRespawnPoint);
+}
+
+
+void ServerPlayer::aiStep() {
+    updateAttackAnim();
+    super::aiStep();
+}
+
+void ServerPlayer::tick() {
+	super::tick();
+
+	if(!useItem.isNull())
+		useItemDuration--;
+
+	//LOGI("Server:tick. Cmenu: %p\n", containerMenu);
+	if (containerMenu)
+		containerMenu->broadcastChanges();
+
+	if (health != _sentHealth) {
+		_sentHealth = health;
+		SetHealthPacket packet(health);
+		_mc->raknetInstance->send(owner, packet);
+	}
+}
+
+void ServerPlayer::take( Entity* e, int orgCount ) {
+	TakeItemEntityPacket packet(e->entityId, entityId);
+	_mc->raknetInstance->send(packet);
+
+	super::take(e, orgCount);
+}
+
+void ServerPlayer::hurtArmor(int dmg) {
+    super::hurtArmor(dmg);
+    HurtArmorPacket packet(dmg);
+    _mc->raknetInstance->send(owner, packet);
+}
+
+void ServerPlayer::openContainer( ChestTileEntity* container) {
+	LOGI("Client is opening a container\n");
+	nextContainerCounter();
+	ContainerOpenPacket packet(_containerCounter, ContainerType::CONTAINER, container->getName(), container->getContainerSize());
+	_mc->raknetInstance->send(owner, packet);
+	setContainerMenu(new ContainerMenu(container, container->runningId));
+}
+
+void ServerPlayer::openFurnace( FurnaceTileEntity* furnace ) {
+	LOGI("Client is opening a furnace\n");
+	nextContainerCounter();
+	ContainerOpenPacket packet(_containerCounter, ContainerType::FURNACE, furnace->getName(), furnace->getContainerSize());
+	_mc->raknetInstance->send(owner, packet);
+	setContainerMenu(new FurnaceMenu(furnace));
+}
+
+void ServerPlayer::closeContainer() {
+	LOGI("Client is closing a container\n");
+	ContainerClosePacket packet(containerMenu->containerId);
+	_mc->raknetInstance->send(owner, packet);
+	doCloseContainer();
+}
+
+void ServerPlayer::doCloseContainer() {
+	if (!containerMenu) {
+		LOGE("Container is missing @ doCloseContainer!\n");
+	}
+	setContainerMenu(NULL);
+}
+
+bool ServerPlayer::hasResource( int id ) {
+	return true;
+}
+
+//
+// IContainerListener
+//
+void ServerPlayer::setContainerData( BaseContainerMenu* menu, int id, int value ) {
+	ContainerSetDataPacket p(menu->containerId, id, value);
+	_mc->raknetInstance->send(owner, p);
+	//LOGI("Setting container data for id %d: %d\n", id, value);
+}
+
+void ServerPlayer::slotChanged( BaseContainerMenu* menu, int slot, const ItemInstance& item, bool isResultSlot ) {
+	if (isResultSlot) return;
+	ContainerSetSlotPacket p(menu->containerId, slot, item);
+	_mc->raknetInstance->send(owner, p);
+	//LOGI("Slot %d changed\n", slot);
+}
+
+void ServerPlayer::refreshContainer( BaseContainerMenu* menu, const std::vector<ItemInstance>& items ) {
+	ContainerSetContentPacket p(menu->containerId, menu->getItems());
+	_mc->raknetInstance->send(owner, p);
+	//LOGI("Refreshing container with %d items\n", items.size());
+}
+
+void ServerPlayer::nextContainerCounter() {
+	if (++_containerCounter >= 100)
+		_containerCounter = 0;
+}
+
+void ServerPlayer::setContainerMenu( BaseContainerMenu* menu ) {
+	if (containerMenu == menu)
+		return;
+
+	if (containerMenu)
+		delete containerMenu;
+
+	containerMenu = menu;
+	if (containerMenu) {
+		containerMenu->containerId = _containerCounter;
+		containerMenu->setListener(this);
+	}
+}
+
+void ServerPlayer::completeUsingItem() {
+	EntityEventPacket p(entityId, EntityEvent::USE_ITEM_COMPLETE);
+	_mc->raknetInstance->send(owner, p);
+	super::completeUsingItem();
+}
+
+void ServerPlayer::displayClientMessage( const std::string& messageId ) {
+	ChatPacket package(messageId);
+	_mc->raknetInstance->send(owner, package);
+}

src/server/ServerPlayer.h

@@ -0,0 +1,55 @@
+#ifndef ServerPlayer_H__
+#define ServerPlayer_H__
+
+#include "../world/entity/player/Player.h"
+#include "../world/inventory/BaseContainerMenu.h"
+
+class Minecraft;
+class FurnaceTileEntity;
+class ItemInstance;
+class FillingContainer;
+class ChestTileEntity;
+
+class ServerPlayer: public Player,
+					public IContainerListener
+{
+    typedef Player super;
+public:
+    ServerPlayer(Minecraft* minecraft, Level* level);
+
+	~ServerPlayer();
+
+	void aiStep();
+	void tick();
+	void take(Entity* e, int orgCount);
+
+	void hurtArmor(int dmg);
+
+	void displayClientMessage(const std::string& messageId);
+
+	void openContainer(ChestTileEntity* furnace);
+	void openFurnace(FurnaceTileEntity* furnace);
+	void closeContainer();
+	void doCloseContainer();
+
+	bool hasResource( int id );
+	//
+	// IContainerListener
+	//
+	void setContainerData(BaseContainerMenu* menu, int id, int value);
+	void slotChanged(BaseContainerMenu* menu, int slot, const ItemInstance& item, bool isResultSlot);
+	void refreshContainer(BaseContainerMenu* menu, const std::vector<ItemInstance>& items);
+
+	virtual void stopSleepInBed(bool forcefulWakeUp, bool updateLevelList, bool saveRespawnPoint);
+
+	void completeUsingItem();
+private:
+	void nextContainerCounter();
+	void setContainerMenu( BaseContainerMenu* menu );
+
+	Minecraft* _mc;
+    int _sentHealth;
+	int _containerCounter;
+};
+
+#endif /*ServerPlayer_H__*/