LegacyConsole/DrPerkyLegit-LCEServerTest
2
0
Fork 0
mirror of https://github.com/DrPerkyLegit/LCEServerTest.git synced 2026-05-24 04:24:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

removed git history

Browse Source
This commit is contained in:
DrPerkyLegit
2026-05-16 11:30:28 -04:00
commit afdf1d188c
2384 changed files with 416681 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

178
Minecraft.Client/Common/GameRules/ConsoleGenerateStructure.cpp Normal file
View File

@@ -0,0 +1,178 @@
#include "stdafx.h"
#include "ConsoleGenerateStructure.h"
#include "ConsoleGameRules.h"
#include "..\..\..\Minecraft.World\net.minecraft.world.level.h"
#include "..\..\..\Minecraft.World\net.minecraft.world.level.dimension.h"
#include "..\..\..\Minecraft.World\net.minecraft.world.level.levelgen.structure.h"
#include "..\..\..\Minecraft.World\StringHelpers.h"
#include "..\..\..\Minecraft.World\net.minecraft.h"
ConsoleGenerateStructure::ConsoleGenerateStructure() : StructurePiece(0)
{
m_x = m_y = m_z = 0;
boundingBox = nullptr;
orientation = Direction::NORTH;
m_dimension = 0;
}
void ConsoleGenerateStructure::getChildren(vector<GameRuleDefinition *> *children)
{
GameRuleDefinition::getChildren(children);
for ( auto& action : m_actions )
children->push_back( action );
}
GameRuleDefinition *ConsoleGenerateStructure::addChild(ConsoleGameRules::EGameRuleType ruleType)
{
GameRuleDefinition *rule = nullptr;
if(ruleType == ConsoleGameRules::eGameRuleType_GenerateBox)
{
rule = new XboxStructureActionGenerateBox();
m_actions.push_back(static_cast<XboxStructureActionGenerateBox *>(rule));
}
else if(ruleType == ConsoleGameRules::eGameRuleType_PlaceBlock)
{
rule = new XboxStructureActionPlaceBlock();
m_actions.push_back(static_cast<XboxStructureActionPlaceBlock *>(rule));
}
else if(ruleType == ConsoleGameRules::eGameRuleType_PlaceContainer)
{
rule = new XboxStructureActionPlaceContainer();
m_actions.push_back(static_cast<XboxStructureActionPlaceContainer *>(rule));
}
else if(ruleType == ConsoleGameRules::eGameRuleType_PlaceSpawner)
{
rule = new XboxStructureActionPlaceSpawner();
m_actions.push_back(static_cast<XboxStructureActionPlaceSpawner *>(rule));
}
else
{
#ifndef _CONTENT_PACKAGE
wprintf(L"ConsoleGenerateStructure: Attempted to add invalid child rule - %d\n", ruleType );
#endif
}
return rule;
}
void ConsoleGenerateStructure::writeAttributes(DataOutputStream *dos, UINT numAttrs)
{
GameRuleDefinition::writeAttributes(dos, numAttrs + 5);
ConsoleGameRules::write(dos, ConsoleGameRules::eGameRuleAttr_x);
dos->writeUTF(std::to_wstring(m_x));
ConsoleGameRules::write(dos, ConsoleGameRules::eGameRuleAttr_y);
dos->writeUTF(std::to_wstring(m_y));
ConsoleGameRules::write(dos, ConsoleGameRules::eGameRuleAttr_z);
dos->writeUTF(std::to_wstring(m_z));
ConsoleGameRules::write(dos, ConsoleGameRules::eGameRuleAttr_orientation);
dos->writeUTF(std::to_wstring(orientation));
ConsoleGameRules::write(dos, ConsoleGameRules::eGameRuleAttr_dimension);
dos->writeUTF(std::to_wstring(m_dimension));
}
void ConsoleGenerateStructure::addAttribute(const wstring &attributeName, const wstring &attributeValue)
{
if(attributeName.compare(L"x") == 0)
{
int value = _fromString<int>(attributeValue);
m_x = value;
app.DebugPrintf("ConsoleGenerateStructure: Adding parameter x=%d\n",m_x);
}
else if(attributeName.compare(L"y") == 0)
{
int value = _fromString<int>(attributeValue);
m_y = value;
app.DebugPrintf("ConsoleGenerateStructure: Adding parameter y=%d\n",m_y);
}
else if(attributeName.compare(L"z") == 0)
{
int value = _fromString<int>(attributeValue);
m_z = value;
app.DebugPrintf("ConsoleGenerateStructure: Adding parameter z=%d\n",m_z);
}
else if(attributeName.compare(L"orientation") == 0)
{
int value = _fromString<int>(attributeValue);
orientation = value;
app.DebugPrintf("ConsoleGenerateStructure: Adding parameter orientation=%d\n",orientation);
}
else if(attributeName.compare(L"dim") == 0)
{
m_dimension = _fromString<int>(attributeValue);
if(m_dimension > 1 || m_dimension < -1) m_dimension = 0;
app.DebugPrintf("ApplySchematicRuleDefinition: Adding parameter dimension=%d\n",m_dimension);
}
else
{
GameRuleDefinition::addAttribute(attributeName, attributeValue);
}
}
BoundingBox* ConsoleGenerateStructure::getBoundingBox()
{
if(boundingBox == nullptr)
{
// Find the max bounds
int maxX, maxY, maxZ;
maxX = maxY = maxZ = 1;
for( ConsoleGenerateStructureAction *action : m_actions )
{
maxX = std::max<int>(maxX,action->getEndX());
maxY = std::max<int>(maxY,action->getEndY());
maxZ = std::max<int>(maxZ,action->getEndZ());
}
boundingBox = new BoundingBox(m_x, m_y, m_z, m_x + maxX, m_y + maxY, m_z + maxZ);
}
return boundingBox;
}
bool ConsoleGenerateStructure::postProcess(Level *level, Random *random, BoundingBox *chunkBB)
{
if(level->dimension->id != m_dimension) return false;
for( ConsoleGenerateStructureAction *action : m_actions )
{
switch(action->getActionType())
{
case ConsoleGameRules::eGameRuleType_GenerateBox:
{
XboxStructureActionGenerateBox *genBox = static_cast<XboxStructureActionGenerateBox *>(action);
genBox->generateBoxInLevel(this,level,chunkBB);
}
break;
case ConsoleGameRules::eGameRuleType_PlaceBlock:
{
XboxStructureActionPlaceBlock *pPlaceBlock = static_cast<XboxStructureActionPlaceBlock *>(action);
pPlaceBlock->placeBlockInLevel(this,level,chunkBB);
}
break;
case ConsoleGameRules::eGameRuleType_PlaceContainer:
{
XboxStructureActionPlaceContainer *pPlaceContainer = static_cast<XboxStructureActionPlaceContainer *>(action);
pPlaceContainer->placeContainerInLevel(this,level,chunkBB);
}
break;
case ConsoleGameRules::eGameRuleType_PlaceSpawner:
{
XboxStructureActionPlaceSpawner *pPlaceSpawner = static_cast<XboxStructureActionPlaceSpawner *>(action);
pPlaceSpawner->placeSpawnerInLevel(this,level,chunkBB);
}
break;
};
}
return false;
}
bool ConsoleGenerateStructure::checkIntersects(int x0, int y0, int z0, int x1, int y1, int z1)
{
return getBoundingBox()->intersects(x0,y0,z0,x1,y1,z1);
}
int ConsoleGenerateStructure::getMinY()
{
return getBoundingBox()->y0;
}