LegacyRenouveau/Minecraft.World/LevelSettings.cpp

#include "Player.h"
#include "stdafx.h"
#include "LevelSettings.h"
#include "net.minecraft.world.level.storage.h"
#include "LevelType.h"
#include "LivingEntity.h"
#include "MobEffect.h"
#include "MobEffectInstance.h"

GameType *GameType::NOT_SET = nullptr;
GameType *GameType::SURVIVAL= nullptr;
GameType *GameType::CREATIVE = nullptr;
GameType *GameType::ADVENTURE = nullptr;
GameType* GameType::SPECTATOR = nullptr;

void GameType::staticCtor()
{
	NOT_SET = new GameType(-1, L"");
	SURVIVAL = new GameType(0, L"survival");
	CREATIVE = new GameType(1, L"creative");
	ADVENTURE = new GameType(2, L"adventure");
	SPECTATOR = new GameType(3, L"spectator");
}

GameType::GameType(int id, const wstring &name)
{
	this->id = id;
	this->name = name;
}

int GameType::getId()
{
	return id;
}

wstring GameType::getName()
{
	return name;
}

void GameType::updatePlayerAbilities(Abilities *abilities, shared_ptr<Player> player)
{
	if (this == CREATIVE)
	{
		abilities->mayfly = true;
		abilities->instabuild = true;
		abilities->invulnerable = true;
		abilities->spectatorMode = false;
		player->noPhysics = false;
		player->setInvisible(false);
        player->setPlayerGamePrivilege(Player::ePlayerGamePrivilege_CannotMine, 0);
        player->setPlayerGamePrivilege(Player::ePlayerGamePrivilege_CannotBuild, 0);
        player->setPlayerGamePrivilege(Player::ePlayerGamePrivilege_CanUseContainers, 1);
        player->setPlayerGamePrivilege(Player::ePlayerGamePrivilege_CanUseDoorsAndSwitches, 1);
        player->removeEffect(MobEffect::nightVision->id);
	}
	else if (this == SPECTATOR)
    {
        abilities->mayfly = true;
        abilities->flying = true;
        abilities->instabuild = false;
        abilities->invulnerable = true;
        abilities->spectatorMode = true;
        abilities->mayBuild = false;
        abilities->setFlyingSpeed(0.08f);
        player->noPhysics = true;
        player->onGround = false;
        player->addEffect(new MobEffectInstance(MobEffect::nightVision->id, 0x7fffffff, 0, true));
        player->setInvisible(true);
        player->setPlayerGamePrivilege(Player::ePlayerGamePrivilege_CannotMine, 1);
        player->setPlayerGamePrivilege(Player::ePlayerGamePrivilege_CannotBuild, 1);
        player->setPlayerGamePrivilege(Player::ePlayerGamePrivilege_CanUseContainers, 0);
        player->setPlayerGamePrivilege(Player::ePlayerGamePrivilege_CanUseDoorsAndSwitches, 0);
    }
	else
	{
	    player->setPlayerGamePrivilege(Player::ePlayerGamePrivilege_CannotMine, 0);
        player->setPlayerGamePrivilege(Player::ePlayerGamePrivilege_CannotBuild, 0);
        player->setPlayerGamePrivilege(Player::ePlayerGamePrivilege_CanUseContainers, 1);
        player->setPlayerGamePrivilege(Player::ePlayerGamePrivilege_CanUseDoorsAndSwitches, 1);
        player->removeEffect(MobEffect::nightVision->id);
        player->noPhysics = false;
        player->setInvisible(false);
		abilities->mayfly = false;
		abilities->instabuild = false;
		abilities->invulnerable = false;
		abilities->flying = false;
		abilities->spectatorMode = false;
	}
	abilities->mayBuild = !isAdventureRestricted() && !isSpectator();
}

bool GameType::isAdventureRestricted()
{
	return this == ADVENTURE;
}

bool GameType::isCreative()
{
	return this == CREATIVE;
}
bool GameType::isSpectator()
{
	return this == SPECTATOR;
}

bool GameType::isSurvival()
{
	return this == SURVIVAL || this == ADVENTURE;
}

GameType *GameType::byId(int id)
{
	if(id == NOT_SET->id) return NOT_SET;
	else if(id == SURVIVAL->id) return SURVIVAL;
	else if(id == CREATIVE->id) return CREATIVE;
	else if(id == ADVENTURE->id) return ADVENTURE;
	else if(id == SPECTATOR->id) return SPECTATOR;

	return SURVIVAL;
}

GameType *GameType::byName(const wstring &name)
{
	if(name.compare(NOT_SET->name) == 0) return NOT_SET;
	else if(name.compare(SURVIVAL->name) == 0) return SURVIVAL;
	else if(name.compare(CREATIVE->name) == 0) return CREATIVE;
	else if(name.compare(ADVENTURE->name) == 0) return ADVENTURE;
	else if(name.compare(SPECTATOR->name) == 0) return SPECTATOR;


	return SURVIVAL;
}

void LevelSettings::_init(int64_t seed, GameType *gameType, bool generateMapFeatures, bool hardcore, bool newSeaLevel, LevelType *levelType, int xzSize, int hellScale)
{
	this->seed = seed;
	this->gameType = gameType;
	this->hardcore = hardcore;
	this->generateMapFeatures = generateMapFeatures;
	this->newSeaLevel = newSeaLevel;
	this->levelType = levelType;
	this->allowCommands = false;
	this->startingBonusItems = false;
	levelTypeOptions = L"";
	m_xzSize = xzSize;
	m_hellScale = hellScale;
}

LevelSettings::LevelSettings(int64_t seed, GameType *gameType, bool generateMapFeatures, bool hardcore, bool newSeaLevel, LevelType *levelType, int xzSize, int hellScale) :
	seed(seed),
	gameType(gameType),
	hardcore(hardcore),
	generateMapFeatures(generateMapFeatures),
	newSeaLevel(newSeaLevel),
	levelType(levelType),
	startingBonusItems(false)
{
	_init(seed, gameType, generateMapFeatures, hardcore, newSeaLevel, levelType, xzSize, hellScale);
}

LevelSettings::LevelSettings(LevelData *levelData)
{
	_init(levelData->getSeed(), levelData->getGameType(), levelData->isGenerateMapFeatures(), levelData->isHardcore(), levelData->useNewSeaLevel(), levelData->getGenerator(), levelData->getXZSize(), levelData->getHellScale() );
}

LevelSettings *LevelSettings::enableStartingBonusItems()
{
	startingBonusItems = true;
	return this;
}

LevelSettings *LevelSettings::enableSinglePlayerCommands()
{
	allowCommands = true;
	return this;
}

LevelSettings *LevelSettings::setLevelTypeOptions(const wstring &options)
{
	levelTypeOptions = options;
	return this;
}

bool LevelSettings::hasStartingBonusItems()
{
	return startingBonusItems;
}

int64_t LevelSettings::getSeed()
{
	return seed;
}

GameType *LevelSettings::getGameType()
{
	return gameType;
}

bool LevelSettings::isHardcore()
{
	return hardcore;
}

LevelType *LevelSettings::getLevelType()
{
	return levelType;
}

bool LevelSettings::getAllowCommands()
{
	return allowCommands;
}

bool LevelSettings::isGenerateMapFeatures()
{
	return generateMapFeatures;
}

GameType *LevelSettings::validateGameType(int gameType)
{
	return GameType::byId(gameType);
}

bool LevelSettings::useNewSeaLevel()
{
	return newSeaLevel;
}

// 4J Added
int LevelSettings::getXZSize()
{
	return m_xzSize;
}

int LevelSettings::getHellScale()
{
	return m_hellScale;
}

wstring LevelSettings::getLevelTypeOptions()
{
	return levelTypeOptions;
}