backups/4jcraft
2
0
Fork 0
mirror of https://github.com/4jcraft/4jcraft.git synced 2026-08-08 19:12:25 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

fix: unglob std::{min, max}, manual stuff

Browse source
This commit is contained in:
Tropical 2026-03-06 20:47:11 -06:00
parent 967ffbb2a6
commit 04ff82ba70
54 changed files with 126 additions and 126 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Minecraft.Client/Build/Common/App_structs.h
View file

@ -224,4 +224,4 @@ typedef struct _TMSPPRequest
} }
TMSPPRequest; TMSPPRequest;
typedef pair<EUIScene, HXUIOBJ> SceneStackPair; typedef std::pair<EUIScene, HXUIOBJ> SceneStackPair;

4
Minecraft.Client/Build/Common/DLC/DLCManager.h
View file

@ -89,8 +89,8 @@ public:
DWORD checkForCorruptDLCAndAlert(bool showMessage = true); DWORD checkForCorruptDLCAndAlert(bool showMessage = true);
bool readDLCDataFile(DWORD &dwFilesProcessed, const std::wstring &path, DLCPack *pack, bool fromArchive = false); bool readDLCDataFile(DWORD &dwFilesProcessed, const std::wstring &path, DLCPack *pack, bool fromArchive = false);
bool readDLCDataFile(DWORD &dwFilesProcessed, const string &path, DLCPack *pack, bool fromArchive = false); bool readDLCDataFile(DWORD &dwFilesProcessed, const std::string &path, DLCPack *pack, bool fromArchive = false);
DWORD retrievePackIDFromDLCDataFile(const string &path, DLCPack *pack); DWORD retrievePackIDFromDLCDataFile(const std::string &path, DLCPack *pack);
private: private:
bool processDLCDataFile(DWORD &dwFilesProcessed, PBYTE pbData, DWORD dwLength, DLCPack *pack); bool processDLCDataFile(DWORD &dwFilesProcessed, PBYTE pbData, DWORD dwLength, DLCPack *pack);

2
Minecraft.Client/Level/ServerLevel.h
View file

@ -18,7 +18,7 @@ private:
PlayerChunkMap *chunkMap; PlayerChunkMap *chunkMap;
CRITICAL_SECTION m_tickNextTickCS; // 4J added CRITICAL_SECTION m_tickNextTickCS; // 4J added
set<TickNextTickData, TickNextTickDataKeyCompare> tickNextTickList; // 4J Was TreeSet std::set<TickNextTickData, TickNextTickDataKeyCompare> tickNextTickList; // 4J Was TreeSet
std::unordered_set<TickNextTickData, TickNextTickDataKeyHash, TickNextTickDataKeyEq> tickNextTickSet; // 4J Was HashSet std::unordered_set<TickNextTickData, TickNextTickDataKeyHash, TickNextTickDataKeyEq> tickNextTickSet; // 4J Was HashSet
std::vector<Pos *> m_queuedSendTileUpdates; // 4J added std::vector<Pos *> m_queuedSendTileUpdates; // 4J added

8
Minecraft.Client/Platform/Linux/Stubs/DirectXMath/DirectXCollision.inl
View file

@ -1767,9 +1767,9 @@ inline bool XM_CALLCONV BoundingBox::Intersects(FXMVECTOR Origin, FXMVECTOR Dire
// t_min.x = maximum( t_min.x, t_min.y, t_min.z ); // t_min.x = maximum( t_min.x, t_min.y, t_min.z );
// t_max.x = minimum( t_max.x, t_max.y, t_max.z ); // t_max.x = minimum( t_max.x, t_max.y, t_max.z );
t_min = XMVectorMax(t_min, XMVectorSplatY(t_min)); // x = max(x,y) t_min = XMVectorMax(t_min, XMVectorSplatY(t_min)); // x = max(x,y)
t_min = XMVectorMax(t_min, XMVectorSplatZ(t_min)); // x = max(max(x,y),z) t_min = XMVectorMax(t_min, XMVectorSplatZ(t_min)); // x = max(std::max(x,y),z)
t_max = XMVectorMin(t_max, XMVectorSplatY(t_max)); // x = min(x,y) t_max = XMVectorMin(t_max, XMVectorSplatY(t_max)); // x = min(x,y)
t_max = XMVectorMin(t_max, XMVectorSplatZ(t_max)); // x = min(min(x,y),z) t_max = XMVectorMin(t_max, XMVectorSplatZ(t_max)); // x = min(std::min(x,y),z)
// if ( t_min > t_max ) return false; // if ( t_min > t_max ) return false;
XMVECTOR NoIntersection = XMVectorGreater(XMVectorSplatX(t_min), XMVectorSplatX(t_max)); XMVECTOR NoIntersection = XMVectorGreater(XMVectorSplatX(t_min), XMVectorSplatX(t_max));
@ -2596,9 +2596,9 @@ inline bool XM_CALLCONV BoundingOrientedBox::Intersects(FXMVECTOR Origin, FXMVEC
// t_min.x = maximum( t_min.x, t_min.y, t_min.z ); // t_min.x = maximum( t_min.x, t_min.y, t_min.z );
// t_max.x = minimum( t_max.x, t_max.y, t_max.z ); // t_max.x = minimum( t_max.x, t_max.y, t_max.z );
t_min = XMVectorMax(t_min, XMVectorSplatY(t_min)); // x = max(x,y) t_min = XMVectorMax(t_min, XMVectorSplatY(t_min)); // x = max(x,y)
t_min = XMVectorMax(t_min, XMVectorSplatZ(t_min)); // x = max(max(x,y),z) t_min = XMVectorMax(t_min, XMVectorSplatZ(t_min)); // x = max(std::max(x,y),z)
t_max = XMVectorMin(t_max, XMVectorSplatY(t_max)); // x = min(x,y) t_max = XMVectorMin(t_max, XMVectorSplatY(t_max)); // x = min(x,y)
t_max = XMVectorMin(t_max, XMVectorSplatZ(t_max)); // x = min(min(x,y),z) t_max = XMVectorMin(t_max, XMVectorSplatZ(t_max)); // x = min(std::min(x,y),z)
// if ( t_min > t_max ) return false; // if ( t_min > t_max ) return false;
XMVECTOR NoIntersection = XMVectorGreater(XMVectorSplatX(t_min), XMVectorSplatX(t_max)); XMVECTOR NoIntersection = XMVectorGreater(XMVectorSplatX(t_min), XMVectorSplatX(t_max));

8
Minecraft.Client/Platform/PS3/PS3Extras/DirectX/DirectXCollision.inl
View file

@ -1761,9 +1761,9 @@ inline bool BoundingBox::Intersects( FXMVECTOR Origin, FXMVECTOR Direction, floa
// t_min.x = maximum( t_min.x, t_min.y, t_min.z ); // t_min.x = maximum( t_min.x, t_min.y, t_min.z );
// t_max.x = minimum( t_max.x, t_max.y, t_max.z ); // t_max.x = minimum( t_max.x, t_max.y, t_max.z );
t_min = XMVectorMax( t_min, XMVectorSplatY( t_min ) ); // x = max(x,y) t_min = XMVectorMax( t_min, XMVectorSplatY( t_min ) ); // x = max(x,y)
t_min = XMVectorMax( t_min, XMVectorSplatZ( t_min ) ); // x = max(max(x,y),z) t_min = XMVectorMax( t_min, XMVectorSplatZ( t_min ) ); // x = max(std::max(x,y),z)
t_max = XMVectorMin( t_max, XMVectorSplatY( t_max ) ); // x = min(x,y) t_max = XMVectorMin( t_max, XMVectorSplatY( t_max ) ); // x = min(x,y)
t_max = XMVectorMin( t_max, XMVectorSplatZ( t_max ) ); // x = min(min(x,y),z) t_max = XMVectorMin( t_max, XMVectorSplatZ( t_max ) ); // x = min(std::min(x,y),z)
// if ( t_min > t_max ) return false; // if ( t_min > t_max ) return false;
XMVECTOR NoIntersection = XMVectorGreater( XMVectorSplatX( t_min ), XMVectorSplatX( t_max ) ); XMVECTOR NoIntersection = XMVectorGreater( XMVectorSplatX( t_min ), XMVectorSplatX( t_max ) );
@ -2589,9 +2589,9 @@ inline bool BoundingOrientedBox::Intersects( FXMVECTOR Origin, FXMVECTOR Directi
// t_min.x = maximum( t_min.x, t_min.y, t_min.z ); // t_min.x = maximum( t_min.x, t_min.y, t_min.z );
// t_max.x = minimum( t_max.x, t_max.y, t_max.z ); // t_max.x = minimum( t_max.x, t_max.y, t_max.z );
t_min = XMVectorMax( t_min, XMVectorSplatY( t_min ) ); // x = max(x,y) t_min = XMVectorMax( t_min, XMVectorSplatY( t_min ) ); // x = max(x,y)
t_min = XMVectorMax( t_min, XMVectorSplatZ( t_min ) ); // x = max(max(x,y),z) t_min = XMVectorMax( t_min, XMVectorSplatZ( t_min ) ); // x = max(std::max(x,y),z)
t_max = XMVectorMin( t_max, XMVectorSplatY( t_max ) ); // x = min(x,y) t_max = XMVectorMin( t_max, XMVectorSplatY( t_max ) ); // x = min(x,y)
t_max = XMVectorMin( t_max, XMVectorSplatZ( t_max ) ); // x = min(min(x,y),z) t_max = XMVectorMin( t_max, XMVectorSplatZ( t_max ) ); // x = min(std::min(x,y),z)
// if ( t_min > t_max ) return false; // if ( t_min > t_max ) return false;
XMVECTOR NoIntersection = XMVectorGreater( XMVectorSplatX( t_min ), XMVectorSplatX( t_max ) ); XMVECTOR NoIntersection = XMVectorGreater( XMVectorSplatX( t_min ), XMVectorSplatX( t_max ) );

2
Minecraft.Client/Platform/Xbox/Network/PlatformNetworkManagerXbox.cpp
View file

@ -1298,7 +1298,7 @@ void CPlatformNetworkManagerXbox::SearchForGames()
return; return;
} }
DWORD sessionIDCount = min( XSESSION_SEARCH_MAX_IDS, friendsSessions[m_lastSearchPad].size() ); DWORD sessionIDCount = std::min( XSESSION_SEARCH_MAX_IDS, friendsSessions[m_lastSearchPad].size() );
SessionID *sessionIDList = new SessionID[sessionIDCount]; SessionID *sessionIDList = new SessionID[sessionIDCount];
for(DWORD i = 0; i < sessionIDCount; ++i) for(DWORD i = 0; i < sessionIDCount; ++i)

2
Minecraft.Client/Player/ServerPlayer.cpp
View file

@ -253,7 +253,7 @@ void ServerPlayer::flushEntitiesToRemove()
if (!entitiesToRemove.empty()) if (!entitiesToRemove.empty())
{ {
int sz = entitiesToRemove.size(); int sz = entitiesToRemove.size();
int amount = min(sz, RemoveEntitiesPacket::MAX_PER_PACKET); int amount = std::min(sz, RemoveEntitiesPacket::MAX_PER_PACKET);
intArray ids(amount); intArray ids(amount);
int pos = 0; int pos = 0;

4
Minecraft.Client/Rendering/GameRenderer.cpp
View file

@ -983,7 +983,7 @@ float GameRenderer::getNightVisionScale(std::shared_ptr<Player> player, float a)
} }
else else
{ {
float flash = max(0.0f, (float)duration - a); float flash = std::max(0.0f, (float)duration - a);
return .7f + Mth::sin(flash * PI * .05f) * .3f; // was: .7 + sin(flash*pi*0.2) * .3 return .7f + Mth::sin(flash * PI * .05f) * .3f; // was: .7 + sin(flash*pi*0.2) * .3
} }
} }
@ -2144,7 +2144,7 @@ void GameRenderer::setupFog(int i, float alpha)
if (mc->level->dimension->isFoggyAt((int) player->x, (int) player->z)) if (mc->level->dimension->isFoggyAt((int) player->x, (int) player->z))
{ {
glFogf(GL_FOG_START, distance * 0.05f); glFogf(GL_FOG_START, distance * 0.05f);
glFogf(GL_FOG_END, min(distance, 16 * 16 * .75f) * .5f); glFogf(GL_FOG_END, std::min(distance, 16 * 16 * .75f) * .5f);
} }
} }

6
Minecraft.Client/Rendering/Tesselator.cpp
View file

@ -1022,9 +1022,9 @@ uint32_t _ConvertF32toX11Y11Z10N(float x, float y, float z)
if (z<-1.0f || z>1.0f) { printf("Value (%5.3f) should be in range [-1..1]. Conversion will clamp to X11Y11Z10N.\n", z); } if (z<-1.0f || z>1.0f) { printf("Value (%5.3f) should be in range [-1..1]. Conversion will clamp to X11Y11Z10N.\n", z); }
#endif #endif
const uint32_t uX = ((int32_t(max(min(((x)*2047.f - 1.f)*0.5f, 1023.f), -1024.f)) & (X11Y11Z10N_X_MASK >> X11Y11Z10N_X_SHIFT)) << X11Y11Z10N_X_SHIFT); const uint32_t uX = ((int32_t(std::max(std::min(((x)*2047.f - 1.f)*0.5f, 1023.f), -1024.f)) & (X11Y11Z10N_X_MASK >> X11Y11Z10N_X_SHIFT)) << X11Y11Z10N_X_SHIFT);
const uint32_t uY = ((int32_t(max(min(((y)*2047.f - 1.f)*0.5f, 1023.f), -1024.f)) & (X11Y11Z10N_Y_MASK >> X11Y11Z10N_Y_SHIFT)) << X11Y11Z10N_Y_SHIFT); const uint32_t uY = ((int32_t(std::max(std::min(((y)*2047.f - 1.f)*0.5f, 1023.f), -1024.f)) & (X11Y11Z10N_Y_MASK >> X11Y11Z10N_Y_SHIFT)) << X11Y11Z10N_Y_SHIFT);
const uint32_t uZ = ((int32_t(max(min(((z)*1023.f - 1.f)*0.5f, 511.f), -512.f )) & (X11Y11Z10N_Z_MASK >> X11Y11Z10N_Z_SHIFT)) << X11Y11Z10N_Z_SHIFT); const uint32_t uZ = ((int32_t(std::max(std::min(((z)*1023.f - 1.f)*0.5f, 511.f), -512.f )) & (X11Y11Z10N_Z_MASK >> X11Y11Z10N_Z_SHIFT)) << X11Y11Z10N_Z_SHIFT);
const uint32_t xyz = uX | uY | uZ; const uint32_t xyz = uX | uY | uZ;
return xyz; return xyz;
} }

4
Minecraft.Client/Textures/Stitching/StitchSlot.cpp
View file

@ -76,8 +76,8 @@ bool StitchSlot::add(TextureHolder *textureHolder)
// (In the case of this ASCII drawing, it's the 'right hand side' that should win) // (In the case of this ASCII drawing, it's the 'right hand side' that should win)
// The 'fattest' area should be used (or when tied, the right hand one) // The 'fattest' area should be used (or when tied, the right hand one)
int right = max(height, spareWidth); int right = std::max(height, spareWidth);
int bottom = max(width, spareHeight); int bottom = std::max(width, spareHeight);
if (right >= bottom) if (right >= bottom)
{ {
subSlots->push_back(new StitchSlot(originX, originY + textureHeight, textureWidth, spareHeight)); subSlots->push_back(new StitchSlot(originX, originY + textureHeight, textureWidth, spareHeight));

4
Minecraft.Client/Textures/Stitching/Stitcher.cpp
View file

@ -154,7 +154,7 @@ bool Stitcher::addToStorage(TextureHolder *textureHolder)
*/ */
bool Stitcher::expand(TextureHolder *textureHolder) bool Stitcher::expand(TextureHolder *textureHolder)
{ {
int minDistance = min(textureHolder->getHeight(), textureHolder->getWidth()); int minDistance = std::min(textureHolder->getHeight(), textureHolder->getWidth());
bool firstAddition = storageX == 0 && storageY == 0; bool firstAddition = storageX == 0 && storageY == 0;
// It couldn't fit, decide which direction to grow to // It couldn't fit, decide which direction to grow to
@ -175,7 +175,7 @@ bool Stitcher::expand(TextureHolder *textureHolder)
} }
// Even if the smallest side fits the larger might not >.> // Even if the smallest side fits the larger might not >.>
int maxDistance = max(textureHolder->getHeight(), textureHolder->getWidth()); int maxDistance = std::max(textureHolder->getHeight(), textureHolder->getWidth());
// TODO: This seems wrong ... // TODO: This seems wrong ...
if (firstAddition && !xCanGrow && !(smallestEncompassingPowerOfTwo(storageY + maxDistance) <= maxHeight)) if (firstAddition && !xCanGrow && !(smallestEncompassingPowerOfTwo(storageY + maxDistance) <= maxHeight))
{ {

2
Minecraft.Client/Textures/TextureHolder.cpp
View file

@ -52,7 +52,7 @@ void TextureHolder::setForcedScale(int targetSize)
return; return;
} }
scale = (float) targetSize / min(width, height); scale = (float) targetSize / std::min(width, height);
} }
//@Override //@Override

8
Minecraft.Client/UI/Rect2i.cpp
View file

@ -21,10 +21,10 @@ Rect2i *Rect2i::intersect(const Rect2i *other)
int x3 = x2 + other->getWidth(); int x3 = x2 + other->getWidth();
int y3 = y2 + other->getHeight(); int y3 = y2 + other->getHeight();
xPos = max(x0, x2); xPos = std::max(x0, x2);
yPos = max(y0, y2); yPos = std::max(y0, y2);
width = max(0, min(x1, x3) - xPos); width = std::max(0, std::min(x1, x3) - xPos);
height = max(0, min(y1, y3) - yPos); height = std::max(0, std::min(y1, y3) - yPos);
return this; return this;
} }

2
Minecraft.World/AI/Control/BodyControl.cpp
View file

@ -39,7 +39,7 @@ void BodyControl::clientTick()
{ {
++timeStill; ++timeStill;
static const int timeStillBeforeTurn = 10; static const int timeStillBeforeTurn = 10;
if (timeStill > timeStillBeforeTurn) clampAngle = max(1 - (timeStill - timeStillBeforeTurn) / 10.f, 0.0f) * maxClampAngle; if (timeStill > timeStillBeforeTurn) clampAngle = std::max(1 - (timeStill - timeStillBeforeTurn) / 10.f, 0.0f) * maxClampAngle;
} }
mob->yBodyRot = clamp(mob->yHeadRot, mob->yBodyRot, clampAngle); mob->yBodyRot = clamp(mob->yHeadRot, mob->yBodyRot, clampAngle);

2
Minecraft.World/AI/Goals/ArrowAttackGoal.cpp
View file

@ -60,7 +60,7 @@ void ArrowAttackGoal::tick()
mob->getLookControl()->setLookAt(tar, 30, 30); mob->getLookControl()->setLookAt(tar, 30, 30);
attackTime = max(attackTime - 1, 0); attackTime = std::max(attackTime - 1, 0);
if (attackTime > 0) return; if (attackTime > 0) return;
if (targetDistSqr > attackRadiusSqr || !canSee) return; if (targetDistSqr > attackRadiusSqr || !canSee) return;
fireAtTarget(); fireAtTarget();

2
Minecraft.World/AI/Goals/ControlledByPlayerGoal.cpp
View file

@ -80,7 +80,7 @@ void ControlledByPlayerGoal::tick()
float sin = Mth::sin(pig->yRot * PI / 180); float sin = Mth::sin(pig->yRot * PI / 180);
float cos = Mth::cos(pig->yRot * PI / 180); float cos = Mth::cos(pig->yRot * PI / 180);
float aproxSpeed = pig->getSpeed() * friction2; float aproxSpeed = pig->getSpeed() * friction2;
float dist = max((int)moveSpeed, 1); float dist = std::max((int)moveSpeed, 1);
dist = aproxSpeed / dist; dist = aproxSpeed / dist;
float normMoveSpeed = moveSpeed * dist; float normMoveSpeed = moveSpeed * dist;
float xa = -(normMoveSpeed * sin); float xa = -(normMoveSpeed * sin);

2
Minecraft.World/AI/Goals/DoorInteractGoal.cpp
View file

@ -23,7 +23,7 @@ bool DoorInteractGoal::canUse()
Path *path = pathNav->getPath(); Path *path = pathNav->getPath();
if (path == NULL || path->isDone() || !pathNav->canOpenDoors()) return false; if (path == NULL || path->isDone() || !pathNav->canOpenDoors()) return false;
for (int i = 0; i < min(path->getIndex() + 2, path->getSize()); ++i) for (int i = 0; i < std::min(path->getIndex() + 2, path->getSize()); ++i)
{ {
Node *n = path->get(i); Node *n = path->get(i);
doorX = n->x; doorX = n->x;

2
Minecraft.World/AI/Goals/EatTileGoal.cpp
View file

@ -51,7 +51,7 @@ int EatTileGoal::getEatAnimationTick()
void EatTileGoal::tick() void EatTileGoal::tick()
{ {
eatAnimationTick = max(0, eatAnimationTick - 1); eatAnimationTick = std::max(0, eatAnimationTick - 1);
if (eatAnimationTick != 4) return; if (eatAnimationTick != 4) return;
int xx = Mth::floor(mob->x); int xx = Mth::floor(mob->x);

2
Minecraft.World/AI/Goals/MeleeAttackGoal.cpp
View file

@ -86,7 +86,7 @@ void MeleeAttackGoal::tick()
} }
} }
attackTime = max(attackTime - 1, 0); attackTime = std::max(attackTime - 1, 0);
double meleeRadiusSqr = (mob->bbWidth * 2) * (mob->bbWidth * 2); double meleeRadiusSqr = (mob->bbWidth * 2) * (mob->bbWidth * 2);
if (mob->distanceToSqr(target.lock()->x, target.lock()->bb->y0, target.lock()->z) > meleeRadiusSqr) return; if (mob->distanceToSqr(target.lock()->x, target.lock()->bb->y0, target.lock()->z) > meleeRadiusSqr) return;

2
Minecraft.World/AI/Goals/OcelotAttackGoal.cpp
View file

@ -52,7 +52,7 @@ void OzelotAttackGoal::tick()
mob->getNavigation()->moveTo(target.lock(), speed); mob->getNavigation()->moveTo(target.lock(), speed);
attackTime = max(attackTime - 1, 0); attackTime = std::max(attackTime - 1, 0);
if (distSqr > meleeRadiusSqr) return; if (distSqr > meleeRadiusSqr) return;
if (attackTime > 0) return; if (attackTime > 0) return;

2
Minecraft.World/Blocks/FallingTile.cpp
View file

@ -159,7 +159,7 @@ void FallingTile::causeFallDamage(float distance)
//for (Entity entity : entities) //for (Entity entity : entities)
for(AUTO_VAR(it,entities->begin()); it != entities->end(); ++it) for(AUTO_VAR(it,entities->begin()); it != entities->end(); ++it)
{ {
(*it)->hurt(source, min(Mth::floor(dmg * fallDamageAmount), fallDamageMax)); (*it)->hurt(source, std::min(Mth::floor(dmg * fallDamageAmount), fallDamageMax));
} }
if (tile == Tile::anvil_Id && random->nextFloat() < 0.05f + (dmg * 0.05)) if (tile == Tile::anvil_Id && random->nextFloat() < 0.05f + (dmg * 0.05))
{ {

2
Minecraft.World/Containers/FurnaceResultSlot.cpp
View file

@ -24,7 +24,7 @@ std::shared_ptr<ItemInstance> FurnaceResultSlot::remove(int c)
{ {
if (hasItem()) if (hasItem())
{ {
removeCount += min(c, getItem()->count); removeCount += std::min(c, getItem()->count);
} }
return Slot::remove(c); return Slot::remove(c);
} }

2
Minecraft.World/Containers/MerchantResultSlot.cpp
View file

@ -20,7 +20,7 @@ std::shared_ptr<ItemInstance> MerchantResultSlot::remove(int c)
{ {
if (hasItem()) if (hasItem())
{ {
removeCount += min(c, getItem()->count); removeCount += std::min(c, getItem()->count);
} }
return Slot::remove(c); return Slot::remove(c);
} }

18
Minecraft.World/Containers/RepairMenu.cpp
View file

@ -82,7 +82,7 @@ void RepairMenu::createResult()
if (result->isDamageableItem() && Item::items[result->id]->isValidRepairItem(input, addition)) if (result->isDamageableItem() && Item::items[result->id]->isValidRepairItem(input, addition))
{ {
int repairAmount = min(result->getDamageValue(), result->getMaxDamage() / 4); int repairAmount = std::min(result->getDamageValue(), result->getMaxDamage() / 4);
if (repairAmount <= 0) if (repairAmount <= 0)
{ {
resultSlots->setItem(0, nullptr); resultSlots->setItem(0, nullptr);
@ -96,9 +96,9 @@ void RepairMenu::createResult()
{ {
int resultDamage = result->getDamageValue() - repairAmount; int resultDamage = result->getDamageValue() - repairAmount;
result->setAuxValue(resultDamage); result->setAuxValue(resultDamage);
price += max(1, repairAmount / 100) + enchantments->size(); price += std::max(1, repairAmount / 100) + enchantments->size();
repairAmount = min(result->getDamageValue(), result->getMaxDamage() / 4); repairAmount = std::min(result->getDamageValue(), result->getMaxDamage() / 4);
count++; count++;
} }
repairItemCountCost = count; repairItemCountCost = count;
@ -124,10 +124,10 @@ void RepairMenu::createResult()
if (resultDamage < result->getAuxValue()) if (resultDamage < result->getAuxValue())
{ {
result->setAuxValue(resultDamage); result->setAuxValue(resultDamage);
price += max(1, additional / 100); price += std::max(1, additional / 100);
if (DEBUG_COST) if (DEBUG_COST)
{ {
app.DebugPrintf("Repairing; price is now %d (went up by %d)\n", price, max(1, additional / 100) ); app.DebugPrintf("Repairing; price is now %d (went up by %d)\n", price, std::max(1, additional / 100) );
} }
} }
} }
@ -141,7 +141,7 @@ void RepairMenu::createResult()
AUTO_VAR(localIt, enchantments->find(id)); AUTO_VAR(localIt, enchantments->find(id));
int current = localIt != enchantments->end() ? localIt->second : 0; int current = localIt != enchantments->end() ? localIt->second : 0;
int level = it->second; int level = it->second;
level = (current == level) ? level += 1 : max(level, current); level = (current == level) ? level += 1 : std::max(level, current);
int extra = level - current; int extra = level - current;
bool compatible = enchantment->canEnchant(input); bool compatible = enchantment->canEnchant(input);
@ -183,7 +183,7 @@ void RepairMenu::createResult()
break; break;
} }
if (usingBook) fee = max(1, fee / 2); if (usingBook) fee = std::max(1, fee / 2);
price += fee * extra; price += fee * extra;
if (DEBUG_COST) if (DEBUG_COST)
@ -244,7 +244,7 @@ void RepairMenu::createResult()
break; break;
} }
if (usingBook) fee = max(1, fee / 2); if (usingBook) fee = std::max(1, fee / 2);
tax += count + level * fee; tax += count + level * fee;
if (DEBUG_COST) if (DEBUG_COST)
@ -253,7 +253,7 @@ void RepairMenu::createResult()
} }
} }
if (usingBook) tax = max(1, tax / 2); if (usingBook) tax = std::max(1, tax / 2);
cost = tax + price; cost = tax + price;
if (price <= 0) if (price <= 0)

2
Minecraft.World/Containers/ResultSlot.cpp
View file

@ -22,7 +22,7 @@ std::shared_ptr<ItemInstance> ResultSlot::remove(int c)
{ {
if (hasItem()) if (hasItem())
{ {
removeCount += min(c, getItem()->count); removeCount += std::min(c, getItem()->count);
} }
return Slot::remove(c); return Slot::remove(c);
} }

4
Minecraft.World/Enchantments/EnchantmentHelper.cpp
View file

@ -288,11 +288,11 @@ int EnchantmentHelper::getEnchantmentCost(Random *random, int slot, int bookcase
int selected = random->nextInt(8) + 1 + (bookcases >> 1) + random->nextInt(bookcases + 1); int selected = random->nextInt(8) + 1 + (bookcases >> 1) + random->nextInt(bookcases + 1);
if (slot == 0) if (slot == 0)
{ {
return max((selected / 3), 1); return std::max((selected / 3), 1);
} }
if (slot == 1) if (slot == 1)
{ {
return max(selected, bookcases * 2); return std::max(selected, bookcases * 2);
} }
return selected; return selected;
} }

6
Minecraft.World/Entities/HangingEntity.cpp
View file

@ -86,7 +86,7 @@ void HangingEntity::setDir(int dir)
float y1 = y + h + ss; float y1 = y + h + ss;
float z0 = z - d - ss; float z0 = z - d - ss;
float z1 = z + d + ss; float z1 = z + d + ss;
bb->set(min(x0,x1), min(y0,y1), min(z0,z1), max(x0,x1), max(y0,y1), max(z0,z1)); bb->set(std::min(x0,x1), std::min(y0,y1), std::min(z0,z1), std::max(x0,x1), std::max(y0,y1), std::max(z0,z1));
} }
float HangingEntity::offs(int w) float HangingEntity::offs(int w)
@ -117,8 +117,8 @@ bool HangingEntity::survives()
} }
else else
{ {
int ws = max(1, getWidth() / 16); int ws = std::max(1, getWidth() / 16);
int hs = max(1, getHeight() / 16); int hs = std::max(1, getHeight() / 16);
int xt = xTile; int xt = xTile;
int yt = yTile; int yt = yTile;

4
Minecraft.World/Entities/ItemEntity.cpp
View file

@ -158,8 +158,8 @@ bool ItemEntity::merge(std::shared_ptr<ItemEntity> target)
if (targetItem->count + myItem->count > targetItem->getMaxStackSize()) return false; if (targetItem->count + myItem->count > targetItem->getMaxStackSize()) return false;
targetItem->count += myItem->count; targetItem->count += myItem->count;
target->throwTime = max(target->throwTime, this->throwTime); target->throwTime = std::max(target->throwTime, this->throwTime);
target->age = min(target->age, this->age); target->age = std::min(target->age, this->age);
target->setItem(targetItem); target->setItem(targetItem);
remove(); remove();

6
Minecraft.World/Entities/Mobs/EnderDragon.cpp
View file

@ -879,7 +879,7 @@ void EnderDragon::findNewTarget()
if(!newTarget && m_currentPath != NULL && m_currentPath->isDone()) if(!newTarget && m_currentPath != NULL && m_currentPath->isDone())
{ {
// Distance is 64, which is the radius of the circle // Distance is 64, which is the radius of the circle
int eggHeight = max(level->seaLevel + 5, level->getTopSolidBlock(PODIUM_X_POS,PODIUM_Z_POS)); //level->getHeightmap(4,4); int eggHeight = std::max(level->seaLevel + 5, level->getTopSolidBlock(PODIUM_X_POS,PODIUM_Z_POS)); //level->getHeightmap(4,4);
playerNearestToEgg = level->getNearestPlayer(PODIUM_X_POS, eggHeight, PODIUM_Z_POS, 64.0); playerNearestToEgg = level->getNearestPlayer(PODIUM_X_POS, eggHeight, PODIUM_Z_POS, 64.0);
double dist = 64.0f; double dist = 64.0f;
if(playerNearestToEgg != NULL) if(playerNearestToEgg != NULL)
@ -950,7 +950,7 @@ void EnderDragon::findNewTarget()
int currentNodeIndex = findClosestNode(); int currentNodeIndex = findClosestNode();
// To get the angle to the player correct when landing, head to a node diametrically opposite the player, then swoop in to 4,4 // To get the angle to the player correct when landing, head to a node diametrically opposite the player, then swoop in to 4,4
int eggHeight = max( level->seaLevel + 5, level->getTopSolidBlock(PODIUM_X_POS,PODIUM_Z_POS) ); //level->getHeightmap(4,4); int eggHeight = std::max( level->seaLevel + 5, level->getTopSolidBlock(PODIUM_X_POS,PODIUM_Z_POS) ); //level->getHeightmap(4,4);
playerNearestToEgg = level->getNearestPlayer(PODIUM_X_POS, eggHeight, PODIUM_Z_POS, 128.0); playerNearestToEgg = level->getNearestPlayer(PODIUM_X_POS, eggHeight, PODIUM_Z_POS, 128.0);
int targetNodeIndex = 0 ; int targetNodeIndex = 0 ;
@ -1568,7 +1568,7 @@ int EnderDragon::findClosestNode()
} }
// Fix for #77202 - TU9: Content: Gameplay: The Ender Dragon sometimes flies through terrain // Fix for #77202 - TU9: Content: Gameplay: The Ender Dragon sometimes flies through terrain
// Add minimum height // Add minimum height
nodeY = max( (level->seaLevel + 10), level->getTopSolidBlock(nodeX, nodeZ) + yAdjustment ); nodeY = std::max( (level->seaLevel + 10), level->getTopSolidBlock(nodeX, nodeZ) + yAdjustment );
app.DebugPrintf("Node %d is at (%d,%d,%d)\n", i, nodeX, nodeY, nodeZ); app.DebugPrintf("Node %d is at (%d,%d,%d)\n", i, nodeX, nodeY, nodeZ);

2
Minecraft.World/Entities/Mobs/Sheep.cpp
View file

@ -86,7 +86,7 @@ void Sheep::newServerAiStep()
void Sheep::aiStep() void Sheep::aiStep()
{ {
if (level->isClientSide) eatAnimationTick = max(0, eatAnimationTick - 1); if (level->isClientSide) eatAnimationTick = std::max(0, eatAnimationTick - 1);
Animal::aiStep(); Animal::aiStep();
} }

2
Minecraft.World/Entities/Mobs/Zombie.cpp
View file

@ -295,7 +295,7 @@ void Zombie::startConverting(int time)
getEntityData()->set(DATA_CONVERTING_ID, (uint8_t) 1); getEntityData()->set(DATA_CONVERTING_ID, (uint8_t) 1);
removeEffect(MobEffect::weakness->id); removeEffect(MobEffect::weakness->id);
addEffect(new MobEffectInstance(MobEffect::damageBoost->id, time, min(level->difficulty - 1, 0))); addEffect(new MobEffectInstance(MobEffect::damageBoost->id, time, std::min(level->difficulty - 1, 0)));
level->broadcastEntityEvent(shared_from_this(), EntityEvent::ZOMBIE_CONVERTING); level->broadcastEntityEvent(shared_from_this(), EntityEvent::ZOMBIE_CONVERTING);
} }

2
Minecraft.World/IO/Files/ConsoleSaveFileOriginal.cpp
View file

@ -60,7 +60,7 @@ ConsoleSaveFileOriginal::ConsoleSaveFileOriginal(const std::wstring &fileName, L
if( forceCleanSave ) if( forceCleanSave )
fileSize = 0; fileSize = 0;
DWORD heapSize = max( fileSize, (DWORD)(1024 * 1024 * 2)); // 4J Stu - Our files are going to be bigger than 2MB so allocate high to start with DWORD heapSize = std::max( fileSize, (DWORD)(1024 * 1024 * 2)); // 4J Stu - Our files are going to be bigger than 2MB so allocate high to start with
// Initially committ enough room to store headSize bytes (using CSF_PAGE_SIZE pages, so rounding up here). We should only ever have one save file at a time, // Initially committ enough room to store headSize bytes (using CSF_PAGE_SIZE pages, so rounding up here). We should only ever have one save file at a time,
// and the pages should be decommitted in the dtor, so pages committed should always be zero at this point. // and the pages should be decommitted in the dtor, so pages committed should always be zero at this point.

2
Minecraft.World/IO/Files/ConsoleSaveFileSplit.cpp
View file

@ -478,7 +478,7 @@ void ConsoleSaveFileSplit::_init(const std::wstring &fileName, LPVOID pvSaveData
regionFiles[regionIndex] = regionFileRef; regionFiles[regionIndex] = regionFileRef;
} }
DWORD heapSize = max( fileSize, (DWORD)(1024 * 1024 * 2)); // 4J Stu - Our files are going to be bigger than 2MB so allocate high to start with DWORD heapSize = std::max( fileSize, (DWORD)(1024 * 1024 * 2)); // 4J Stu - Our files are going to be bigger than 2MB so allocate high to start with
// Initially committ enough room to store headSize bytes (using CSF_PAGE_SIZE pages, so rounding up here). We should only ever have one save file at a time, // Initially committ enough room to store headSize bytes (using CSF_PAGE_SIZE pages, so rounding up here). We should only ever have one save file at a time,
// and the pages should be decommitted in the dtor, so pages committed should always be zero at this point. // and the pages should be decommitted in the dtor, so pages committed should always be zero at this point.

2
Minecraft.World/IO/Files/FileHeader.cpp
View file

@ -30,7 +30,7 @@ FileEntry *FileHeader::AddFile( const std::wstring &name, unsigned int length /*
wchar_t filename[64]; wchar_t filename[64];
memset( &filename, 0, sizeof( wchar_t ) * 64 ); memset( &filename, 0, sizeof( wchar_t ) * 64 );
memcpy( &filename, name.c_str(), min( sizeof( wchar_t ) * 64, sizeof( wchar_t ) * name.length() ) ); memcpy( &filename, name.c_str(), std::min( sizeof( wchar_t ) * 64, sizeof( wchar_t ) * name.length() ) );
// Would a map be more efficient? Our file tables probably won't be very big so better to avoid hashing all the time? // Would a map be more efficient? Our file tables probably won't be very big so better to avoid hashing all the time?
// Does the file exist? // Does the file exist?

4
Minecraft.World/IO/Streams/ByteArrayInputStream.cpp
View file

@ -10,7 +10,7 @@
//offset - the offset in the buffer of the first byte to read. //offset - the offset in the buffer of the first byte to read.
//length - the maximum number of bytes to read from the buffer. //length - the maximum number of bytes to read from the buffer.
ByteArrayInputStream::ByteArrayInputStream(byteArray buf, unsigned int offset, unsigned int length) ByteArrayInputStream::ByteArrayInputStream(byteArray buf, unsigned int offset, unsigned int length)
: pos( offset ), count( min( offset+length, buf.length ) ), mark( offset ) : pos( offset ), count( std::min( offset+length, buf.length ) ), mark( offset )
{ {
this->buf = buf; this->buf = buf;
} }
@ -77,7 +77,7 @@ int ByteArrayInputStream::read(byteArray b, unsigned int offset, unsigned int le
if( pos == count ) if( pos == count )
return -1; return -1;
int k = min( length, count-pos ); int k = std::min( length, count-pos );
XMemCpy( &b[offset], &buf[pos], k ); XMemCpy( &b[offset], &buf[pos], k );
//std::copy( buf->data+pos, buf->data+pos+k, b->data + offset ); // Or this instead? //std::copy( buf->data+pos, buf->data+pos+k, b->data + offset ); // Or this instead?

2
Minecraft.World/IO/Streams/ByteArrayOutputStream.cpp
View file

@ -55,7 +55,7 @@ void ByteArrayOutputStream::write(byteArray b, unsigned int offset, unsigned int
// If we will fill the buffer we need to make it bigger // If we will fill the buffer we need to make it bigger
if( count + length >= buf.length ) if( count + length >= buf.length )
buf.resize( max( count + length + 1, buf.length * 2 ) ); buf.resize( std::max( count + length + 1, buf.length * 2 ) );
XMemCpy( &buf[count], &b[offset], length ); XMemCpy( &buf[count], &b[offset], length );
//std::copy( b->data+offset, b->data+offset+length, buf->data + count ); // Or this instead? //std::copy( b->data+offset, b->data+offset+length, buf->data + count ); // Or this instead?

52
Minecraft.World/Level/LevelChunk.cpp
View file

@ -1696,21 +1696,21 @@ int LevelChunk::getBlocksAndData(byteArray *data, int x0, int y0, int z0, int x1
int compressedHeight = Level::COMPRESSED_CHUNK_SECTION_HEIGHT; int compressedHeight = Level::COMPRESSED_CHUNK_SECTION_HEIGHT;
// 4J - replaced block storage as now using CompressedTileStorage // 4J - replaced block storage as now using CompressedTileStorage
if(y0 < Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += lowerBlocks->getDataRegion( *data, x0, y0, z0, x1, min(compressedHeight, y1), z1, p ); if(y0 < Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += lowerBlocks->getDataRegion( *data, x0, y0, z0, x1, std::min(compressedHeight, y1), z1, p );
if(y1 > Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += upperBlocks->getDataRegion( *data, x0, max(y0-compressedHeight,0), z0, x1, y1-Level::COMPRESSED_CHUNK_SECTION_HEIGHT, z1, p ); if(y1 > Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += upperBlocks->getDataRegion( *data, x0, std::max(y0-compressedHeight,0), z0, x1, y1-Level::COMPRESSED_CHUNK_SECTION_HEIGHT, z1, p );
// 4J - replaced data storage as now using SparseDataStorage // 4J - replaced data storage as now using SparseDataStorage
if(y0 < Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += lowerData->getDataRegion( *data, x0, y0, z0, x1, min(compressedHeight, y1), z1, p ); if(y0 < Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += lowerData->getDataRegion( *data, x0, y0, z0, x1, std::min(compressedHeight, y1), z1, p );
if(y1 > Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += upperData->getDataRegion( *data, x0, max(y0-compressedHeight,0), z0, x1, y1-Level::COMPRESSED_CHUNK_SECTION_HEIGHT, z1, p ); if(y1 > Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += upperData->getDataRegion( *data, x0, std::max(y0-compressedHeight,0), z0, x1, y1-Level::COMPRESSED_CHUNK_SECTION_HEIGHT, z1, p );
if( includeLighting ) if( includeLighting )
{ {
// 4J - replaced block and skylight storage as these now use our SparseLightStorage // 4J - replaced block and skylight storage as these now use our SparseLightStorage
if(y0 < Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += lowerBlockLight->getDataRegion( *data, x0, y0, z0, x1, min(compressedHeight, y1), z1, p ); if(y0 < Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += lowerBlockLight->getDataRegion( *data, x0, y0, z0, x1, std::min(compressedHeight, y1), z1, p );
if(y1 > Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += upperBlockLight->getDataRegion( *data, x0, max(y0-compressedHeight,0), z0, x1, y1-Level::COMPRESSED_CHUNK_SECTION_HEIGHT, z1, p ); if(y1 > Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += upperBlockLight->getDataRegion( *data, x0, std::max(y0-compressedHeight,0), z0, x1, y1-Level::COMPRESSED_CHUNK_SECTION_HEIGHT, z1, p );
if(y0 < Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += lowerSkyLight->getDataRegion( *data, x0, y0, z0, x1, min(compressedHeight, y1), z1, p ); if(y0 < Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += lowerSkyLight->getDataRegion( *data, x0, y0, z0, x1, std::min(compressedHeight, y1), z1, p );
if(y1 > Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += upperSkyLight->getDataRegion( *data, x0, max(y0-compressedHeight,0), z0, x1, y1-Level::COMPRESSED_CHUNK_SECTION_HEIGHT, z1, p ); if(y1 > Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += upperSkyLight->getDataRegion( *data, x0, std::max(y0-compressedHeight,0), z0, x1, y1-Level::COMPRESSED_CHUNK_SECTION_HEIGHT, z1, p );
} }
/* /*
@ -1744,8 +1744,8 @@ bool LevelChunk::testSetBlocksAndData(byteArray data, int x0, int y0, int z0, in
// 4J Stu - Added this because some "min" functions don't let us use our constants :( // 4J Stu - Added this because some "min" functions don't let us use our constants :(
int compressedHeight = Level::COMPRESSED_CHUNK_SECTION_HEIGHT; int compressedHeight = Level::COMPRESSED_CHUNK_SECTION_HEIGHT;
if(y0 < Level::COMPRESSED_CHUNK_SECTION_HEIGHT) changed = lowerBlocks->testSetDataRegion(data, x0, y0, z0, x1, min(compressedHeight, y1), z1, p); if(y0 < Level::COMPRESSED_CHUNK_SECTION_HEIGHT) changed = lowerBlocks->testSetDataRegion(data, x0, y0, z0, x1, std::min(compressedHeight, y1), z1, p);
if(y1 > Level::COMPRESSED_CHUNK_SECTION_HEIGHT) changed = changed || upperBlocks->testSetDataRegion(data, x0, max(y0-compressedHeight,0), z0, x1, y1-Level::COMPRESSED_CHUNK_SECTION_HEIGHT, z1, p); if(y1 > Level::COMPRESSED_CHUNK_SECTION_HEIGHT) changed = changed || upperBlocks->testSetDataRegion(data, x0, std::max(y0-compressedHeight,0), z0, x1, y1-Level::COMPRESSED_CHUNK_SECTION_HEIGHT, z1, p);
return changed; return changed;
} }
@ -1788,8 +1788,8 @@ int LevelChunk::setBlocksAndData(byteArray data, int x0, int y0, int z0, int x1,
int compressedHeight = Level::COMPRESSED_CHUNK_SECTION_HEIGHT; int compressedHeight = Level::COMPRESSED_CHUNK_SECTION_HEIGHT;
// 4J - replaced block storage as now uses CompressedTileStorage // 4J - replaced block storage as now uses CompressedTileStorage
if(y0 < Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += lowerBlocks->setDataRegion( data, x0, y0, z0, x1, min(compressedHeight, y1), z1, p, includeLighting ? NULL : tileUpdatedCallback, this, 0 ); if(y0 < Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += lowerBlocks->setDataRegion( data, x0, y0, z0, x1, std::min(compressedHeight, y1), z1, p, includeLighting ? NULL : tileUpdatedCallback, this, 0 );
if(y1 > Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += upperBlocks->setDataRegion( data, x0, max(y0-compressedHeight,0), z0, x1, y1-Level::COMPRESSED_CHUNK_SECTION_HEIGHT, z1, p, includeLighting ? NULL : tileUpdatedCallback, this, Level::COMPRESSED_CHUNK_SECTION_HEIGHT ); if(y1 > Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += upperBlocks->setDataRegion( data, x0, std::max(y0-compressedHeight,0), z0, x1, y1-Level::COMPRESSED_CHUNK_SECTION_HEIGHT, z1, p, includeLighting ? NULL : tileUpdatedCallback, this, Level::COMPRESSED_CHUNK_SECTION_HEIGHT );
/* /*
for (int x = x0; x < x1; x++) for (int x = x0; x < x1; x++)
for (int z = z0; z < z1; z++) for (int z = z0; z < z1; z++)
@ -1803,17 +1803,17 @@ int LevelChunk::setBlocksAndData(byteArray data, int x0, int y0, int z0, int x1,
recalcHeightmapOnly(); recalcHeightmapOnly();
// 4J - replaced data storage as now uses SparseDataStorage // 4J - replaced data storage as now uses SparseDataStorage
if(y0 < Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += lowerData->setDataRegion( data, x0, y0, z0, x1, min(compressedHeight, y1), z1, p, includeLighting ? NULL : tileUpdatedCallback, this, 0 ); if(y0 < Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += lowerData->setDataRegion( data, x0, y0, z0, x1, std::min(compressedHeight, y1), z1, p, includeLighting ? NULL : tileUpdatedCallback, this, 0 );
if(y1 > Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += upperData->setDataRegion( data, x0, max(y0-compressedHeight,0), z0, x1, y1-Level::COMPRESSED_CHUNK_SECTION_HEIGHT, z1, p, includeLighting ? NULL : tileUpdatedCallback, this, Level::COMPRESSED_CHUNK_SECTION_HEIGHT ); if(y1 > Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += upperData->setDataRegion( data, x0, std::max(y0-compressedHeight,0), z0, x1, y1-Level::COMPRESSED_CHUNK_SECTION_HEIGHT, z1, p, includeLighting ? NULL : tileUpdatedCallback, this, Level::COMPRESSED_CHUNK_SECTION_HEIGHT );
if( includeLighting ) if( includeLighting )
{ {
// 4J - replaced block and skylight storage as these now use our SparseLightStorage // 4J - replaced block and skylight storage as these now use our SparseLightStorage
if(y0 < Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += lowerBlockLight->setDataRegion( data, x0, y0, z0, x1, min(compressedHeight, y1), z1, p ); if(y0 < Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += lowerBlockLight->setDataRegion( data, x0, y0, z0, x1, std::min(compressedHeight, y1), z1, p );
if(y1 > Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += upperBlockLight->setDataRegion( data, x0, max(y0-compressedHeight,0), z0, x1, y1-Level::COMPRESSED_CHUNK_SECTION_HEIGHT, z1, p ); if(y1 > Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += upperBlockLight->setDataRegion( data, x0, std::max(y0-compressedHeight,0), z0, x1, y1-Level::COMPRESSED_CHUNK_SECTION_HEIGHT, z1, p );
if(y0 < Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += lowerSkyLight->setDataRegion( data, x0, y0, z0, x1, min(compressedHeight, y1), z1, p ); if(y0 < Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += lowerSkyLight->setDataRegion( data, x0, y0, z0, x1, std::min(compressedHeight, y1), z1, p );
if(y1 > Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += upperSkyLight->setDataRegion( data, x0, max(y0-compressedHeight,0), z0, x1, y1-Level::COMPRESSED_CHUNK_SECTION_HEIGHT, z1, p ); if(y1 > Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += upperSkyLight->setDataRegion( data, x0, std::max(y0-compressedHeight,0), z0, x1, y1-Level::COMPRESSED_CHUNK_SECTION_HEIGHT, z1, p );
memcpy(biomes.data, &data.data[p],biomes.length); memcpy(biomes.data, &data.data[p],biomes.length);
p += biomes.length; p += biomes.length;
@ -2324,7 +2324,7 @@ byteArray LevelChunk::getReorderedBlocksAndData(int x0, int y0, int z0, int xs,
{ {
int highestNonEmpty = getHighestNonEmptyY(); int highestNonEmpty = getHighestNonEmptyY();
ys = min(highestNonEmpty - y0, ys); ys = std::min(highestNonEmpty - y0, ys);
if(ys < 0 ) ys = 0; if(ys < 0 ) ys = 0;
int x1 = x0 + xs; int x1 = x0 + xs;
@ -2354,15 +2354,15 @@ byteArray LevelChunk::getReorderedBlocksAndData(int x0, int y0, int z0, int xs,
int compressedHeight = Level::COMPRESSED_CHUNK_SECTION_HEIGHT; int compressedHeight = Level::COMPRESSED_CHUNK_SECTION_HEIGHT;
// 4J - replaced data storage as now using SparseDataStorage // 4J - replaced data storage as now using SparseDataStorage
if(y0 < Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += lowerData->getDataRegion( data, x0, y0, z0, x1, min(compressedHeight, y1), z1, p ); if(y0 < Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += lowerData->getDataRegion( data, x0, y0, z0, x1, std::min(compressedHeight, y1), z1, p );
if(y1 > Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += upperData->getDataRegion( data, x0, max(y0-compressedHeight,0), z0, x1, y1-Level::COMPRESSED_CHUNK_SECTION_HEIGHT, z1, p ); if(y1 > Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += upperData->getDataRegion( data, x0, std::max(y0-compressedHeight,0), z0, x1, y1-Level::COMPRESSED_CHUNK_SECTION_HEIGHT, z1, p );
// 4J - replaced block and skylight storage as these now use our SparseLightStorage // 4J - replaced block and skylight storage as these now use our SparseLightStorage
if(y0 < Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += lowerBlockLight->getDataRegion( data, x0, y0, z0, x1, min(compressedHeight, y1), z1, p ); if(y0 < Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += lowerBlockLight->getDataRegion( data, x0, y0, z0, x1, std::min(compressedHeight, y1), z1, p );
if(y1 > Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += upperBlockLight->getDataRegion( data, x0, max(y0-compressedHeight,0), z0, x1, y1-Level::COMPRESSED_CHUNK_SECTION_HEIGHT, z1, p ); if(y1 > Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += upperBlockLight->getDataRegion( data, x0, std::max(y0-compressedHeight,0), z0, x1, y1-Level::COMPRESSED_CHUNK_SECTION_HEIGHT, z1, p );
if(y0 < Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += lowerSkyLight->getDataRegion( data, x0, y0, z0, x1, min(compressedHeight, y1), z1, p ); if(y0 < Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += lowerSkyLight->getDataRegion( data, x0, y0, z0, x1, std::min(compressedHeight, y1), z1, p );
if(y1 > Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += upperSkyLight->getDataRegion( data, x0, max(y0-compressedHeight,0), z0, x1, y1-Level::COMPRESSED_CHUNK_SECTION_HEIGHT, z1, p ); if(y1 > Level::COMPRESSED_CHUNK_SECTION_HEIGHT) p += upperSkyLight->getDataRegion( data, x0, std::max(y0-compressedHeight,0), z0, x1, y1-Level::COMPRESSED_CHUNK_SECTION_HEIGHT, z1, p );
memcpy(&data.data[p],biomes.data,biomes.length); memcpy(&data.data[p],biomes.data,biomes.length);
@ -2402,7 +2402,7 @@ void LevelChunk::reorderBlocksAndDataToXZY(int y0, int xs, int ys, int zs, byteA
unsigned int halfTileCount = tileCount/2; unsigned int halfTileCount = tileCount/2;
int sectionHeight = Level::COMPRESSED_CHUNK_SECTION_HEIGHT; int sectionHeight = Level::COMPRESSED_CHUNK_SECTION_HEIGHT;
int lowerYSpan = min(y1, sectionHeight) - y0; int lowerYSpan = std::min(y1, sectionHeight) - y0;
int upperYSpan = ys - lowerYSpan; int upperYSpan = ys - lowerYSpan;
int upperSlotOffset = xs * zs * lowerYSpan; int upperSlotOffset = xs * zs * lowerYSpan;

16
Minecraft.World/Level/LevelData.cpp
View file

@ -112,11 +112,11 @@ LevelData::LevelData(CompoundTag *tag)
m_xzSize = tag->getInt(L"XZSize"); m_xzSize = tag->getInt(L"XZSize");
m_hellScale = tag->getInt(L"HellScale"); m_hellScale = tag->getInt(L"HellScale");
m_xzSize = min(m_xzSize,LEVEL_MAX_WIDTH); m_xzSize = std::min(m_xzSize,LEVEL_MAX_WIDTH);
m_xzSize = max(m_xzSize,LEVEL_MIN_WIDTH); m_xzSize = std::max(m_xzSize,LEVEL_MIN_WIDTH);
m_hellScale = min(m_hellScale,HELL_LEVEL_MAX_SCALE); m_hellScale = std::min(m_hellScale,HELL_LEVEL_MAX_SCALE);
m_hellScale = max(m_hellScale,HELL_LEVEL_MIN_SCALE); m_hellScale = std::max(m_hellScale,HELL_LEVEL_MIN_SCALE);
int hellXZSize = m_xzSize / m_hellScale; int hellXZSize = m_xzSize / m_hellScale;
while(hellXZSize > HELL_LEVEL_MAX_WIDTH && m_hellScale < HELL_LEVEL_MAX_SCALE) while(hellXZSize > HELL_LEVEL_MAX_WIDTH && m_hellScale < HELL_LEVEL_MAX_SCALE)
@ -180,11 +180,11 @@ LevelData::LevelData(LevelSettings *levelSettings, const std::wstring& levelName
m_xzSize = levelSettings->getXZSize(); m_xzSize = levelSettings->getXZSize();
m_hellScale = levelSettings->getHellScale(); m_hellScale = levelSettings->getHellScale();
m_xzSize = min(m_xzSize,LEVEL_MAX_WIDTH); m_xzSize = std::min(m_xzSize,LEVEL_MAX_WIDTH);
m_xzSize = max(m_xzSize,LEVEL_MIN_WIDTH); m_xzSize = std::max(m_xzSize,LEVEL_MIN_WIDTH);
m_hellScale = min(m_hellScale,HELL_LEVEL_MAX_SCALE); m_hellScale = std::min(m_hellScale,HELL_LEVEL_MAX_SCALE);
m_hellScale = max(m_hellScale,HELL_LEVEL_MIN_SCALE); m_hellScale = std::max(m_hellScale,HELL_LEVEL_MIN_SCALE);
int hellXZSize = m_xzSize / m_hellScale; int hellXZSize = m_xzSize / m_hellScale;
while(hellXZSize > HELL_LEVEL_MAX_WIDTH && m_hellScale < HELL_LEVEL_MAX_SCALE) while(hellXZSize > HELL_LEVEL_MAX_WIDTH && m_hellScale < HELL_LEVEL_MAX_SCALE)

10
Minecraft.World/Player/FoodData.cpp
View file

@ -20,8 +20,8 @@ FoodData::FoodData()
void FoodData::eat(int food, float saturationModifier) void FoodData::eat(int food, float saturationModifier)
{ {
foodLevel = min(food + foodLevel, FoodConstants::MAX_FOOD); foodLevel = std::min(food + foodLevel, FoodConstants::MAX_FOOD);
saturationLevel = min(saturationLevel + (float) food * saturationModifier * 2.0f, (float)foodLevel); saturationLevel = std::min(saturationLevel + (float) food * saturationModifier * 2.0f, (float)foodLevel);
} }
void FoodData::eat(FoodItem *item) void FoodData::eat(FoodItem *item)
@ -42,11 +42,11 @@ void FoodData::tick(std::shared_ptr<Player> player)
if (saturationLevel > 0) if (saturationLevel > 0)
{ {
saturationLevel = max(saturationLevel - 1, 0.0f); saturationLevel = std::max(saturationLevel - 1, 0.0f);
} }
else if (difficulty > Difficulty::PEACEFUL) else if (difficulty > Difficulty::PEACEFUL)
{ {
foodLevel = max(foodLevel - 1, 0); foodLevel = std::max(foodLevel - 1, 0);
} }
} }
@ -130,7 +130,7 @@ bool FoodData::needsFood()
void FoodData::addExhaustion(float amount) void FoodData::addExhaustion(float amount)
{ {
exhaustionLevel = min(exhaustionLevel + amount, FoodConstants::MAX_SATURATION * 2); exhaustionLevel = std::min(exhaustionLevel + amount, FoodConstants::MAX_SATURATION * 2);
} }
float FoodData::getExhaustionLevel() float FoodData::getExhaustionLevel()

6
Minecraft.World/Recipes/ArmorDyeRecipe.cpp
View file

@ -72,7 +72,7 @@ std::shared_ptr<ItemInstance> ArmorDyeRecipe::assembleDyedArmor(std::shared_ptr<
float green = (float) ((color >> 8) & 0xFF) / 0xFF; float green = (float) ((color >> 8) & 0xFF) / 0xFF;
float blue = (float) (color & 0xFF) / 0xFF; float blue = (float) (color & 0xFF) / 0xFF;
intensityTotal += max(red, max(green, blue)) * 0xFF; intensityTotal += std::max(red, std::max(green, blue)) * 0xFF;
colorTotals[0] += red * 0xFF; colorTotals[0] += red * 0xFF;
colorTotals[1] += green * 0xFF; colorTotals[1] += green * 0xFF;
@ -92,7 +92,7 @@ std::shared_ptr<ItemInstance> ArmorDyeRecipe::assembleDyedArmor(std::shared_ptr<
int green = (int) (Sheep::COLOR[tileData][1] * 0xFF); int green = (int) (Sheep::COLOR[tileData][1] * 0xFF);
int blue = (int) (Sheep::COLOR[tileData][2] * 0xFF); int blue = (int) (Sheep::COLOR[tileData][2] * 0xFF);
intensityTotal += max(red, max(green, blue)); intensityTotal += std::max(red, std::max(green, blue));
colorTotals[0] += red; colorTotals[0] += red;
colorTotals[1] += green; colorTotals[1] += green;
@ -113,7 +113,7 @@ std::shared_ptr<ItemInstance> ArmorDyeRecipe::assembleDyedArmor(std::shared_ptr<
int blue = (colorTotals[2] / colourCounts); int blue = (colorTotals[2] / colourCounts);
float averageIntensity = (float) intensityTotal / colourCounts; float averageIntensity = (float) intensityTotal / colourCounts;
float resultIntensity = (float) max(red, max(green, blue)); float resultIntensity = (float) std::max(red, std::max(green, blue));
// System.out.println(averageIntensity + ", " + resultIntensity); // System.out.println(averageIntensity + ", " + resultIntensity);
red = (int) ((float) red * averageIntensity / resultIntensity); red = (int) ((float) red * averageIntensity / resultIntensity);

2
Minecraft.World/Recipes/ArmorRecipes.h
View file

@ -26,7 +26,7 @@ private:
static std::wstring shapes[][4]; static std::wstring shapes[][4];
private: private:
vector <Object *> *map; std::vector <Object *> *map;
public: public:
void addRecipes(Recipes *r); void addRecipes(Recipes *r);

2
Minecraft.World/Recipes/OreRecipes.h
View file

@ -10,7 +10,7 @@ public:
OreRecipies() {_init();} OreRecipies() {_init();}
private: private:
vector <Object *> *map; std::vector <Object *> *map;
public: public:
void addRecipes(Recipes *r); void addRecipes(Recipes *r);

2
Minecraft.World/Recipes/Recipes.cpp
View file

@ -1083,7 +1083,7 @@ void Recipes::addShapelessRecipy(ItemInstance *result,... )
Item *pItem; Item *pItem;
Recipy::_eGroupType group = Recipy::eGroupType_Decoration; Recipy::_eGroupType group = Recipy::eGroupType_Decoration;
wchar_t wchFrom; wchar_t wchFrom;
vector <ItemInstance *> *ingredients = new std::vector<ItemInstance *>(); std::vector <ItemInstance *> *ingredients = new std::vector<ItemInstance *>();
va_start(vl,result); va_start(vl,result);
// 4J-PB - second argument is a list of the types // 4J-PB - second argument is a list of the types

4
Minecraft.World/Recipes/Recipes.h
View file

@ -70,7 +70,7 @@ public:
private: private:
static Recipes *instance; static Recipes *instance;
vector <Recipy *> *recipies; std::vector <Recipy *> *recipies;
public: public:
static void staticCtor(); static void staticCtor();
@ -90,7 +90,7 @@ public:
void addShapelessRecipy(ItemInstance *result,... ); void addShapelessRecipy(ItemInstance *result,... );
std::shared_ptr<ItemInstance> getItemFor(std::shared_ptr<CraftingContainer> craftSlots, Level *level); std::shared_ptr<ItemInstance> getItemFor(std::shared_ptr<CraftingContainer> craftSlots, Level *level);
vector <Recipy *> *getRecipies(); std::vector <Recipy *> *getRecipies();
// 4J-PB - Added all below for new Xbox 'crafting' // 4J-PB - Added all below for new Xbox 'crafting'
std::shared_ptr<ItemInstance> getItemForRecipe(Recipy *r); std::shared_ptr<ItemInstance> getItemForRecipe(Recipy *r);

4
Minecraft.World/Recipes/ShapelessRecipy.cpp
View file

@ -31,7 +31,7 @@ const ItemInstance *ShapelessRecipy::getResultItem()
bool ShapelessRecipy::matches(std::shared_ptr<CraftingContainer> craftSlots, Level *level) bool ShapelessRecipy::matches(std::shared_ptr<CraftingContainer> craftSlots, Level *level)
{ {
vector <ItemInstance *> tempList = *ingredients; std::vector <ItemInstance *> tempList = *ingredients;
for (int y = 0; y < 3; y++) for (int y = 0; y < 3; y++)
{ {
@ -80,7 +80,7 @@ int ShapelessRecipy::size()
// 4J-PB // 4J-PB
bool ShapelessRecipy::requires(int iRecipe) bool ShapelessRecipy::requires(int iRecipe)
{ {
vector <ItemInstance *> *tempList = new std::vector<ItemInstance *>; std::vector <ItemInstance *> *tempList = new std::vector<ItemInstance *>;
*tempList=*ingredients; *tempList=*ingredients;

2
Minecraft.World/Recipes/ToolRecipes.h
View file

@ -17,7 +17,7 @@ public:
private: private:
static std::wstring shapes[][4]; static std::wstring shapes[][4];
vector <Object *> *map; std::vector <Object *> *map;
public: public:
void addRecipes(Recipes *r); void addRecipes(Recipes *r);

2
Minecraft.World/Recipes/WeaponRecipes.h
View file

@ -15,7 +15,7 @@ public:
private: private:
static std::wstring shapes[][4]; static std::wstring shapes[][4];
vector <Object *> *map; std::vector <Object *> *map;
public: public:
void addRecipes(Recipes *r); void addRecipes(Recipes *r);

2
Minecraft.World/WorldGen/Features/BasicTreeFeature.cpp
View file

@ -286,7 +286,7 @@ void BasicTree::limb(int *start, int *end, int material)
int dir = TreeTile::FACING_Y; int dir = TreeTile::FACING_Y;
int xdiff = abs(coordinate[0] - start[0]); int xdiff = abs(coordinate[0] - start[0]);
int zdiff = abs(coordinate[2] - start[2]); int zdiff = abs(coordinate[2] - start[2]);
int maxdiff = max(xdiff, zdiff); int maxdiff = std::max(xdiff, zdiff);
if (maxdiff > 0) if (maxdiff > 0)
{ {

2
Minecraft.World/WorldGen/Features/MineShaftFeature.cpp
View file

@ -11,7 +11,7 @@ bool MineShaftFeature::isFeatureChunk(int x, int z, bool bIsSuperflat)
forcePlacement = levelGenOptions->isFeatureChunk(x,z,eFeature_Mineshaft); forcePlacement = levelGenOptions->isFeatureChunk(x,z,eFeature_Mineshaft);
} }
return forcePlacement || (random->nextInt(100) == 0 && random->nextInt(80) < max(abs(x), abs(z))); return forcePlacement || (random->nextInt(100) == 0 && random->nextInt(80) < std::max(abs(x), abs(z)));
} }
StructureStart *MineShaftFeature::createStructureStart(int x, int z) StructureStart *MineShaftFeature::createStructureStart(int x, int z)

2
Minecraft.World/WorldGen/Sources/HellRandomLevelSource.cpp
View file

@ -228,7 +228,7 @@ void HellRandomLevelSource::buildSurfaces(int xOffs, int zOffs, byteArray blocks
// Place the nether wart on top of the soul sand // Place the nether wart on top of the soul sand
y += 1; y += 1;
int genDepthMinusOne = Level::genDepthMinusOne; // Take into local int for PS4 as min takes a reference to the const int there and then needs the value to exist for the linker int genDepthMinusOne = Level::genDepthMinusOne; // Take into local int for PS4 as min takes a reference to the const int there and then needs the value to exist for the linker
y = min(y, genDepthMinusOne); y = std::min(y, genDepthMinusOne);
runDepth += 1; runDepth += 1;
offs = (z * 16 + x) * Level::genDepth + y; offs = (z * 16 + x) * Level::genDepth + y;
} }

2
Minecraft.World/WorldGen/Structures/MineShaftPieces.cpp
View file

@ -188,7 +188,7 @@ bool MineShaftPieces::MineShaftRoom::postProcess(Level *level, Random *random, B
generateBox(level, chunkBB, boundingBox->x0, boundingBox->y0, boundingBox->z0, boundingBox->x1, boundingBox->y0, boundingBox->z1, Tile::dirt_Id, 0, true); generateBox(level, chunkBB, boundingBox->x0, boundingBox->y0, boundingBox->z0, boundingBox->x1, boundingBox->y0, boundingBox->z1, Tile::dirt_Id, 0, true);
// room air // room air
generateBox(level, chunkBB, boundingBox->x0, boundingBox->y0 + 1, boundingBox->z0, boundingBox->x1, min(boundingBox->y0 + 3, boundingBox->y1), boundingBox->z1, 0, 0, false); generateBox(level, chunkBB, boundingBox->x0, boundingBox->y0 + 1, boundingBox->z0, boundingBox->x1, std::min(boundingBox->y0 + 3, boundingBox->y1), boundingBox->z1, 0, 0, false);
for(AUTO_VAR(it, childEntranceBoxes.begin()); it != childEntranceBoxes.end(); ++it) for(AUTO_VAR(it, childEntranceBoxes.begin()); it != childEntranceBoxes.end(); ++it)
{ {
BoundingBox *entranceBox = *it; BoundingBox *entranceBox = *it;

4
Minecraft.World/WorldGen/Structures/NetherBridgePieces.cpp
View file

@ -1333,8 +1333,8 @@ bool NetherBridgePieces::CastleCorridorStairsPiece::postProcess(Level *level, Ra
int stairsData = getOrientationData(Tile::stairs_netherBricks_Id, 2); int stairsData = getOrientationData(Tile::stairs_netherBricks_Id, 2);
for (int step = 0; step <= 9; step++) for (int step = 0; step <= 9; step++)
{ {
int floor = max(1, 7 - step); int floor = std::max(1, 7 - step);
int roof = min(max(floor + 5, 14 - step), 13); int roof = std::min(std::max(floor + 5, 14 - step), 13);
int z = step; int z = step;
// floor // floor

2
Minecraft.World/WorldGen/Structures/ScatteredFeaturePieces.cpp
View file

@ -43,7 +43,7 @@ bool ScatteredFeaturePieces::ScatteredFeaturePiece::updateAverageGroundHeight(Le
{ {
if (chunkBB->isInside(x, 64, z)) if (chunkBB->isInside(x, 64, z))
{ {
total += max(level->getTopSolidBlock(x, z), level->dimension->getSpawnYPosition()); total += std::max(level->getTopSolidBlock(x, z), level->dimension->getSpawnYPosition());
count++; count++;
} }
} }

4
Minecraft.World/WorldGen/Structures/Village.cpp
View file

@ -374,10 +374,10 @@ void Village::calcInfo()
for(AUTO_VAR(it, doorInfos.begin()); it != doorInfos.end(); ++it) for(AUTO_VAR(it, doorInfos.begin()); it != doorInfos.end(); ++it)
{ {
std::shared_ptr<DoorInfo> dm = *it; std::shared_ptr<DoorInfo> dm = *it;
maxRadiusSqr = max(dm->distanceToSqr(center->x, center->y, center->z), maxRadiusSqr); maxRadiusSqr = std::max(dm->distanceToSqr(center->x, center->y, center->z), maxRadiusSqr);
} }
int doorDist= Villages::MaxDoorDist; // Take into local int for PS4 as max takes a reference to the const int there and then needs the value to exist for the linker int doorDist= Villages::MaxDoorDist; // Take into local int for PS4 as max takes a reference to the const int there and then needs the value to exist for the linker
radius = max(doorDist, (int) sqrt((float)maxRadiusSqr) + 1); radius = std::max(doorDist, (int) sqrt((float)maxRadiusSqr) + 1);
} }
int Village::getStanding(const std::wstring &playerName) int Village::getStanding(const std::wstring &playerName)