Merge branch 'master' into cBlockArea_Offset
This commit is contained in:
madmaxoft
commit
3e9f265a36
|
|
@ -1,4 +1,5 @@
|
|||
build/
|
||||
nbproject/
|
||||
ipch/
|
||||
Win32/
|
||||
MCServer/MCServer
|
||||
|
|
|
|||
|
|
@ -3,7 +3,13 @@ compiler:
|
|||
- gcc
|
||||
- clang
|
||||
# Build MCServer
|
||||
script: cmake . -DCMAKE_BUILD_TYPE=RELEASE -DBUILD_TOOLS=1 -DSELF_TEST=1 && make -j 2 && cd MCServer/ && (echo stop | ./MCServer)
|
||||
script: cmake . -DBUILD_TOOLS=1 -DSELF_TEST=1 && make -j 2 && cd MCServer/ && (echo stop | $MCSERVER_PATH)
|
||||
|
||||
env:
|
||||
- TRAVIS_MCSERVER_BUILD_TYPE=RELEASE MCSERVER_PATH=./MCServer
|
||||
- TRAVIS_MCSERVER_BUILD_TYPE=DEBUG MCSERVER_PATH=./MCServer_debug
|
||||
- TRAVIS_MCSERVER_BUILD_TYPE=RELEASE TRAVIS_MCSERVER_FORCE32=1 MCSERVER_PATH=./MCServer
|
||||
- TRAVIS_MCSERVER_BUILD_TYPE=DEBUG TRAVIS_MCSERVER_FORCE32=1 MCSERVER_PATH=./MCServer_debug
|
||||
|
||||
# Notification Settings
|
||||
notifications:
|
||||
|
|
|
|||
|
|
@ -3,6 +3,17 @@ cmake_minimum_required (VERSION 2.6)
|
|||
# Without this, the MSVC variable isn't defined for MSVC builds ( http://www.cmake.org/pipermail/cmake/2011-November/047130.html )
|
||||
enable_language(CXX C)
|
||||
|
||||
# These env variables are used for configuring Travis CI builds.
|
||||
# See https://github.com/mc-server/MCServer/pull/767
|
||||
if(DEFINED ENV{TRAVIS_MCSERVER_BUILD_TYPE})
|
||||
message("Setting build type to $ENV{TRAVIS_MCSERVER_BUILD_TYPE}")
|
||||
set(CMAKE_BUILD_TYPE $ENV{TRAVIS_MCSERVER_BUILD_TYPE})
|
||||
endif()
|
||||
|
||||
if(DEFINED ENV{TRAVIS_MCSERVER_FORCE32})
|
||||
set(FORCE32 $ENV{TRAVIS_MCSERVER_FORCE32})
|
||||
endif()
|
||||
|
||||
# This has to be done before any flags have been set up.
|
||||
if(${BUILD_TOOLS})
|
||||
add_subdirectory(Tools/MCADefrag/)
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
Code Stuff
|
||||
----------
|
||||
|
||||
* We use C++03
|
||||
* We use C++03 with some C++11 extensions (ask if you think that something would be useful)
|
||||
* Use the provided wrappers for OS stuff:
|
||||
- Threading is done by inheriting from `cIsThread`, thread synchronization through `cCriticalSection`, `cSemaphore` and `cEvent`, file access and filesystem operations through the `cFile` class, high-precision timers through `cTimer`, high-precision sleep through `cSleep`
|
||||
* No magic numbers, use named constants:
|
||||
|
|
@ -22,8 +22,10 @@ Code Stuff
|
|||
- This helps prevent mistakes such as `if (a & 1 == 0)`
|
||||
* White space is free, so use it freely
|
||||
- "freely" as in "plentifully", not "arbitrarily"
|
||||
* All `case` statements inside a `switch` need an extra indent.
|
||||
* Each and every control statement deserves its braces. This helps maintainability later on when the file is edited, lines added or removed - the control logic doesn't break so easily.
|
||||
- The only exception: a `switch` statement with all `case` statements being a single short statement is allowed to use the short brace-less form.
|
||||
- These two rules really mean that indent is governed by braces
|
||||
* Add an empty last line in all source files (GCC and GIT can complain otherwise)
|
||||
* Use doxy-comments for functions in the header file, format as `/** Description */`
|
||||
* Use spaces after the comment markers: `// Comment` instead of `//Comment`
|
||||
|
|
|
|||
|
|
@ -2031,8 +2031,9 @@ end
|
|||
Desc = "This class manages a TNT entity.",
|
||||
Functions =
|
||||
{
|
||||
GetCounterTime = { Return = "number", Notes = "Returns the time until the entity explodes." },
|
||||
GetMaxFuseTime = { Return = "number", Notes = "Returns how long the fuse was." },
|
||||
Explode = { Return = "", Notes = "Explode the tnt." },
|
||||
GetFuseTicks = { Return = "number", Notes = "Returns the fuse ticks until the tnt will explode." },
|
||||
SetFuseTicks = { Return = "number", Notes = "Set the fuse ticks until the tnt will explode." },
|
||||
},
|
||||
Inherits = "cEntity",
|
||||
},
|
||||
|
|
@ -2267,7 +2268,7 @@ end
|
|||
SpawnMob = { Params = "X, Y, Z, {{cMonster|MonsterType}}", Return = "EntityID", Notes = "Spawns the specified type of mob at the specified coords. Returns the EntityID of the creates entity, or -1 on failure. " },
|
||||
SpawnFallingBlock = { Params = "X, Y, Z, BlockType, BlockMeta", Return = "EntityID", Notes = "Spawns an {{cFallingBlock|Falling Block}} entity at the specified coords with the given block type/meta" },
|
||||
SpawnExperienceOrb = { Params = "X, Y, Z, Reward", Return = "EntityID", Notes = "Spawns an {{cExpOrb|experience orb}} at the specified coords, with the given reward" },
|
||||
SpawnPrimedTNT = { Params = "X, Y, Z, FuseTimeSecs, InitialVelocityCoeff", Return = "", Notes = "Spawns a {{cTNTEntity|primed TNT entity}} at the specified coords, with the given fuse time. The entity gets a random speed multiplied by the InitialVelocityCoeff, 1 being the default value." },
|
||||
SpawnPrimedTNT = { Params = "X, Y, Z, FuseTicks, InitialVelocityCoeff", Return = "", Notes = "Spawns a {{cTNTEntity|primed TNT entity}} at the specified coords, with the given fuse ticks. The entity gets a random speed multiplied by the InitialVelocityCoeff, 1 being the default value." },
|
||||
TryGetHeight = { Params = "BlockX, BlockZ", Return = "IsValid, Height", Notes = "Returns true and height of the highest non-air block if the chunk is loaded, or false otherwise." },
|
||||
UpdateSign = { Params = "X, Y, Z, Line1, Line2, Line3, Line4, [{{cPlayer|Player}}]", Return = "", Notes = "Sets the sign text at the specified coords. The sign-updating hooks are called for the change. The Player parameter is used to indicate the player from whom the change has come, it may be nil. Same as SetSignLiens()" },
|
||||
UseBlockEntity = { Params = "{{cPlayer|Player}}, BlockX, BlockY, BlockZ", Return = "", Notes = "Makes the specified Player use the block entity at the specified coords (open chest UI, etc.) If the cords are in an unloaded chunk or there's no block entity, ignores the call." },
|
||||
|
|
|
|||
|
|
@ -1 +1 @@
|
|||
Subproject commit 3b416b07a339b3abcbc127070d56eea05b05373d
|
||||
Subproject commit 013a32a7fb3c8a6cfe0aef892d4c7394d4e1be59
|
||||
|
|
@ -39,6 +39,7 @@
|
|||
#
|
||||
|
||||
# Need to list each of the four log types, otherwise all logs would get converted into apple planks (^0)
|
||||
|
||||
ApplePlanks, 4 = AppleLog, *
|
||||
ConiferPlanks, 4 = ConiferLog, *
|
||||
BirchPlanks, 4 = BirchLog, *
|
||||
|
|
@ -434,6 +435,55 @@ GoldNugget, 9 = GoldIngot, *
|
|||
EnchantmentTable = Obsidian, 1:3, 2:3, 3:3, 2:2 | Diamond, 1:2, 3:2 | Book, 2:1
|
||||
|
||||
|
||||
#******************************************************#
|
||||
# Fireworks & Co.
|
||||
# (Best not to add non-vanilla items to this as it will cause internal firework data handling code to log warnings)
|
||||
|
||||
# Ballistic firework rockets - plain and with firework star, all with 1 - 3 gunpowder
|
||||
FireworkRocket = Paper, * | Gunpowder, *
|
||||
FireworkRocket = Paper, * | Gunpowder, * | Gunpowder, *
|
||||
FireworkRocket = Paper, * | Gunpowder, * | Gunpowder, * | Gunpowder, *
|
||||
FireworkRocket = FireworkStar, * | Paper, * | Gunpowder, *
|
||||
FireworkRocket = FireworkStar, * | Paper, * | Gunpowder, * | Gunpowder, *
|
||||
FireworkRocket = FireworkStar, * | Paper, * | Gunpowder, * | Gunpowder, * | Gunpowder, *
|
||||
|
||||
# Radioactive firework stars
|
||||
# Plain powder and dye
|
||||
FireworkStar = Gunpowder, * | Dye ^-1, *
|
||||
|
||||
# Powder and effect, with effect combining
|
||||
FireworkStar = Gunpowder, * | Dye ^-1, * | Diamond, *
|
||||
FireworkStar = Gunpowder, * | Dye ^-1, * | Glowdust, *
|
||||
FireworkStar = Gunpowder, * | Dye ^-1, * | Glowdust, * | Diamond, *
|
||||
|
||||
# Powder and shape (no shape combining possible)
|
||||
FireworkStar = Gunpowder, * | Dye ^-1, * | Firecharge, *
|
||||
FireworkStar = Gunpowder, * | Dye ^-1, * | Goldnugget, *
|
||||
FireworkStar = Gunpowder, * | Dye ^-1, * | Feather, *
|
||||
FireworkStar = Gunpowder, * | Dye ^-1, * | SkeletonHead ^-1, *
|
||||
|
||||
# Power and shape (no shape combining possible), combined with effect
|
||||
FireworkStar = Gunpowder, * | Dye ^-1, * | Firecharge, * | Diamond, *
|
||||
FireworkStar = Gunpowder, * | Dye ^-1, * | Firecharge, * | Glowdust, *
|
||||
FireworkStar = Gunpowder, * | Dye ^-1, * | Goldnugget, * | Diamond, *
|
||||
FireworkStar = Gunpowder, * | Dye ^-1, * | Goldnugget, * | Glowdust, *
|
||||
FireworkStar = Gunpowder, * | Dye ^-1, * | Feather, * | Diamond, *
|
||||
FireworkStar = Gunpowder, * | Dye ^-1, * | Feather, * | Glowdust, *
|
||||
FireworkStar = Gunpowder, * | Dye ^-1, * | SkeletonHead ^-1, * | Diamond, *
|
||||
FireworkStar = Gunpowder, * | Dye ^-1, * | SkeletonHead ^-1, * | Glowdust, *
|
||||
|
||||
# Power and shape (no shape combining possible), combined with effect (with effect combining)
|
||||
FireworkStar = Gunpowder, * | Dye ^-1, * | Firecharge, * | Glowdust, * | Diamond, *
|
||||
FireworkStar = Gunpowder, * | Dye ^-1, * | Goldnugget, * | Glowdust, * | Diamond, *
|
||||
FireworkStar = Gunpowder, * | Dye ^-1, * | Feather, * | Glowdust, * | Diamond, *
|
||||
FireworkStar = Gunpowder, * | Dye ^-1, * | SkeletonHead ^-1, * | Glowdust, * | Diamond, *
|
||||
|
||||
# Star fade colour-change
|
||||
FireworkStar = FireworkStar, * | Dye ^-1, *
|
||||
FireworkStar = FireworkStar, * | Dye ^-1, * | Dye ^-1, *
|
||||
FireworkStar = FireworkStar, * | Dye ^-1, * | Dye ^-1, * | Dye ^-1, *
|
||||
FireworkStar = FireworkStar, * | Dye ^-1, * | Dye ^-1, * | Dye ^-1, * | Dye ^-1, *
|
||||
FireworkStar = FireworkStar, * | Dye ^-1, * | Dye ^-1, * | Dye ^-1, * | Dye ^-1, * | Dye ^-1, *
|
||||
FireworkStar = FireworkStar, * | Dye ^-1, * | Dye ^-1, * | Dye ^-1, * | Dye ^-1, * | Dye ^-1, * | Dye ^-1, *
|
||||
FireworkStar = FireworkStar, * | Dye ^-1, * | Dye ^-1, * | Dye ^-1, * | Dye ^-1, * | Dye ^-1, * | Dye ^-1, * | Dye ^-1, *
|
||||
FireworkStar = FireworkStar, * | Dye ^-1, * | Dye ^-1, * | Dye ^-1, * | Dye ^-1, * | Dye ^-1, * | Dye ^-1, * | Dye ^-1, * | Dye ^-1, *
|
||||
|
|
|
|||
|
|
@ -677,6 +677,7 @@ void cLuaState::Push(Vector3i * a_Vector)
|
|||
|
||||
void cLuaState::Push(void * a_Ptr)
|
||||
{
|
||||
UNUSED(a_Ptr);
|
||||
ASSERT(IsValid());
|
||||
|
||||
// Investigate the cause of this - what is the callstack?
|
||||
|
|
|
|||
|
|
@ -116,7 +116,7 @@ void cDispenserEntity::DropSpenseFromSlot(cChunk & a_Chunk, int a_SlotNum)
|
|||
{
|
||||
double TNTX = 0.5 + (DispX + DispChunk->GetPosX() * cChunkDef::Width);
|
||||
double TNTZ = 0.5 + (DispZ + DispChunk->GetPosZ() * cChunkDef::Width);
|
||||
m_World->SpawnPrimedTNT(TNTX, DispY + 0.5, TNTZ, 4, 0); // 4 seconds fuse, no initial velocity
|
||||
m_World->SpawnPrimedTNT(TNTX, DispY + 0.5, TNTZ, 80, 0); // 80 ticks fuse, no initial velocity
|
||||
m_Contents.ChangeSlotCount(a_SlotNum, -1);
|
||||
}
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -42,8 +42,6 @@ cBlockInfo::~cBlockInfo()
|
|||
|
||||
cBlockInfo & cBlockInfo::Get(BLOCKTYPE a_Type)
|
||||
{
|
||||
ASSERT(a_Type < 256);
|
||||
|
||||
return ms_Info[a_Type];
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -4,6 +4,7 @@
|
|||
#include "BlockHandler.h"
|
||||
#include "ChunkInterface.h"
|
||||
#include "WorldInterface.h"
|
||||
#include "MetaRotater.h"
|
||||
#include "../Entities/Player.h"
|
||||
|
||||
|
||||
|
|
@ -11,11 +12,11 @@
|
|||
|
||||
|
||||
class cBlockBedHandler :
|
||||
public cBlockHandler
|
||||
public cMetaRotater<cBlockHandler, 0x3, 0x02, 0x03, 0x00, 0x01, true>
|
||||
{
|
||||
public:
|
||||
cBlockBedHandler(BLOCKTYPE a_BlockType)
|
||||
: cBlockHandler(a_BlockType)
|
||||
: cMetaRotater<cBlockHandler, 0x3, 0x02, 0x03, 0x00, 0x01,true>(a_BlockType)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -2,16 +2,17 @@
|
|||
|
||||
#include "BlockHandler.h"
|
||||
#include "Chunk.h"
|
||||
#include "MetaRotater.h"
|
||||
|
||||
|
||||
|
||||
|
||||
class cBlockButtonHandler :
|
||||
public cBlockHandler
|
||||
public cMetaRotater<cBlockHandler, 0x07, 0x04, 0x01, 0x03, 0x02, true>
|
||||
{
|
||||
public:
|
||||
cBlockButtonHandler(BLOCKTYPE a_BlockType)
|
||||
: cBlockHandler(a_BlockType)
|
||||
: cMetaRotater<cBlockHandler, 0x07, 0x04, 0x01, 0x03, 0x02, true>(a_BlockType)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -4,17 +4,18 @@
|
|||
#include "BlockEntity.h"
|
||||
#include "../BlockArea.h"
|
||||
#include "../Entities/Player.h"
|
||||
#include "MetaRotater.h"
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
class cBlockChestHandler :
|
||||
public cBlockEntityHandler
|
||||
public cMetaRotater<cBlockEntityHandler, 0x07, 0x04, 0x01, 0x03, 0x02, true>
|
||||
{
|
||||
public:
|
||||
cBlockChestHandler(BLOCKTYPE a_BlockType)
|
||||
: cBlockEntityHandler(a_BlockType)
|
||||
: cMetaRotater<cBlockEntityHandler, 0x07, 0x04, 0x01, 0x03, 0x02, true>(a_BlockType)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -3,17 +3,18 @@
|
|||
|
||||
#include "BlockHandler.h"
|
||||
#include "BlockRedstoneRepeater.h"
|
||||
#include "MetaRotater.h"
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
class cBlockComparatorHandler :
|
||||
public cBlockHandler
|
||||
public cMetaRotater<cBlockHandler, 0x03, 0x00, 0x01, 0x02, 0x03, true>
|
||||
{
|
||||
public:
|
||||
cBlockComparatorHandler(BLOCKTYPE a_BlockType)
|
||||
: cBlockHandler(a_BlockType)
|
||||
: cMetaRotater<cBlockHandler, 0x03, 0x00, 0x01, 0x02, 0x03, true>(a_BlockType)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@
|
|||
|
||||
|
||||
cBlockDoorHandler::cBlockDoorHandler(BLOCKTYPE a_BlockType)
|
||||
: cBlockHandler(a_BlockType)
|
||||
: super(a_BlockType)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -4,13 +4,15 @@
|
|||
#include "BlockHandler.h"
|
||||
#include "../Entities/Player.h"
|
||||
#include "Chunk.h"
|
||||
#include "MetaRotater.h"
|
||||
|
||||
|
||||
|
||||
|
||||
class cBlockDoorHandler :
|
||||
public cBlockHandler
|
||||
public cMetaRotater<cBlockHandler, 0x03, 0x01, 0x02, 0x03, 0x00, true>
|
||||
{
|
||||
typedef cMetaRotater<cBlockHandler, 0x03, 0x01, 0x02, 0x03, 0x00, true> super;
|
||||
public:
|
||||
cBlockDoorHandler(BLOCKTYPE a_BlockType);
|
||||
|
||||
|
|
@ -168,6 +170,60 @@ public:
|
|||
}
|
||||
|
||||
|
||||
virtual NIBBLETYPE MetaRotateCCW(NIBBLETYPE a_Meta) override
|
||||
{
|
||||
if (a_Meta & 0x08)
|
||||
{
|
||||
return a_Meta;
|
||||
}
|
||||
else
|
||||
{
|
||||
return super::MetaRotateCCW(a_Meta);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
virtual NIBBLETYPE MetaRotateCW(NIBBLETYPE a_Meta) override
|
||||
{
|
||||
if (a_Meta & 0x08)
|
||||
{
|
||||
return a_Meta;
|
||||
}
|
||||
else
|
||||
{
|
||||
return super::MetaRotateCW(a_Meta);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
virtual NIBBLETYPE MetaMirrorXY(NIBBLETYPE a_Meta) override
|
||||
{
|
||||
if (a_Meta & 0x08)
|
||||
{
|
||||
return a_Meta;
|
||||
}
|
||||
else
|
||||
{
|
||||
return super::MetaMirrorXY(a_Meta);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
virtual NIBBLETYPE MetaMirrorYZ(NIBBLETYPE a_Meta) override
|
||||
{
|
||||
if (a_Meta & 0x08)
|
||||
{
|
||||
return a_Meta;
|
||||
}
|
||||
else
|
||||
{
|
||||
return super::MetaMirrorYZ(a_Meta);
|
||||
}
|
||||
}
|
||||
|
||||
} ;
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -6,17 +6,18 @@
|
|||
#pragma once
|
||||
|
||||
#include "../Piston.h"
|
||||
#include "MetaRotater.h"
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
class cBlockDropSpenserHandler :
|
||||
public cBlockEntityHandler
|
||||
public cMetaRotater<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>
|
||||
{
|
||||
public:
|
||||
cBlockDropSpenserHandler(BLOCKTYPE a_BlockType) :
|
||||
cBlockEntityHandler(a_BlockType)
|
||||
cMetaRotater<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>(a_BlockType)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
@ -34,6 +35,20 @@ public:
|
|||
a_BlockMeta = cPiston::RotationPitchToMetaData(a_Player->GetYaw(), a_Player->GetPitch());
|
||||
return true;
|
||||
}
|
||||
|
||||
virtual NIBBLETYPE MetaMirrorXZ(NIBBLETYPE a_Meta) override
|
||||
{
|
||||
// Bit 0x08 is a flag. Lowest three bits are position. 0x08 == 1000
|
||||
NIBBLETYPE OtherMeta = a_Meta & 0x08;
|
||||
// Mirrors defined by by a table. (Source, mincraft.gamepedia.com) 0x07 == 0111
|
||||
switch (a_Meta & 0x07)
|
||||
{
|
||||
case 0x00: return 0x01 + OtherMeta; // Down -> Up
|
||||
case 0x01: return 0x00 + OtherMeta; // Up -> Down
|
||||
}
|
||||
// Not Facing Up or Down; No change.
|
||||
return a_Meta;
|
||||
}
|
||||
} ;
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -2,17 +2,17 @@
|
|||
#pragma once
|
||||
|
||||
#include "BlockEntity.h"
|
||||
|
||||
#include "MetaRotater.h"
|
||||
|
||||
|
||||
|
||||
|
||||
class cBlockEnderchestHandler :
|
||||
public cBlockEntityHandler
|
||||
public cMetaRotater<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>
|
||||
{
|
||||
public:
|
||||
cBlockEnderchestHandler(BLOCKTYPE a_BlockType)
|
||||
: cBlockEntityHandler(a_BlockType)
|
||||
: cMetaRotater<cBlockEntityHandler, 0x07, 0x02, 0x05, 0x03, 0x04>(a_BlockType)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -2,17 +2,17 @@
|
|||
#pragma once
|
||||
|
||||
#include "BlockHandler.h"
|
||||
|
||||
#include "MetaRotater.h"
|
||||
|
||||
|
||||
|
||||
|
||||
class cBlockFenceGateHandler :
|
||||
public cBlockHandler
|
||||
public cMetaRotater<cBlockHandler, 0x03, 0x02, 0x03, 0x00, 0x01, true>
|
||||
{
|
||||
public:
|
||||
cBlockFenceGateHandler(BLOCKTYPE a_BlockType) :
|
||||
cBlockHandler(a_BlockType)
|
||||
cMetaRotater<cBlockHandler, 0x03, 0x02, 0x03, 0x00, 0x01, true>(a_BlockType)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -23,6 +23,8 @@ class cBlockHandler
|
|||
{
|
||||
public:
|
||||
cBlockHandler(BLOCKTYPE a_BlockType);
|
||||
|
||||
virtual ~cBlockHandler() {}
|
||||
|
||||
/// Called when the block gets ticked either by a random tick or by a queued tick.
|
||||
/// Note that the coords are chunk-relative!
|
||||
|
|
|
|||
|
|
@ -2,17 +2,17 @@
|
|||
#pragma once
|
||||
|
||||
#include "BlockHandler.h"
|
||||
|
||||
#include "MetaRotater.h"
|
||||
|
||||
|
||||
|
||||
|
||||
class cBlockStairsHandler :
|
||||
public cBlockHandler
|
||||
public cMetaRotater<cBlockHandler, 0x03, 0x03, 0x00, 0x02, 0x01, true>
|
||||
{
|
||||
public:
|
||||
cBlockStairsHandler(BLOCKTYPE a_BlockType) :
|
||||
cBlockHandler(a_BlockType)
|
||||
cMetaRotater<cBlockHandler, 0x03, 0x03, 0x00, 0x02, 0x01, true>(a_BlockType)
|
||||
{
|
||||
|
||||
}
|
||||
|
|
@ -25,6 +25,14 @@ public:
|
|||
BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
|
||||
) override
|
||||
{
|
||||
UNUSED(a_ChunkInterface);
|
||||
UNUSED(a_BlockX);
|
||||
UNUSED(a_BlockY);
|
||||
UNUSED(a_BlockZ);
|
||||
UNUSED(a_CursorX);
|
||||
UNUSED(a_CursorY);
|
||||
UNUSED(a_CursorZ);
|
||||
UNUSED(a_BlockMeta);
|
||||
a_BlockType = m_BlockType;
|
||||
a_BlockMeta = RotationToMetaData(a_Player->GetYaw());
|
||||
switch (a_BlockFace)
|
||||
|
|
@ -96,54 +104,6 @@ public:
|
|||
}
|
||||
|
||||
|
||||
virtual NIBBLETYPE MetaRotateCCW(NIBBLETYPE a_Meta) override
|
||||
{
|
||||
// Bits 3 and 4 stay, the rest is swapped around according to a table:
|
||||
NIBBLETYPE TopBits = (a_Meta & 0x0c);
|
||||
switch (a_Meta & 0x03)
|
||||
{
|
||||
case 0x00: return TopBits | 0x03; // East -> North
|
||||
case 0x01: return TopBits | 0x02; // West -> South
|
||||
case 0x02: return TopBits | 0x00; // South -> East
|
||||
case 0x03: return TopBits | 0x01; // North -> West
|
||||
}
|
||||
// Not reachable, but to avoid a compiler warning:
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
virtual NIBBLETYPE MetaRotateCW(NIBBLETYPE a_Meta) override
|
||||
{
|
||||
// Bits 3 and 4 stay, the rest is swapped around according to a table:
|
||||
NIBBLETYPE TopBits = (a_Meta & 0x0c);
|
||||
switch (a_Meta & 0x03)
|
||||
{
|
||||
case 0x00: return TopBits | 0x02; // East -> South
|
||||
case 0x01: return TopBits | 0x03; // West -> North
|
||||
case 0x02: return TopBits | 0x01; // South -> West
|
||||
case 0x03: return TopBits | 0x00; // North -> East
|
||||
}
|
||||
// Not reachable, but to avoid a compiler warning:
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
virtual NIBBLETYPE MetaMirrorXY(NIBBLETYPE a_Meta) override
|
||||
{
|
||||
// Bits 3 and 4 stay, the rest is swapped around according to a table:
|
||||
NIBBLETYPE TopBits = (a_Meta & 0x0c);
|
||||
switch (a_Meta & 0x03)
|
||||
{
|
||||
case 0x00: return TopBits | 0x00; // East -> East
|
||||
case 0x01: return TopBits | 0x01; // West -> West
|
||||
case 0x02: return TopBits | 0x03; // South -> North
|
||||
case 0x03: return TopBits | 0x02; // North -> South
|
||||
}
|
||||
// Not reachable, but to avoid a compiler warning:
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
virtual NIBBLETYPE MetaMirrorXZ(NIBBLETYPE a_Meta) override
|
||||
{
|
||||
// Toggle bit 3:
|
||||
|
|
@ -151,20 +111,6 @@ public:
|
|||
}
|
||||
|
||||
|
||||
virtual NIBBLETYPE MetaMirrorYZ(NIBBLETYPE a_Meta) override
|
||||
{
|
||||
// Bits 3 and 4 stay, the rest is swapped around according to a table:
|
||||
NIBBLETYPE TopBits = (a_Meta & 0x0c);
|
||||
switch (a_Meta & 0x03)
|
||||
{
|
||||
case 0x00: return TopBits | 0x01; // East -> West
|
||||
case 0x01: return TopBits | 0x00; // West -> East
|
||||
case 0x02: return TopBits | 0x02; // South -> South
|
||||
case 0x03: return TopBits | 0x03; // North -> North
|
||||
}
|
||||
// Not reachable, but to avoid a compiler warning:
|
||||
return 0;
|
||||
}
|
||||
} ;
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -2,17 +2,17 @@
|
|||
|
||||
#include "BlockHandler.h"
|
||||
#include "../Chunk.h"
|
||||
|
||||
#include "MetaRotater.h"
|
||||
|
||||
|
||||
|
||||
|
||||
class cBlockTorchHandler :
|
||||
public cBlockHandler
|
||||
public cMetaRotater<cBlockHandler, 0x7, 0x4, 0x1, 0x3, 0x2>
|
||||
{
|
||||
public:
|
||||
cBlockTorchHandler(BLOCKTYPE a_BlockType)
|
||||
: cBlockHandler(a_BlockType)
|
||||
: cMetaRotater<cBlockHandler, 0x7, 0x4, 0x1, 0x3, 0x2>(a_BlockType)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
@ -185,67 +185,6 @@ public:
|
|||
{
|
||||
return "step.wood";
|
||||
}
|
||||
|
||||
|
||||
virtual NIBBLETYPE MetaRotateCCW(NIBBLETYPE a_Meta) override
|
||||
{
|
||||
// Bit 4 stays, the rest is swapped around according to a table:
|
||||
NIBBLETYPE TopBits = (a_Meta & 0x08);
|
||||
switch (a_Meta & 0x07)
|
||||
{
|
||||
case 0x01: return TopBits | 0x04; // East -> North
|
||||
case 0x02: return TopBits | 0x03; // West -> South
|
||||
case 0x03: return TopBits | 0x01; // South -> East
|
||||
case 0x04: return TopBits | 0x02; // North -> West
|
||||
default: return a_Meta; // Floor -> Floor
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
virtual NIBBLETYPE MetaRotateCW(NIBBLETYPE a_Meta) override
|
||||
{
|
||||
// Bit 4 stays, the rest is swapped around according to a table:
|
||||
NIBBLETYPE TopBits = (a_Meta & 0x08);
|
||||
switch (a_Meta & 0x07)
|
||||
{
|
||||
case 0x01: return TopBits | 0x03; // East -> South
|
||||
case 0x02: return TopBits | 0x04; // West -> North
|
||||
case 0x03: return TopBits | 0x02; // South -> West
|
||||
case 0x04: return TopBits | 0x01; // North -> East
|
||||
default: return a_Meta; // Floor -> Floor
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
virtual NIBBLETYPE MetaMirrorXY(NIBBLETYPE a_Meta) override
|
||||
{
|
||||
// Bit 4 stays, the rest is swapped around according to a table:
|
||||
NIBBLETYPE TopBits = (a_Meta & 0x08);
|
||||
switch (a_Meta & 0x07)
|
||||
{
|
||||
case 0x03: return TopBits | 0x04; // South -> North
|
||||
case 0x04: return TopBits | 0x03; // North -> South
|
||||
default: return a_Meta; // Keep the rest
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Mirroring around the XZ plane doesn't make sense for floor torches,
|
||||
// the others stay the same, so let's keep all the metas the same.
|
||||
// The base class does tht for us, no need to override MetaMirrorXZ()
|
||||
|
||||
|
||||
virtual NIBBLETYPE MetaMirrorYZ(NIBBLETYPE a_Meta) override
|
||||
{
|
||||
// Bit 4 stays, the rest is swapped around according to a table:
|
||||
NIBBLETYPE TopBits = (a_Meta & 0x08);
|
||||
switch (a_Meta & 0x07)
|
||||
{
|
||||
case 0x01: return TopBits | 0x02; // East -> West
|
||||
case 0x02: return TopBits | 0x01; // West -> East
|
||||
default: return a_Meta; // Keep the rest
|
||||
}
|
||||
}
|
||||
} ;
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,8 +1,7 @@
|
|||
|
||||
#pragma once
|
||||
|
||||
#include "BlockHandler.h"
|
||||
|
||||
#include "MetaRotater.h"
|
||||
|
||||
|
||||
|
||||
|
|
@ -24,6 +23,10 @@ public:
|
|||
BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
|
||||
) override
|
||||
{
|
||||
UNUSED(a_Player);
|
||||
UNUSED(a_CursorX);
|
||||
UNUSED(a_CursorY);
|
||||
UNUSED(a_CursorZ);
|
||||
// TODO: Disallow placement where the vine doesn't attach to something properly
|
||||
BLOCKTYPE BlockType = 0;
|
||||
NIBBLETYPE BlockMeta;
|
||||
|
|
@ -162,11 +165,17 @@ public:
|
|||
return false;
|
||||
}
|
||||
|
||||
virtual void OnUpdate(cWorld * a_World, int X, int Y, int Z)
|
||||
virtual void OnUpdate(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_BlockPluginInterface, cChunk & a_Chunk, int a_RelX, int a_RelY, int a_RelZ)
|
||||
{
|
||||
if (a_World->GetBlock(X, Y - 1, Z) == E_BLOCK_AIR)
|
||||
UNUSED(a_ChunkInterface);
|
||||
UNUSED(a_WorldInterface);
|
||||
UNUSED(a_BlockPluginInterface);
|
||||
|
||||
BLOCKTYPE Block;
|
||||
a_Chunk.UnboundedRelGetBlockType(a_RelX, a_RelY - 1, a_RelZ, Block);
|
||||
if (Block == E_BLOCK_AIR)
|
||||
{
|
||||
a_World->SetBlock(X, Y - 1, Z, E_BLOCK_VINES, a_World->GetBlockMeta(X, Y, Z));
|
||||
a_Chunk.UnboundedRelSetBlock(a_RelX, a_RelY - 1, a_RelZ, E_BLOCK_VINES, a_Chunk.GetMeta(a_RelX, a_RelY, a_RelZ));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -180,8 +189,8 @@ public:
|
|||
{
|
||||
return ((a_Meta << 1) | (a_Meta >> 3)) & 0x0f; // Rotate bits to the left
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
virtual NIBBLETYPE MetaMirrorXY(NIBBLETYPE a_Meta) override
|
||||
{
|
||||
// Bits 2 and 4 stay, bits 1 and 3 swap
|
||||
|
|
@ -194,6 +203,7 @@ public:
|
|||
// Bits 1 and 3 stay, bits 2 and 4 swap
|
||||
return ((a_Meta & 0x05) | ((a_Meta & 0x02) << 2) | ((a_Meta & 0x08) >> 2));
|
||||
}
|
||||
|
||||
} ;
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,120 @@
|
|||
// MetaRotater.h
|
||||
|
||||
// Provides a mixin for rotations and reflections
|
||||
|
||||
#pragma once
|
||||
|
||||
// MSVC generates warnings for the templated AssertIfNotMatched parameter conditions, so disable it:
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning(disable: 4127) // Conditional expression is constant
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*
|
||||
Provides a mixin for rotations and reflections following the standard pattern of apply mask then use case.
|
||||
|
||||
Usage:
|
||||
Inherit from this class providing your base class as Base, the BitMask for the direction bits in bitmask and the masked value for the directions in North, East, South, West. There is also an aptional parameter AssertIfNotMatched. Set this if it is invalid for a block to exist in any other state.
|
||||
*/
|
||||
|
||||
template<class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched = false>
|
||||
class cMetaRotater : public Base
|
||||
{
|
||||
public:
|
||||
|
||||
cMetaRotater(BLOCKTYPE a_BlockType) :
|
||||
Base(a_BlockType)
|
||||
{}
|
||||
|
||||
virtual ~cMetaRotater() {}
|
||||
|
||||
virtual NIBBLETYPE MetaRotateCCW(NIBBLETYPE a_Meta) override;
|
||||
virtual NIBBLETYPE MetaRotateCW(NIBBLETYPE a_Meta) override;
|
||||
virtual NIBBLETYPE MetaMirrorXY(NIBBLETYPE a_Meta) override;
|
||||
virtual NIBBLETYPE MetaMirrorYZ(NIBBLETYPE a_Meta) override;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched>
|
||||
NIBBLETYPE cMetaRotater<Base, BitMask, North, East, South, West, AssertIfNotMatched>::MetaRotateCW(NIBBLETYPE a_Meta)
|
||||
{
|
||||
NIBBLETYPE OtherMeta = a_Meta & (~BitMask);
|
||||
switch (a_Meta & BitMask)
|
||||
{
|
||||
case South: return West | OtherMeta;
|
||||
case West: return North | OtherMeta;
|
||||
case North: return East | OtherMeta;
|
||||
case East: return South | OtherMeta;
|
||||
}
|
||||
if (AssertIfNotMatched)
|
||||
{
|
||||
ASSERT(!"Invalid Meta value");
|
||||
}
|
||||
return a_Meta;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched>
|
||||
NIBBLETYPE cMetaRotater<Base, BitMask, North, East, South, West, AssertIfNotMatched>::MetaRotateCCW(NIBBLETYPE a_Meta)
|
||||
{
|
||||
NIBBLETYPE OtherMeta = a_Meta & (~BitMask);
|
||||
switch (a_Meta & BitMask)
|
||||
{
|
||||
case South: return East | OtherMeta;
|
||||
case East: return North | OtherMeta;
|
||||
case North: return West | OtherMeta;
|
||||
case West: return South | OtherMeta;
|
||||
}
|
||||
if (AssertIfNotMatched)
|
||||
{
|
||||
ASSERT(!"Invalid Meta value");
|
||||
}
|
||||
return a_Meta;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched>
|
||||
NIBBLETYPE cMetaRotater<Base, BitMask, North, East, South, West, AssertIfNotMatched>::MetaMirrorXY(NIBBLETYPE a_Meta)
|
||||
{
|
||||
NIBBLETYPE OtherMeta = a_Meta & (~BitMask);
|
||||
switch (a_Meta & BitMask)
|
||||
{
|
||||
case South: return North | OtherMeta;
|
||||
case North: return South | OtherMeta;
|
||||
}
|
||||
// Not Facing North or South; No change.
|
||||
return a_Meta;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template<class Base, NIBBLETYPE BitMask, NIBBLETYPE North, NIBBLETYPE East, NIBBLETYPE South, NIBBLETYPE West, bool AssertIfNotMatched>
|
||||
NIBBLETYPE cMetaRotater<Base, BitMask, North, East, South, West, AssertIfNotMatched>::MetaMirrorYZ(NIBBLETYPE a_Meta)
|
||||
{
|
||||
NIBBLETYPE OtherMeta = a_Meta & (~BitMask);
|
||||
switch (a_Meta & BitMask)
|
||||
{
|
||||
case West: return East | OtherMeta;
|
||||
case East: return West | OtherMeta;
|
||||
}
|
||||
// Not Facing East or West; No change.
|
||||
return a_Meta;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -44,10 +44,10 @@
|
|||
|
||||
|
||||
|
||||
#if 0
|
||||
#ifdef SELF_TEST
|
||||
|
||||
/// Self-test of the VarInt-reading and writing code
|
||||
class cByteBufferSelfTest
|
||||
static class cByteBufferSelfTest
|
||||
{
|
||||
public:
|
||||
cByteBufferSelfTest(void)
|
||||
|
|
@ -86,7 +86,7 @@ public:
|
|||
cByteBuffer buf(3);
|
||||
for (int i = 0; i < 1000; i++)
|
||||
{
|
||||
int FreeSpace = buf.GetFreeSpace();
|
||||
size_t FreeSpace = buf.GetFreeSpace();
|
||||
assert(buf.GetReadableSpace() == 0);
|
||||
assert(FreeSpace > 0);
|
||||
assert(buf.Write("a", 1));
|
||||
|
|
@ -171,21 +171,22 @@ cByteBuffer::~cByteBuffer()
|
|||
|
||||
|
||||
|
||||
bool cByteBuffer::Write(const char * a_Bytes, int a_Count)
|
||||
bool cByteBuffer::Write(const char * a_Bytes, size_t a_Count)
|
||||
{
|
||||
CHECK_THREAD;
|
||||
CheckValid();
|
||||
|
||||
// Store the current free space for a check after writing:
|
||||
int CurFreeSpace = GetFreeSpace();
|
||||
int CurReadableSpace = GetReadableSpace();
|
||||
int WrittenBytes = 0;
|
||||
size_t CurFreeSpace = GetFreeSpace();
|
||||
size_t CurReadableSpace = GetReadableSpace();
|
||||
size_t WrittenBytes = 0;
|
||||
|
||||
if (CurFreeSpace < a_Count)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
int TillEnd = m_BufferSize - m_WritePos;
|
||||
ASSERT(m_BufferSize >= m_WritePos);
|
||||
size_t TillEnd = m_BufferSize - m_WritePos;
|
||||
if (TillEnd <= a_Count)
|
||||
{
|
||||
// Need to wrap around the ringbuffer end
|
||||
|
|
@ -216,16 +217,20 @@ bool cByteBuffer::Write(const char * a_Bytes, int a_Count)
|
|||
|
||||
|
||||
|
||||
int cByteBuffer::GetFreeSpace(void) const
|
||||
size_t cByteBuffer::GetFreeSpace(void) const
|
||||
{
|
||||
CHECK_THREAD;
|
||||
CheckValid();
|
||||
if (m_WritePos >= m_DataStart)
|
||||
{
|
||||
// Wrap around the buffer end:
|
||||
ASSERT(m_BufferSize >= m_WritePos);
|
||||
ASSERT((m_BufferSize - m_WritePos + m_DataStart) >= 1);
|
||||
return m_BufferSize - m_WritePos + m_DataStart - 1;
|
||||
}
|
||||
// Single free space partition:
|
||||
ASSERT(m_BufferSize >= m_WritePos);
|
||||
ASSERT(m_BufferSize - m_WritePos >= 1);
|
||||
return m_DataStart - m_WritePos - 1;
|
||||
}
|
||||
|
||||
|
|
@ -234,10 +239,12 @@ int cByteBuffer::GetFreeSpace(void) const
|
|||
|
||||
|
||||
/// Returns the number of bytes that are currently in the ringbuffer. Note GetReadableBytes()
|
||||
int cByteBuffer::GetUsedSpace(void) const
|
||||
size_t cByteBuffer::GetUsedSpace(void) const
|
||||
{
|
||||
CHECK_THREAD;
|
||||
CheckValid();
|
||||
ASSERT(m_BufferSize >= GetFreeSpace());
|
||||
ASSERT((m_BufferSize - GetFreeSpace()) >= 1);
|
||||
return m_BufferSize - GetFreeSpace() - 1;
|
||||
}
|
||||
|
||||
|
|
@ -246,16 +253,18 @@ int cByteBuffer::GetUsedSpace(void) const
|
|||
|
||||
|
||||
/// Returns the number of bytes that are currently available for reading (may be less than UsedSpace due to some data having been read already)
|
||||
int cByteBuffer::GetReadableSpace(void) const
|
||||
size_t cByteBuffer::GetReadableSpace(void) const
|
||||
{
|
||||
CHECK_THREAD;
|
||||
CheckValid();
|
||||
if (m_ReadPos > m_WritePos)
|
||||
{
|
||||
// Wrap around the buffer end:
|
||||
ASSERT(m_BufferSize >= m_ReadPos);
|
||||
return m_BufferSize - m_ReadPos + m_WritePos;
|
||||
}
|
||||
// Single readable space partition:
|
||||
ASSERT(m_WritePos >= m_ReadPos);
|
||||
return m_WritePos - m_ReadPos ;
|
||||
}
|
||||
|
||||
|
|
@ -263,7 +272,7 @@ int cByteBuffer::GetReadableSpace(void) const
|
|||
|
||||
|
||||
|
||||
bool cByteBuffer::CanReadBytes(int a_Count) const
|
||||
bool cByteBuffer::CanReadBytes(size_t a_Count) const
|
||||
{
|
||||
CHECK_THREAD;
|
||||
CheckValid();
|
||||
|
|
@ -274,7 +283,7 @@ bool cByteBuffer::CanReadBytes(int a_Count) const
|
|||
|
||||
|
||||
|
||||
bool cByteBuffer::CanWriteBytes(int a_Count) const
|
||||
bool cByteBuffer::CanWriteBytes(size_t a_Count) const
|
||||
{
|
||||
CHECK_THREAD;
|
||||
CheckValid();
|
||||
|
|
@ -650,15 +659,14 @@ bool cByteBuffer::WriteLEInt(int a_Value)
|
|||
|
||||
|
||||
|
||||
bool cByteBuffer::ReadBuf(void * a_Buffer, int a_Count)
|
||||
bool cByteBuffer::ReadBuf(void * a_Buffer, size_t a_Count)
|
||||
{
|
||||
CHECK_THREAD;
|
||||
CheckValid();
|
||||
ASSERT(a_Count >= 0);
|
||||
NEEDBYTES(a_Count);
|
||||
char * Dst = (char *)a_Buffer; // So that we can do byte math
|
||||
int BytesToEndOfBuffer = m_BufferSize - m_ReadPos;
|
||||
ASSERT(BytesToEndOfBuffer >= 0); // Sanity check
|
||||
ASSERT(m_BufferSize >= m_ReadPos);
|
||||
size_t BytesToEndOfBuffer = m_BufferSize - m_ReadPos;
|
||||
if (BytesToEndOfBuffer <= a_Count)
|
||||
{
|
||||
// Reading across the ringbuffer end, read the first part and adjust parameters:
|
||||
|
|
@ -684,14 +692,14 @@ bool cByteBuffer::ReadBuf(void * a_Buffer, int a_Count)
|
|||
|
||||
|
||||
|
||||
bool cByteBuffer::WriteBuf(const void * a_Buffer, int a_Count)
|
||||
bool cByteBuffer::WriteBuf(const void * a_Buffer, size_t a_Count)
|
||||
{
|
||||
CHECK_THREAD;
|
||||
CheckValid();
|
||||
ASSERT(a_Count >= 0);
|
||||
PUTBYTES(a_Count);
|
||||
char * Src = (char *)a_Buffer; // So that we can do byte math
|
||||
int BytesToEndOfBuffer = m_BufferSize - m_WritePos;
|
||||
ASSERT(m_BufferSize >= m_ReadPos);
|
||||
size_t BytesToEndOfBuffer = m_BufferSize - m_WritePos;
|
||||
if (BytesToEndOfBuffer <= a_Count)
|
||||
{
|
||||
// Reading across the ringbuffer end, read the first part and adjust parameters:
|
||||
|
|
@ -714,22 +722,22 @@ bool cByteBuffer::WriteBuf(const void * a_Buffer, int a_Count)
|
|||
|
||||
|
||||
|
||||
bool cByteBuffer::ReadString(AString & a_String, int a_Count)
|
||||
bool cByteBuffer::ReadString(AString & a_String, size_t a_Count)
|
||||
{
|
||||
CHECK_THREAD;
|
||||
CheckValid();
|
||||
ASSERT(a_Count >= 0);
|
||||
NEEDBYTES(a_Count);
|
||||
a_String.clear();
|
||||
a_String.reserve(a_Count);
|
||||
int BytesToEndOfBuffer = m_BufferSize - m_ReadPos;
|
||||
ASSERT(BytesToEndOfBuffer >= 0); // Sanity check
|
||||
ASSERT(m_BufferSize >= m_ReadPos);
|
||||
size_t BytesToEndOfBuffer = m_BufferSize - m_ReadPos;
|
||||
if (BytesToEndOfBuffer <= a_Count)
|
||||
{
|
||||
// Reading across the ringbuffer end, read the first part and adjust parameters:
|
||||
if (BytesToEndOfBuffer > 0)
|
||||
{
|
||||
a_String.assign(m_Buffer + m_ReadPos, BytesToEndOfBuffer);
|
||||
ASSERT(a_Count >= BytesToEndOfBuffer);
|
||||
a_Count -= BytesToEndOfBuffer;
|
||||
}
|
||||
m_ReadPos = 0;
|
||||
|
|
@ -767,11 +775,10 @@ bool cByteBuffer::ReadUTF16String(AString & a_String, int a_NumChars)
|
|||
|
||||
|
||||
|
||||
bool cByteBuffer::SkipRead(int a_Count)
|
||||
bool cByteBuffer::SkipRead(size_t a_Count)
|
||||
{
|
||||
CHECK_THREAD;
|
||||
CheckValid();
|
||||
ASSERT(a_Count >= 0);
|
||||
if (!CanReadBytes(a_Count))
|
||||
{
|
||||
return false;
|
||||
|
|
@ -809,6 +816,7 @@ bool cByteBuffer::ReadToByteBuffer(cByteBuffer & a_Dst, size_t a_NumBytes)
|
|||
size_t num = (a_NumBytes > sizeof(buf)) ? sizeof(buf) : a_NumBytes;
|
||||
VERIFY(ReadBuf(buf, num));
|
||||
VERIFY(a_Dst.Write(buf, num));
|
||||
ASSERT(a_NumBytes >= num);
|
||||
a_NumBytes -= num;
|
||||
}
|
||||
return true;
|
||||
|
|
@ -846,13 +854,15 @@ void cByteBuffer::ReadAgain(AString & a_Out)
|
|||
// Used by ProtoProxy to repeat communication twice, once for parsing and the other time for the remote party
|
||||
CHECK_THREAD;
|
||||
CheckValid();
|
||||
int DataStart = m_DataStart;
|
||||
size_t DataStart = m_DataStart;
|
||||
if (m_ReadPos < m_DataStart)
|
||||
{
|
||||
// Across the ringbuffer end, read the first part and adjust next part's start:
|
||||
ASSERT(m_BufferSize >= m_DataStart);
|
||||
a_Out.append(m_Buffer + m_DataStart, m_BufferSize - m_DataStart);
|
||||
DataStart = 0;
|
||||
}
|
||||
ASSERT(m_ReadPos >= DataStart);
|
||||
a_Out.append(m_Buffer + DataStart, m_ReadPos - DataStart);
|
||||
}
|
||||
|
||||
|
|
@ -860,7 +870,7 @@ void cByteBuffer::ReadAgain(AString & a_Out)
|
|||
|
||||
|
||||
|
||||
void cByteBuffer::AdvanceReadPos(int a_Count)
|
||||
void cByteBuffer::AdvanceReadPos(size_t a_Count)
|
||||
{
|
||||
CHECK_THREAD;
|
||||
CheckValid();
|
||||
|
|
|
|||
|
|
@ -31,25 +31,25 @@ public:
|
|||
~cByteBuffer();
|
||||
|
||||
/// Writes the bytes specified to the ringbuffer. Returns true if successful, false if not
|
||||
bool Write(const char * a_Bytes, int a_Count);
|
||||
bool Write(const char * a_Bytes, size_t a_Count);
|
||||
|
||||
/// Returns the number of bytes that can be successfully written to the ringbuffer
|
||||
int GetFreeSpace(void) const;
|
||||
size_t GetFreeSpace(void) const;
|
||||
|
||||
/// Returns the number of bytes that are currently in the ringbuffer. Note GetReadableBytes()
|
||||
int GetUsedSpace(void) const;
|
||||
size_t GetUsedSpace(void) const;
|
||||
|
||||
/// Returns the number of bytes that are currently available for reading (may be less than UsedSpace due to some data having been read already)
|
||||
int GetReadableSpace(void) const;
|
||||
size_t GetReadableSpace(void) const;
|
||||
|
||||
/// Returns the current data start index. For debugging purposes.
|
||||
int GetDataStart(void) const { return m_DataStart; }
|
||||
|
||||
/// Returns true if the specified amount of bytes are available for reading
|
||||
bool CanReadBytes(int a_Count) const;
|
||||
bool CanReadBytes(size_t a_Count) const;
|
||||
|
||||
/// Returns true if the specified amount of bytes are available for writing
|
||||
bool CanWriteBytes(int a_Count) const;
|
||||
bool CanWriteBytes(size_t a_Count) const;
|
||||
|
||||
// Read the specified datatype and advance the read pointer; return true if successfully read:
|
||||
bool ReadChar (char & a_Value);
|
||||
|
|
@ -92,19 +92,19 @@ public:
|
|||
bool WriteLEInt (int a_Value);
|
||||
|
||||
/// Reads a_Count bytes into a_Buffer; returns true if successful
|
||||
bool ReadBuf(void * a_Buffer, int a_Count);
|
||||
bool ReadBuf(void * a_Buffer, size_t a_Count);
|
||||
|
||||
/// Writes a_Count bytes into a_Buffer; returns true if successful
|
||||
bool WriteBuf(const void * a_Buffer, int a_Count);
|
||||
bool WriteBuf(const void * a_Buffer, size_t a_Count);
|
||||
|
||||
/// Reads a_Count bytes into a_String; returns true if successful
|
||||
bool ReadString(AString & a_String, int a_Count);
|
||||
bool ReadString(AString & a_String, size_t a_Count);
|
||||
|
||||
/// Reads 2 * a_NumChars bytes and interprets it as a UTF16-BE string, converting it into UTF8 string a_String
|
||||
bool ReadUTF16String(AString & a_String, int a_NumChars);
|
||||
|
||||
/// Skips reading by a_Count bytes; returns false if not enough bytes in the ringbuffer
|
||||
bool SkipRead(int a_Count);
|
||||
bool SkipRead(size_t a_Count);
|
||||
|
||||
/// Reads all available data into a_Data
|
||||
void ReadAll(AString & a_Data);
|
||||
|
|
@ -126,18 +126,18 @@ public:
|
|||
|
||||
protected:
|
||||
char * m_Buffer;
|
||||
int m_BufferSize; // Total size of the ringbuffer
|
||||
size_t m_BufferSize; // Total size of the ringbuffer
|
||||
|
||||
#ifdef _DEBUG
|
||||
volatile unsigned long m_ThreadID; // Thread that is currently accessing the object, checked via cSingleThreadAccessChecker
|
||||
#endif // _DEBUG
|
||||
|
||||
int m_DataStart; // Where the data starts in the ringbuffer
|
||||
int m_WritePos; // Where the data ends in the ringbuffer
|
||||
int m_ReadPos; // Where the next read will start in the ringbuffer
|
||||
size_t m_DataStart; // Where the data starts in the ringbuffer
|
||||
size_t m_WritePos; // Where the data ends in the ringbuffer
|
||||
size_t m_ReadPos; // Where the next read will start in the ringbuffer
|
||||
|
||||
/// Advances the m_ReadPos by a_Count bytes
|
||||
void AdvanceReadPos(int a_Count);
|
||||
void AdvanceReadPos(size_t a_Count);
|
||||
} ;
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
|
||||
cmake_minimum_required (VERSION 2.8.2)
|
||||
project (MCServer)
|
||||
|
||||
|
|
@ -10,7 +9,6 @@ set(FOLDERS OSSupport HTTPServer Items Blocks Protocol Generating)
|
|||
set(FOLDERS ${FOLDERS} WorldStorage Mobs Entities Simulator UI BlockEntities)
|
||||
|
||||
|
||||
|
||||
if (NOT MSVC)
|
||||
|
||||
#Bindings needs to reference other folders so are done here
|
||||
|
|
|
|||
|
|
@ -62,16 +62,12 @@ typedef unsigned char HEIGHTTYPE;
|
|||
class cChunkDef
|
||||
{
|
||||
public:
|
||||
enum
|
||||
{
|
||||
// Chunk dimensions:
|
||||
Width = 16,
|
||||
Height = 256,
|
||||
NumBlocks = Width * Height * Width,
|
||||
|
||||
/// If the data is collected into a single buffer, how large it needs to be:
|
||||
BlockDataSize = cChunkDef::NumBlocks * 2 + (cChunkDef::NumBlocks / 2), // 2.5 * numblocks
|
||||
} ;
|
||||
// Chunk dimensions:
|
||||
static const int Width = 16;
|
||||
static const int Height = 256;
|
||||
static const int NumBlocks = Width * Height * Width;
|
||||
/// If the data is collected into a single buffer, how large it needs to be:
|
||||
static const int BlockDataSize = cChunkDef::NumBlocks * 2 + (cChunkDef::NumBlocks / 2); // 2.5 * numblocks
|
||||
|
||||
/// The type used for any heightmap operations and storage; idx = x + Width * z; Height points to the highest non-air block in the column
|
||||
typedef HEIGHTTYPE HeightMap[Width * Width];
|
||||
|
|
|
|||
|
|
@ -52,6 +52,9 @@
|
|||
/** Maximum number of explosions to send this tick, server will start dropping if exceeded */
|
||||
#define MAX_EXPLOSIONS_PER_TICK 20
|
||||
|
||||
/** Maximum number of block change interactions a player can perform per tick - exceeding this causes a kick */
|
||||
#define MAX_BLOCK_CHANGE_INTERACTIONS 20
|
||||
|
||||
/** How many ticks before the socket is closed after the client is destroyed (#31) */
|
||||
static const int TICKS_BEFORE_CLOSE = 20;
|
||||
|
||||
|
|
@ -96,8 +99,8 @@ cClientHandle::cClientHandle(const cSocket * a_Socket, int a_ViewDistance) :
|
|||
m_ShouldCheckDownloaded(false),
|
||||
m_NumExplosionsThisTick(0),
|
||||
m_UniqueID(0),
|
||||
m_Locale("en_GB"),
|
||||
m_HasSentPlayerChunk(false)
|
||||
m_HasSentPlayerChunk(false),
|
||||
m_Locale("en_GB")
|
||||
{
|
||||
m_Protocol = new cProtocolRecognizer(this);
|
||||
|
||||
|
|
@ -555,12 +558,25 @@ void cClientHandle::HandlePluginMessage(const AString & a_Channel, const AString
|
|||
}
|
||||
else if (a_Channel == "REGISTER")
|
||||
{
|
||||
if (HasPluginChannel(a_Channel))
|
||||
{
|
||||
SendPluginMessage("UNREGISTER", a_Channel);
|
||||
return; // Can't register again if already taken - kinda defeats the point of plugin messaging!
|
||||
}
|
||||
|
||||
RegisterPluginChannels(BreakApartPluginChannels(a_Message));
|
||||
}
|
||||
else if (a_Channel == "UNREGISTER")
|
||||
{
|
||||
UnregisterPluginChannels(BreakApartPluginChannels(a_Message));
|
||||
}
|
||||
else if (!HasPluginChannel(a_Channel))
|
||||
{
|
||||
// Ignore if client sent something but didn't register the channel first
|
||||
LOGD("Player %s sent a plugin message on channel \"%s\", but didn't REGISTER it first", GetUsername().c_str(), a_Channel.c_str());
|
||||
SendPluginMessage("UNREGISTER", a_Channel);
|
||||
return;
|
||||
}
|
||||
|
||||
cPluginManager::Get()->CallHookPluginMessage(*this, a_Channel, a_Message);
|
||||
}
|
||||
|
|
@ -687,6 +703,14 @@ void cClientHandle::HandleLeftClick(int a_BlockX, int a_BlockY, int a_BlockZ, eB
|
|||
a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_Status
|
||||
);
|
||||
|
||||
m_NumBlockChangeInteractionsThisTick++;
|
||||
|
||||
if (!CheckBlockInteractionsRate())
|
||||
{
|
||||
Kick("Too many blocks were destroyed per unit time - hacked client?");
|
||||
return;
|
||||
}
|
||||
|
||||
cPluginManager * PlgMgr = cRoot::Get()->GetPluginManager();
|
||||
if (PlgMgr->CallHookPlayerLeftClick(*m_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_Status))
|
||||
{
|
||||
|
|
@ -694,12 +718,6 @@ void cClientHandle::HandleLeftClick(int a_BlockX, int a_BlockY, int a_BlockZ, eB
|
|||
m_Player->GetWorld()->SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, m_Player);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!CheckBlockInteractionsRate())
|
||||
{
|
||||
// Too many interactions per second, simply ignore. Probably a hacked client, so don't even send bak the block
|
||||
return;
|
||||
}
|
||||
|
||||
switch (a_Status)
|
||||
{
|
||||
|
|
@ -931,7 +949,7 @@ void cClientHandle::HandleRightClick(int a_BlockX, int a_BlockY, int a_BlockZ, e
|
|||
cBlockHandler * BlockHandler = cBlockInfo::GetHandler(BlockType);
|
||||
BlockHandler->OnCancelRightClick(ChunkInterface, *World, m_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace);
|
||||
|
||||
if (a_BlockFace > -1)
|
||||
if (a_BlockFace != BLOCK_FACE_NONE)
|
||||
{
|
||||
AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, a_BlockFace);
|
||||
World->SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, m_Player);
|
||||
|
|
@ -942,7 +960,7 @@ void cClientHandle::HandleRightClick(int a_BlockX, int a_BlockY, int a_BlockZ, e
|
|||
|
||||
if (!CheckBlockInteractionsRate())
|
||||
{
|
||||
LOGD("Too many block interactions, aborting placement");
|
||||
Kick("Too many blocks were placed/interacted with per unit time - hacked client?");
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -1453,7 +1471,7 @@ bool cClientHandle::HandleHandshake(const AString & a_Username)
|
|||
|
||||
|
||||
|
||||
void cClientHandle::HandleEntityAction(int a_EntityID, char a_ActionID)
|
||||
void cClientHandle::HandleEntityCrouch(int a_EntityID, bool a_IsCrouching)
|
||||
{
|
||||
if (a_EntityID != m_Player->GetUniqueID())
|
||||
{
|
||||
|
|
@ -1461,35 +1479,37 @@ void cClientHandle::HandleEntityAction(int a_EntityID, char a_ActionID)
|
|||
return;
|
||||
}
|
||||
|
||||
switch (a_ActionID)
|
||||
m_Player->SetCrouch(a_IsCrouching);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cClientHandle::HandleEntityLeaveBed(int a_EntityID)
|
||||
{
|
||||
if (a_EntityID != m_Player->GetUniqueID())
|
||||
{
|
||||
case 1: // Crouch
|
||||
{
|
||||
m_Player->SetCrouch(true);
|
||||
break;
|
||||
}
|
||||
case 2: // Uncrouch
|
||||
{
|
||||
m_Player->SetCrouch(false);
|
||||
break;
|
||||
}
|
||||
case 3: // Leave bed
|
||||
{
|
||||
m_Player->GetWorld()->BroadcastEntityAnimation(*m_Player, 2);
|
||||
break;
|
||||
}
|
||||
case 4: // Start sprinting
|
||||
{
|
||||
m_Player->SetSprint(true);
|
||||
break;
|
||||
}
|
||||
case 5: // Stop sprinting
|
||||
{
|
||||
m_Player->SetSprint(false);
|
||||
SendPlayerMaxSpeed();
|
||||
break;
|
||||
}
|
||||
// We should only receive entity actions from the entity that is performing the action
|
||||
return;
|
||||
}
|
||||
|
||||
m_Player->GetWorld()->BroadcastEntityAnimation(*m_Player, 2);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cClientHandle::HandleEntitySprinting(int a_EntityID, bool a_IsSprinting)
|
||||
{
|
||||
if (a_EntityID != m_Player->GetUniqueID())
|
||||
{
|
||||
// We should only receive entity actions from the entity that is performing the action
|
||||
return;
|
||||
}
|
||||
|
||||
m_Player->SetSprint(a_IsSprinting);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1619,28 +1639,12 @@ bool cClientHandle::CheckBlockInteractionsRate(void)
|
|||
{
|
||||
ASSERT(m_Player != NULL);
|
||||
ASSERT(m_Player->GetWorld() != NULL);
|
||||
/*
|
||||
// TODO: _X 2012_11_01: This needs a total re-thinking and rewriting
|
||||
int LastActionCnt = m_Player->GetLastBlockActionCnt();
|
||||
if ((m_Player->GetWorld()->GetTime() - m_Player->GetLastBlockActionTime()) < 0.1)
|
||||
|
||||
if (m_NumBlockChangeInteractionsThisTick > MAX_BLOCK_CHANGE_INTERACTIONS)
|
||||
{
|
||||
// Limit the number of block interactions per tick
|
||||
m_Player->SetLastBlockActionTime(); //Player tried to interact with a block. Reset last block interation time.
|
||||
m_Player->SetLastBlockActionCnt(LastActionCnt + 1);
|
||||
if (m_Player->GetLastBlockActionCnt() > MAXBLOCKCHANGEINTERACTIONS)
|
||||
{
|
||||
// Kick if more than MAXBLOCKCHANGEINTERACTIONS per tick
|
||||
LOGWARN("Player %s tried to interact with a block too quickly! (could indicate bot) Was Kicked.", m_Username.c_str());
|
||||
Kick("You're a baaaaaad boy!");
|
||||
return false;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_Player->SetLastBlockActionCnt(0); // Reset count
|
||||
m_Player->SetLastBlockActionTime(); // Player tried to interact with a block. Reset last block interation time.
|
||||
}
|
||||
*/
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -1713,8 +1717,9 @@ void cClientHandle::Tick(float a_Dt)
|
|||
}
|
||||
}
|
||||
|
||||
// Reset explosion counter:
|
||||
// Reset explosion & block change counters:
|
||||
m_NumExplosionsThisTick = 0;
|
||||
m_NumBlockChangeInteractionsThisTick = 0;
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -46,7 +46,6 @@ class cClientHandle : // tolua_export
|
|||
public cSocketThreads::cCallback
|
||||
{ // tolua_export
|
||||
public:
|
||||
static const int MAXBLOCKCHANGEINTERACTIONS = 20; // 5 didn't help, 10 still doesn't work in Creative, 20 seems to have done the trick
|
||||
|
||||
#if defined(ANDROID_NDK)
|
||||
static const int DEFAULT_VIEW_DISTANCE = 4; // The default ViewDistance (used when no value is set in Settings.ini)
|
||||
|
|
@ -188,7 +187,9 @@ public:
|
|||
void HandleChat (const AString & a_Message);
|
||||
void HandleCreativeInventory(short a_SlotNum, const cItem & a_HeldItem);
|
||||
void HandleDisconnect (const AString & a_Reason);
|
||||
void HandleEntityAction (int a_EntityID, char a_ActionID);
|
||||
void HandleEntityCrouch (int a_EntityID, bool a_IsCrouching);
|
||||
void HandleEntityLeaveBed (int a_EntityID);
|
||||
void HandleEntitySprinting (int a_EntityID, bool a_IsSprinting);
|
||||
|
||||
/** Called when the protocol handshake has been received (for protocol versions that support it;
|
||||
otherwise the first instant when a username is received).
|
||||
|
|
@ -319,6 +320,9 @@ private:
|
|||
|
||||
/** Number of explosions sent this tick */
|
||||
int m_NumExplosionsThisTick;
|
||||
|
||||
/** Number of place or break interactions this tick */
|
||||
int m_NumBlockChangeInteractionsThisTick;
|
||||
|
||||
static int s_ClientCount;
|
||||
int m_UniqueID;
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
|
||||
|
||||
// CraftingRecipes.cpp
|
||||
|
||||
// Interfaces to the cCraftingRecipes class representing the storage of crafting recipes
|
||||
|
|
@ -762,9 +762,94 @@ cCraftingRecipes::cRecipe * cCraftingRecipes::MatchRecipe(const cItem * a_Crafti
|
|||
Recipe->m_Ingredients.push_back(*itrS);
|
||||
}
|
||||
Recipe->m_Ingredients.insert(Recipe->m_Ingredients.end(), MatchedSlots.begin(), MatchedSlots.end());
|
||||
|
||||
// We use Recipe instead of a_Recipe because we want the wildcard ingredients' slot numbers as well, which was just added previously
|
||||
HandleFireworks(a_CraftingGrid, Recipe.get(), a_GridStride, a_OffsetX, a_OffsetY);
|
||||
|
||||
return Recipe.release();
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cCraftingRecipes::HandleFireworks(const cItem * a_CraftingGrid, cCraftingRecipes::cRecipe * a_Recipe, int a_GridStride, int a_OffsetX, int a_OffsetY)
|
||||
{
|
||||
// TODO: add support for more than one dye in the recipe
|
||||
// A manual and temporary solution (listing everything) is in crafting.txt for fade colours, but a programmatic solutions needs to be done for everything else
|
||||
|
||||
if (a_Recipe->m_Result.m_ItemType == E_ITEM_FIREWORK_ROCKET)
|
||||
{
|
||||
for (cRecipeSlots::const_iterator itr = a_Recipe->m_Ingredients.begin(); itr != a_Recipe->m_Ingredients.end(); ++itr)
|
||||
{
|
||||
switch (itr->m_Item.m_ItemType)
|
||||
{
|
||||
case E_ITEM_FIREWORK_STAR:
|
||||
{
|
||||
// Result was a rocket, found a star - copy star data to rocket data
|
||||
int GridID = (itr->x + a_OffsetX) + a_GridStride * (itr->y + a_OffsetY);
|
||||
a_Recipe->m_Result.m_FireworkItem.CopyFrom(a_CraftingGrid[GridID].m_FireworkItem);
|
||||
break;
|
||||
}
|
||||
case E_ITEM_GUNPOWDER:
|
||||
{
|
||||
// Gunpowder - increase flight time
|
||||
a_Recipe->m_Result.m_FireworkItem.m_FlightTimeInTicks += 20;
|
||||
break;
|
||||
}
|
||||
case E_ITEM_PAPER: break;
|
||||
default: LOG("Unexpected item in firework rocket a_Recipe, was the crafting file fireworks section changed?"); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (a_Recipe->m_Result.m_ItemType == E_ITEM_FIREWORK_STAR)
|
||||
{
|
||||
std::vector<int> DyeColours;
|
||||
bool FoundStar = false;
|
||||
|
||||
for (cRecipeSlots::const_iterator itr = a_Recipe->m_Ingredients.begin(); itr != a_Recipe->m_Ingredients.end(); ++itr)
|
||||
{
|
||||
switch (itr->m_Item.m_ItemType)
|
||||
{
|
||||
case E_ITEM_FIREWORK_STAR:
|
||||
{
|
||||
// Result was star, found another star - probably adding fade colours, but copy data over anyhow
|
||||
FoundStar = true;
|
||||
int GridID = (itr->x + a_OffsetX) + a_GridStride * (itr->y + a_OffsetY);
|
||||
a_Recipe->m_Result.m_FireworkItem.CopyFrom(a_CraftingGrid[GridID].m_FireworkItem);
|
||||
break;
|
||||
}
|
||||
case E_ITEM_DYE:
|
||||
{
|
||||
int GridID = (itr->x + a_OffsetX) + a_GridStride * (itr->y + a_OffsetY);
|
||||
DyeColours.push_back(cFireworkItem::GetVanillaColourCodeFromDye(a_CraftingGrid[GridID].m_ItemDamage));
|
||||
break;
|
||||
}
|
||||
case E_ITEM_GUNPOWDER: break;
|
||||
case E_ITEM_DIAMOND: a_Recipe->m_Result.m_FireworkItem.m_HasTrail = true; break;
|
||||
case E_ITEM_GLOWSTONE_DUST: a_Recipe->m_Result.m_FireworkItem.m_HasFlicker = true; break;
|
||||
|
||||
case E_ITEM_FIRE_CHARGE: a_Recipe->m_Result.m_FireworkItem.m_Type = 1; break;
|
||||
case E_ITEM_GOLD_NUGGET: a_Recipe->m_Result.m_FireworkItem.m_Type = 2; break;
|
||||
case E_ITEM_FEATHER: a_Recipe->m_Result.m_FireworkItem.m_Type = 4; break;
|
||||
case E_ITEM_HEAD: a_Recipe->m_Result.m_FireworkItem.m_Type = 3; break;
|
||||
default: LOG("Unexpected item in firework star a_Recipe, was the crafting file fireworks section changed?"); break; // ermahgerd BARD ardmins
|
||||
}
|
||||
}
|
||||
|
||||
if (FoundStar && (!DyeColours.empty()))
|
||||
{
|
||||
// Found a star and a dye? Fade colours.
|
||||
a_Recipe->m_Result.m_FireworkItem.m_FadeColours = DyeColours;
|
||||
}
|
||||
else if (!DyeColours.empty())
|
||||
{
|
||||
// Only dye? Normal colours.
|
||||
a_Recipe->m_Result.m_FireworkItem.m_Colours = DyeColours;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -165,6 +165,9 @@ protected:
|
|||
|
||||
/// Checks if the grid matches the specified recipe, offset by the specified offsets. Returns a matched cRecipe * if so, or NULL if not matching. Caller must delete the return value!
|
||||
cRecipe * MatchRecipe(const cItem * a_CraftingGrid, int a_GridWidth, int a_GridHeight, int a_GridStride, const cRecipe * a_Recipe, int a_OffsetX, int a_OffsetY);
|
||||
|
||||
/** Searches for anything firework related, and does the data setting if appropriate */
|
||||
void HandleFireworks(const cItem * a_CraftingGrid, cCraftingRecipes::cRecipe * a_Recipe, int a_GridStride, int a_OffsetX, int a_OffsetY);
|
||||
} ;
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -72,6 +72,9 @@ int cCuboid::GetVolume(void) const
|
|||
|
||||
bool cCuboid::DoesIntersect(const cCuboid & a_Other) const
|
||||
{
|
||||
ASSERT(IsSorted());
|
||||
ASSERT(a_Other.IsSorted());
|
||||
|
||||
// In order for cuboids to intersect, each of their coord intervals need to intersect
|
||||
return (
|
||||
DoIntervalsIntersect(p1.x, p2.x, a_Other.p1.x, a_Other.p2.x) &&
|
||||
|
|
@ -86,6 +89,9 @@ bool cCuboid::DoesIntersect(const cCuboid & a_Other) const
|
|||
|
||||
bool cCuboid::IsCompletelyInside(const cCuboid & a_Outer) const
|
||||
{
|
||||
ASSERT(IsSorted());
|
||||
ASSERT(a_Outer.IsSorted());
|
||||
|
||||
return (
|
||||
(p1.x >= a_Outer.p1.x) &&
|
||||
(p2.x <= a_Outer.p2.x) &&
|
||||
|
|
@ -197,3 +203,37 @@ bool cCuboid::IsSorted(void) const
|
|||
|
||||
|
||||
|
||||
|
||||
void cCuboid::Engulf(const Vector3i & a_Point)
|
||||
{
|
||||
if (a_Point.x < p1.x)
|
||||
{
|
||||
p1.x = a_Point.x;
|
||||
}
|
||||
else if (a_Point.x > p2.x)
|
||||
{
|
||||
p2.x = a_Point.x;
|
||||
}
|
||||
|
||||
if (a_Point.y < p1.y)
|
||||
{
|
||||
p1.y = a_Point.y;
|
||||
}
|
||||
else if (a_Point.y > p2.y)
|
||||
{
|
||||
p2.y = a_Point.y;
|
||||
}
|
||||
|
||||
if (a_Point.z < p1.z)
|
||||
{
|
||||
p1.z = a_Point.z;
|
||||
}
|
||||
else if (a_Point.z > p2.z)
|
||||
{
|
||||
p2.z = a_Point.z;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
11
src/Cuboid.h
11
src/Cuboid.h
|
|
@ -34,7 +34,8 @@ public:
|
|||
Works on unsorted cuboids, too. */
|
||||
int GetVolume(void) const;
|
||||
|
||||
/** Returns true if the cuboids have at least one voxel in common. Both coords are considered inclusive. */
|
||||
/** Returns true if the cuboids have at least one voxel in common. Both coords are considered inclusive.
|
||||
Assumes both cuboids are sorted. */
|
||||
bool DoesIntersect(const cCuboid & a_Other) const;
|
||||
|
||||
bool IsInside(const Vector3i & v) const
|
||||
|
|
@ -64,7 +65,8 @@ public:
|
|||
);
|
||||
}
|
||||
|
||||
/** Returns true if this cuboid is completely inside the specifie cuboid (in all 6 coords) */
|
||||
/** Returns true if this cuboid is completely inside the specifie cuboid (in all 6 coords).
|
||||
Assumes both cuboids are sorted. */
|
||||
bool IsCompletelyInside(const cCuboid & a_Outer) const;
|
||||
|
||||
/** Moves the cuboid by the specified offsets in each direction */
|
||||
|
|
@ -72,7 +74,7 @@ public:
|
|||
|
||||
/** Expands the cuboid by the specified amount in each direction.
|
||||
Works on unsorted cuboids as well.
|
||||
Note that this function doesn't check for underflows. */
|
||||
Note that this function doesn't check for underflows when using negative amounts. */
|
||||
void Expand(int a_SubMinX, int a_AddMaxX, int a_SubMinY, int a_AddMaxY, int a_SubMinZ, int a_AddMaxZ);
|
||||
|
||||
/** Clamps both X coords to the specified range. Works on unsorted cuboids, too. */
|
||||
|
|
@ -86,6 +88,9 @@ public:
|
|||
|
||||
/** Returns true if the coords are properly sorted (lesser in p1, greater in p2) */
|
||||
bool IsSorted(void) const;
|
||||
|
||||
/** If needed, expands the cuboid so that it contains the specified point. Assumes sorted. Doesn't contract. */
|
||||
void Engulf(const Vector3i & a_Point);
|
||||
} ;
|
||||
// tolua_end
|
||||
|
||||
|
|
|
|||
|
|
@ -276,6 +276,26 @@ inline eBlockFace RotateBlockFaceCW(eBlockFace a_BlockFace)
|
|||
|
||||
|
||||
|
||||
/** Returns the textual representation of the BlockFace constant. */
|
||||
inline AString BlockFaceToString(eBlockFace a_BlockFace)
|
||||
{
|
||||
switch (a_BlockFace)
|
||||
{
|
||||
case BLOCK_FACE_XM: return "BLOCK_FACE_XM";
|
||||
case BLOCK_FACE_XP: return "BLOCK_FACE_XP";
|
||||
case BLOCK_FACE_YM: return "BLOCK_FACE_YM";
|
||||
case BLOCK_FACE_YP: return "BLOCK_FACE_YP";
|
||||
case BLOCK_FACE_ZM: return "BLOCK_FACE_ZM";
|
||||
case BLOCK_FACE_ZP: return "BLOCK_FACE_ZP";
|
||||
case BLOCK_FACE_NONE: return "BLOCK_FACE_NONE";
|
||||
}
|
||||
return Printf("Unknown BLOCK_FACE: %d", a_BlockFace);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
inline bool IsValidBlock(int a_BlockType)
|
||||
{
|
||||
if (
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
class cFloater :
|
||||
public cEntity
|
||||
{
|
||||
typedef cFloater super;
|
||||
typedef cEntity super;
|
||||
|
||||
public:
|
||||
//tolua_end
|
||||
|
|
|
|||
|
|
@ -1031,9 +1031,9 @@ cMinecartWithChest::cMinecartWithChest(double a_X, double a_Y, double a_Z) :
|
|||
|
||||
|
||||
|
||||
void cMinecartWithChest::SetSlot(int a_Idx, const cItem & a_Item)
|
||||
void cMinecartWithChest::SetSlot(size_t a_Idx, const cItem & a_Item)
|
||||
{
|
||||
ASSERT((a_Idx >= 0) && (a_Idx < ARRAYCOUNT(m_Items)));
|
||||
ASSERT(a_Idx < ARRAYCOUNT(m_Items));
|
||||
|
||||
m_Items[a_Idx] = a_Item;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -122,7 +122,7 @@ public:
|
|||
const cItem & GetSlot(int a_Idx) const { return m_Items[a_Idx]; }
|
||||
cItem & GetSlot(int a_Idx) { return m_Items[a_Idx]; }
|
||||
|
||||
void SetSlot(int a_Idx, const cItem & a_Item);
|
||||
void SetSlot(size_t a_Idx, const cItem & a_Item);
|
||||
|
||||
protected:
|
||||
|
||||
|
|
@ -193,4 +193,4 @@ public:
|
|||
CLASS_PROTODEF(cMinecartWithHopper);
|
||||
|
||||
cMinecartWithHopper(double a_X, double a_Y, double a_Z);
|
||||
} ;
|
||||
} ;
|
||||
|
|
|
|||
|
|
@ -10,18 +10,11 @@
|
|||
#include "../BlockEntities/BlockEntity.h"
|
||||
#include "../GroupManager.h"
|
||||
#include "../Group.h"
|
||||
#include "../ChatColor.h"
|
||||
#include "../Item.h"
|
||||
#include "../Tracer.h"
|
||||
#include "../Root.h"
|
||||
#include "../OSSupport/Timer.h"
|
||||
#include "../MersenneTwister.h"
|
||||
#include "../Chunk.h"
|
||||
#include "../Items/ItemHandler.h"
|
||||
|
||||
#include "../Vector3d.h"
|
||||
#include "../Vector3f.h"
|
||||
|
||||
#include "inifile/iniFile.h"
|
||||
#include "json/json.h"
|
||||
|
||||
|
|
@ -45,10 +38,7 @@ cPlayer::cPlayer(cClientHandle* a_Client, const AString & a_PlayerName)
|
|||
, m_Inventory(*this)
|
||||
, m_CurrentWindow(NULL)
|
||||
, m_InventoryWindow(NULL)
|
||||
, m_TimeLastPickupCheck(0.f)
|
||||
, m_Color('-')
|
||||
, m_LastBlockActionTime(0)
|
||||
, m_LastBlockActionCnt(0)
|
||||
, m_GameMode(eGameMode_NotSet)
|
||||
, m_IP("")
|
||||
, m_ClientHandle(a_Client)
|
||||
|
|
@ -86,7 +76,6 @@ cPlayer::cPlayer(cClientHandle* a_Client, const AString & a_PlayerName)
|
|||
m_LastPlayerListTime = t1.GetNowTime();
|
||||
|
||||
m_TimeLastTeleportPacket = 0;
|
||||
m_TimeLastPickupCheck = 0;
|
||||
|
||||
m_PlayerName = a_PlayerName;
|
||||
m_bDirtyPosition = true; // So chunks are streamed to player at spawn
|
||||
|
|
@ -1047,27 +1036,6 @@ void cPlayer::CloseWindowIfID(char a_WindowID, bool a_CanRefuse)
|
|||
|
||||
|
||||
|
||||
void cPlayer::SetLastBlockActionTime()
|
||||
{
|
||||
if (m_World != NULL)
|
||||
{
|
||||
m_LastBlockActionTime = m_World->GetWorldAge() / 20.0f;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cPlayer::SetLastBlockActionCnt( int a_LastBlockActionCnt )
|
||||
{
|
||||
m_LastBlockActionCnt = a_LastBlockActionCnt;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cPlayer::SetGameMode(eGameMode a_GameMode)
|
||||
{
|
||||
if ((a_GameMode < gmMin) || (a_GameMode >= gmMax))
|
||||
|
|
|
|||
|
|
@ -50,7 +50,7 @@ public:
|
|||
/// Returns the curently equipped weapon; empty item if none
|
||||
virtual cItem GetEquippedWeapon(void) const override { return m_Inventory.GetEquippedItem(); }
|
||||
|
||||
/// Returns the currently equipped helmet; empty item if nonte
|
||||
/// Returns the currently equipped helmet; empty item if none
|
||||
virtual cItem GetEquippedHelmet(void) const override { return m_Inventory.GetEquippedHelmet(); }
|
||||
|
||||
/// Returns the currently equipped chestplate; empty item if none
|
||||
|
|
@ -165,11 +165,6 @@ public:
|
|||
// tolua_end
|
||||
|
||||
void SetIP(const AString & a_IP);
|
||||
|
||||
float GetLastBlockActionTime() { return m_LastBlockActionTime; }
|
||||
int GetLastBlockActionCnt() { return m_LastBlockActionCnt; }
|
||||
void SetLastBlockActionCnt( int );
|
||||
void SetLastBlockActionTime();
|
||||
|
||||
// Sets the current gamemode, doesn't check validity, doesn't send update packets to client
|
||||
void LoginSetGameMode(eGameMode a_GameMode);
|
||||
|
|
@ -416,12 +411,8 @@ protected:
|
|||
cWindow * m_CurrentWindow;
|
||||
cWindow * m_InventoryWindow;
|
||||
|
||||
float m_TimeLastPickupCheck;
|
||||
|
||||
char m_Color;
|
||||
|
||||
float m_LastBlockActionTime;
|
||||
int m_LastBlockActionCnt;
|
||||
eGameMode m_GameMode;
|
||||
AString m_IP;
|
||||
|
||||
|
|
|
|||
|
|
@ -214,7 +214,7 @@ cProjectileEntity::cProjectileEntity(eKind a_Kind, cEntity * a_Creator, const Ve
|
|||
|
||||
|
||||
|
||||
cProjectileEntity * cProjectileEntity::Create(eKind a_Kind, cEntity * a_Creator, double a_X, double a_Y, double a_Z, const Vector3d * a_Speed)
|
||||
cProjectileEntity * cProjectileEntity::Create(eKind a_Kind, cEntity * a_Creator, double a_X, double a_Y, double a_Z, const cItem & a_Item, const Vector3d * a_Speed)
|
||||
{
|
||||
Vector3d Speed;
|
||||
if (a_Speed != NULL)
|
||||
|
|
@ -231,8 +231,15 @@ cProjectileEntity * cProjectileEntity::Create(eKind a_Kind, cEntity * a_Creator,
|
|||
case pkGhastFireball: return new cGhastFireballEntity (a_Creator, a_X, a_Y, a_Z, Speed);
|
||||
case pkFireCharge: return new cFireChargeEntity (a_Creator, a_X, a_Y, a_Z, Speed);
|
||||
case pkExpBottle: return new cExpBottleEntity (a_Creator, a_X, a_Y, a_Z, Speed);
|
||||
case pkFirework: return new cFireworkEntity (a_Creator, a_X, a_Y, a_Z );
|
||||
// TODO: the rest
|
||||
case pkFirework:
|
||||
{
|
||||
if (a_Item.m_FireworkItem.m_Colours.empty())
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return new cFireworkEntity(a_Creator, a_X, a_Y, a_Z, a_Item);
|
||||
}
|
||||
}
|
||||
|
||||
LOGWARNING("%s: Unknown projectile kind: %d", __FUNCTION__, a_Kind);
|
||||
|
|
@ -276,6 +283,7 @@ AString cProjectileEntity::GetMCAClassName(void) const
|
|||
case pkExpBottle: return "ThrownExpBottle";
|
||||
case pkSplashPotion: return "ThrownPotion";
|
||||
case pkWitherSkull: return "WitherSkull";
|
||||
case pkFirework: return "Firework";
|
||||
case pkFishingFloat: return ""; // Unknown, perhaps MC doesn't save this?
|
||||
}
|
||||
ASSERT(!"Unhandled projectile entity kind!");
|
||||
|
|
@ -693,8 +701,10 @@ void cExpBottleEntity::OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_H
|
|||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// cFireworkEntity :
|
||||
|
||||
cFireworkEntity::cFireworkEntity(cEntity * a_Creator, double a_X, double a_Y, double a_Z) :
|
||||
super(pkFirework, a_Creator, a_X, a_Y, a_Z, 0.25, 0.25)
|
||||
cFireworkEntity::cFireworkEntity(cEntity * a_Creator, double a_X, double a_Y, double a_Z, const cItem & a_Item) :
|
||||
super(pkFirework, a_Creator, a_X, a_Y, a_Z, 0.25, 0.25),
|
||||
m_ExplodeTimer(0),
|
||||
m_FireworkItem(a_Item)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
@ -702,30 +712,20 @@ super(pkFirework, a_Creator, a_X, a_Y, a_Z, 0.25, 0.25)
|
|||
|
||||
|
||||
|
||||
void cFireworkEntity::OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace)
|
||||
{
|
||||
if ((a_HitFace != BLOCK_FACE_BOTTOM) && (a_HitFace != BLOCK_FACE_NONE))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
SetSpeed(0, 0, 0);
|
||||
SetPosition(GetPosX(), GetPosY() - 0.5, GetPosZ());
|
||||
|
||||
m_IsInGround = true;
|
||||
|
||||
BroadcastMovementUpdate();
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cFireworkEntity::HandlePhysics(float a_Dt, cChunk & a_Chunk)
|
||||
{
|
||||
int RelX = POSX_TOINT - a_Chunk.GetPosX() * cChunkDef::Width;
|
||||
int RelZ = POSZ_TOINT - a_Chunk.GetPosZ() * cChunkDef::Width;
|
||||
int PosY = POSY_TOINT;
|
||||
|
||||
if ((PosY < 0) || (PosY >= cChunkDef::Height))
|
||||
{
|
||||
goto setspeed;
|
||||
}
|
||||
|
||||
if (m_IsInGround)
|
||||
{
|
||||
if (a_Chunk.GetBlock((int)GetPosX(), (int)GetPosY() + 1, (int)GetPosZ()) == E_BLOCK_AIR)
|
||||
if (a_Chunk.GetBlock(RelX, POSY_TOINT + 1, RelZ) == E_BLOCK_AIR)
|
||||
{
|
||||
m_IsInGround = false;
|
||||
}
|
||||
|
|
@ -734,28 +734,35 @@ void cFireworkEntity::HandlePhysics(float a_Dt, cChunk & a_Chunk)
|
|||
return;
|
||||
}
|
||||
}
|
||||
|
||||
Vector3d PerTickSpeed = GetSpeed() / 20;
|
||||
Vector3d Pos = GetPosition();
|
||||
|
||||
// Trace the tick's worth of movement as a line:
|
||||
Vector3d NextPos = Pos + PerTickSpeed;
|
||||
cProjectileTracerCallback TracerCallback(this);
|
||||
if (!cLineBlockTracer::Trace(*m_World, TracerCallback, Pos, NextPos))
|
||||
else
|
||||
{
|
||||
// Something has been hit, abort all other processing
|
||||
return;
|
||||
if (a_Chunk.GetBlock(RelX, POSY_TOINT + 1, RelZ) != E_BLOCK_AIR)
|
||||
{
|
||||
OnHitSolidBlock(GetPosition(), BLOCK_FACE_YM);
|
||||
return;
|
||||
}
|
||||
}
|
||||
// The tracer also checks the blocks for slowdown blocks - water and lava - and stores it for later in its SlowdownCoeff
|
||||
|
||||
// Update the position:
|
||||
SetPosition(NextPos);
|
||||
setspeed:
|
||||
AddSpeedY(1);
|
||||
AddPosition(GetSpeed() * (a_Dt / 1000));
|
||||
}
|
||||
|
||||
// Add slowdown and gravity effect to the speed:
|
||||
Vector3d NewSpeed(GetSpeed());
|
||||
NewSpeed.y += 2;
|
||||
NewSpeed *= TracerCallback.GetSlowdownCoeff();
|
||||
SetSpeed(NewSpeed);
|
||||
|
||||
|
||||
|
||||
|
||||
void cFireworkEntity::Tick(float a_Dt, cChunk & a_Chunk)
|
||||
{
|
||||
super::Tick(a_Dt, a_Chunk);
|
||||
|
||||
if (m_ExplodeTimer == m_FireworkItem.m_FireworkItem.m_FlightTimeInTicks)
|
||||
{
|
||||
m_World->BroadcastEntityStatus(*this, ENTITY_STATUS_FIREWORK_EXPLODE);
|
||||
Destroy();
|
||||
}
|
||||
|
||||
m_ExplodeTimer++;
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ public:
|
|||
cProjectileEntity(eKind a_Kind, cEntity * a_Creator, double a_X, double a_Y, double a_Z, double a_Width, double a_Height);
|
||||
cProjectileEntity(eKind a_Kind, cEntity * a_Creator, const Vector3d & a_Pos, const Vector3d & a_Speed, double a_Width, double a_Height);
|
||||
|
||||
static cProjectileEntity * Create(eKind a_Kind, cEntity * a_Creator, double a_X, double a_Y, double a_Z, const Vector3d * a_Speed = NULL);
|
||||
static cProjectileEntity * Create(eKind a_Kind, cEntity * a_Creator, double a_X, double a_Y, double a_Z, const cItem & a_Item, const Vector3d * a_Speed = NULL);
|
||||
|
||||
/// Called by the physics blocktracer when the entity hits a solid block, the hit position and the face hit (BLOCK_FACE_) is given
|
||||
virtual void OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace);
|
||||
|
|
@ -305,13 +305,19 @@ public:
|
|||
|
||||
CLASS_PROTODEF(cFireworkEntity);
|
||||
|
||||
cFireworkEntity(cEntity * a_Creator, double a_X, double a_Y, double a_Z);
|
||||
cFireworkEntity(cEntity * a_Creator, double a_X, double a_Y, double a_Z, const cItem & a_Item);
|
||||
const cItem & GetItem(void) const { return m_FireworkItem; }
|
||||
|
||||
protected:
|
||||
|
||||
// cProjectileEntity overrides:
|
||||
virtual void OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace) override;
|
||||
virtual void HandlePhysics(float a_Dt, cChunk & a_Chunk) override;
|
||||
virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
|
||||
|
||||
private:
|
||||
|
||||
int m_ExplodeTimer;
|
||||
cItem m_FireworkItem;
|
||||
|
||||
// tolua_begin
|
||||
|
||||
|
|
|
|||
|
|
@ -8,10 +8,9 @@
|
|||
|
||||
|
||||
|
||||
cTNTEntity::cTNTEntity(double a_X, double a_Y, double a_Z, double a_FuseTimeInSec) :
|
||||
cTNTEntity::cTNTEntity(double a_X, double a_Y, double a_Z, int a_FuseTicks) :
|
||||
super(etTNT, a_X, a_Y, a_Z, 0.98, 0.98),
|
||||
m_Counter(0),
|
||||
m_MaxFuseTime(a_FuseTimeInSec)
|
||||
m_FuseTicks(a_FuseTicks)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
@ -19,10 +18,9 @@ cTNTEntity::cTNTEntity(double a_X, double a_Y, double a_Z, double a_FuseTimeInSe
|
|||
|
||||
|
||||
|
||||
cTNTEntity::cTNTEntity(const Vector3d & a_Pos, double a_FuseTimeInSec) :
|
||||
cTNTEntity::cTNTEntity(const Vector3d & a_Pos, int a_FuseTicks) :
|
||||
super(etTNT, a_Pos.x, a_Pos.y, a_Pos.z, 0.98, 0.98),
|
||||
m_Counter(0),
|
||||
m_MaxFuseTime(a_FuseTimeInSec)
|
||||
m_FuseTicks(a_FuseTicks)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
@ -42,18 +40,27 @@ void cTNTEntity::SpawnOn(cClientHandle & a_ClientHandle)
|
|||
|
||||
|
||||
|
||||
void cTNTEntity::Explode(void)
|
||||
{
|
||||
m_FuseTicks = 0;
|
||||
Destroy(true);
|
||||
LOGD("BOOM at {%f,%f,%f}", GetPosX(), GetPosY(), GetPosZ());
|
||||
m_World->DoExplosionAt(4.0, GetPosX() + 0.49, GetPosY() + 0.49, GetPosZ() + 0.49, true, esPrimedTNT, this);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cTNTEntity::Tick(float a_Dt, cChunk & a_Chunk)
|
||||
{
|
||||
super::Tick(a_Dt, a_Chunk);
|
||||
BroadcastMovementUpdate();
|
||||
float delta_time = a_Dt / 1000; // Convert miliseconds to seconds
|
||||
m_Counter += delta_time;
|
||||
if (m_Counter > m_MaxFuseTime) // Check if we go KABOOOM
|
||||
|
||||
m_FuseTicks -= 1;
|
||||
if (m_FuseTicks <= 0)
|
||||
{
|
||||
Destroy(true);
|
||||
LOGD("BOOM at {%f,%f,%f}", GetPosX(), GetPosY(), GetPosZ());
|
||||
m_World->DoExplosionAt(4.0, GetPosX() + 0.49, GetPosY() + 0.49, GetPosZ() + 0.49, true, esPrimedTNT, this);
|
||||
return;
|
||||
Explode();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -16,19 +16,28 @@ public:
|
|||
// tolua_end
|
||||
CLASS_PROTODEF(cTNTEntity);
|
||||
|
||||
cTNTEntity(double a_X, double a_Y, double a_Z, double a_FuseTimeInSec);
|
||||
cTNTEntity(const Vector3d & a_Pos, double a_FuseTimeInSec);
|
||||
cTNTEntity(double a_X, double a_Y, double a_Z, int a_FuseTicks = 80);
|
||||
cTNTEntity(const Vector3d & a_Pos, int a_FuseTicks = 80);
|
||||
|
||||
// cEntity overrides:
|
||||
virtual void SpawnOn(cClientHandle & a_ClientHandle) override;
|
||||
virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
|
||||
|
||||
double GetCounterTime(void) const { return m_Counter; } // tolua_export
|
||||
double GetMaxFuseTime(void) const { return m_MaxFuseTime; } // tolua_export
|
||||
|
||||
// tolua_begin
|
||||
|
||||
/** Explode the tnt */
|
||||
void Explode(void);
|
||||
|
||||
/** Returns the fuse ticks until the tnt will explode */
|
||||
int GetFuseTicks(void) const { return m_FuseTicks; }
|
||||
|
||||
/** Set the fuse ticks until the tnt will explode */
|
||||
void SetFuseTicks(int a_FuseTicks) { m_FuseTicks = a_FuseTicks; }
|
||||
|
||||
// tolua_end
|
||||
|
||||
protected:
|
||||
double m_Counter; ///< How much time has elapsed since the object was created, in seconds
|
||||
double m_MaxFuseTime; ///< How long the fuse is, in seconds
|
||||
int m_FuseTicks; ///< How much ticks is left, while the tnt will explode
|
||||
}; // tolua_export
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@
|
|||
#include "EndGen.h"
|
||||
#include "MineShafts.h"
|
||||
#include "Noise3DGenerator.h"
|
||||
#include "POCPieceGenerator.h"
|
||||
#include "Ravines.h"
|
||||
|
||||
|
||||
|
|
@ -364,6 +365,10 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
|
|||
{
|
||||
m_FinishGens.push_back(new cStructGenOreNests(Seed));
|
||||
}
|
||||
else if (NoCaseCompare(*itr, "POCPieces") == 0)
|
||||
{
|
||||
m_FinishGens.push_back(new cPOCPieceGenerator(Seed));
|
||||
}
|
||||
else if (NoCaseCompare(*itr, "PreSimulator") == 0)
|
||||
{
|
||||
m_FinishGens.push_back(new cFinishGenPreSimulator);
|
||||
|
|
|
|||
|
|
@ -69,6 +69,8 @@ public:
|
|||
m_BoundingBox(a_BoundingBox)
|
||||
{
|
||||
}
|
||||
|
||||
virtual ~cMineShaft() {}
|
||||
|
||||
/// Returns true if this mineshaft intersects the specified cuboid
|
||||
bool DoesIntersect(const cCuboid & a_Other)
|
||||
|
|
|
|||
|
|
@ -0,0 +1,270 @@
|
|||
|
||||
// POCPieceGenerator.cpp
|
||||
|
||||
// Implements the cPOCPieceGenerator class representing a Proof-Of_Concept structure generator using the cPieceGenerator technique
|
||||
// The generator generates a maze of rooms at {0, 50, 0}
|
||||
|
||||
#include "Globals.h"
|
||||
#include "POCPieceGenerator.h"
|
||||
#include "ChunkDesc.h"
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/** POC pieces are simple boxes that have connectors in the middle of their walls.
|
||||
Each wall has one connector, there are 3 connector types that get assigned semi-randomly.
|
||||
The piece also knows how to imprint itself in a cChunkDesc, each piece has a different color glass
|
||||
and each connector is uses a different color wool frame. */
|
||||
class cPOCPiece :
|
||||
public cPiece
|
||||
{
|
||||
public:
|
||||
cPOCPiece(int a_SizeXZ, int a_Height) :
|
||||
m_SizeXZ(a_SizeXZ),
|
||||
m_Height(a_Height)
|
||||
{
|
||||
m_Connectors.push_back(cConnector(m_SizeXZ / 2, a_Height / 2, 0, 0, BLOCK_FACE_ZM));
|
||||
m_Connectors.push_back(cConnector(m_SizeXZ / 2, a_Height / 2, m_SizeXZ - 1, 1, BLOCK_FACE_ZP));
|
||||
m_Connectors.push_back(cConnector(0, a_Height / 2, m_SizeXZ / 2, 2, BLOCK_FACE_XM));
|
||||
m_Connectors.push_back(cConnector(m_SizeXZ - 1, a_Height - 1, m_SizeXZ / 2, m_SizeXZ % 3, BLOCK_FACE_XP));
|
||||
}
|
||||
|
||||
|
||||
/** Imprints the piece in the specified chunk. Assumes they intersect. */
|
||||
void ImprintInChunk(cChunkDesc & a_ChunkDesc, const Vector3i & a_Pos, int a_NumCCWRotations)
|
||||
{
|
||||
int BlockX = a_ChunkDesc.GetChunkX() * cChunkDef::Width;
|
||||
int BlockZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width;
|
||||
Vector3i Min = a_Pos;
|
||||
Min.Move(-BlockX, 0, -BlockZ);
|
||||
Vector3i Max = Min;
|
||||
Max.Move(m_SizeXZ - 1, m_Height - 1, m_SizeXZ - 1);
|
||||
ASSERT(Min.x < cChunkDef::Width);
|
||||
ASSERT(Min.z < cChunkDef::Width);
|
||||
ASSERT(Max.x >= 0);
|
||||
ASSERT(Max.z >= 0);
|
||||
if (Min.x >= 0)
|
||||
{
|
||||
// Draw the XM wall:
|
||||
a_ChunkDesc.FillRelCuboid(Min.x, Min.x, Min.y, Max.y, Min.z, Max.z, E_BLOCK_STAINED_GLASS, m_SizeXZ % 16);
|
||||
}
|
||||
if (Min.z >= 0)
|
||||
{
|
||||
// Draw the ZM wall:
|
||||
a_ChunkDesc.FillRelCuboid(Min.x, Max.x, Min.y, Max.y, Min.z, Min.z, E_BLOCK_STAINED_GLASS, m_SizeXZ % 16);
|
||||
}
|
||||
if (Max.x < cChunkDef::Width)
|
||||
{
|
||||
// Draw the XP wall:
|
||||
a_ChunkDesc.FillRelCuboid(Max.x, Max.x, Min.y, Max.y, Min.z, Max.z, E_BLOCK_STAINED_GLASS, m_SizeXZ % 16);
|
||||
}
|
||||
if (Max.z < cChunkDef::Width)
|
||||
{
|
||||
// Draw the ZP wall:
|
||||
a_ChunkDesc.FillRelCuboid(Min.x, Max.x, Min.y, Max.y, Max.z, Max.z, E_BLOCK_STAINED_GLASS, m_SizeXZ % 16);
|
||||
}
|
||||
|
||||
// Draw all the connectors:
|
||||
for (cConnectors::const_iterator itr = m_Connectors.begin(), end = m_Connectors.end(); itr != end; ++itr)
|
||||
{
|
||||
cConnector Conn = cPiece::RotateMoveConnector(*itr, a_NumCCWRotations, a_Pos.x, a_Pos.y, a_Pos.z);
|
||||
Conn.m_Pos.Move(-BlockX, 0, -BlockZ);
|
||||
if (
|
||||
(Conn.m_Pos.x >= 0) && (Conn.m_Pos.x < cChunkDef::Width) &&
|
||||
(Conn.m_Pos.z >= 0) && (Conn.m_Pos.z < cChunkDef::Width)
|
||||
)
|
||||
{
|
||||
a_ChunkDesc.SetBlockTypeMeta(Conn.m_Pos.x, Conn.m_Pos.y, Conn.m_Pos.z, E_BLOCK_WOOL, itr->m_Type % 16);
|
||||
}
|
||||
|
||||
/*
|
||||
// TODO: Frame the connectors
|
||||
switch (itr->m_Direction)
|
||||
{
|
||||
case BLOCK_FACE_XM:
|
||||
case BLOCK_FACE_XP:
|
||||
{
|
||||
// TODO
|
||||
break;
|
||||
}
|
||||
|
||||
case BLOCK_FACE_ZM:
|
||||
case BLOCK_FACE_ZP:
|
||||
{
|
||||
// TODO
|
||||
break;
|
||||
}
|
||||
}
|
||||
*/
|
||||
} // for itr - m_Connectors[]
|
||||
}
|
||||
|
||||
protected:
|
||||
int m_SizeXZ;
|
||||
int m_Height;
|
||||
cConnectors m_Connectors;
|
||||
|
||||
// cPiece overrides:
|
||||
virtual cConnectors GetConnectors(void) const override
|
||||
{
|
||||
return m_Connectors;
|
||||
}
|
||||
|
||||
virtual Vector3i GetSize(void) const override
|
||||
{
|
||||
return Vector3i(m_SizeXZ, m_Height, m_SizeXZ);
|
||||
}
|
||||
|
||||
virtual cCuboid GetHitBox(void) const override
|
||||
{
|
||||
return cCuboid(0, 0, 0, m_SizeXZ - 1, m_Height - 1, m_SizeXZ - 1);
|
||||
}
|
||||
|
||||
virtual bool CanRotateCCW(int a_NumRotations) const override
|
||||
{
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*
|
||||
static void DebugPieces(const cPlacedPieces & a_Pieces)
|
||||
{
|
||||
size_t idx = 0;
|
||||
for (cPlacedPieces::const_iterator itr = a_Pieces.begin(), end = a_Pieces.end(); itr != end; ++itr, ++idx)
|
||||
{
|
||||
const cCuboid & HitBox = (*itr)->GetHitBox();
|
||||
printf(" %u: %d rotations, {%d - %d, %d - %d}\n",
|
||||
idx, (*itr)->GetNumCCWRotations(),
|
||||
HitBox.p1.x, HitBox.p2.x, HitBox.p1.z, HitBox.p2.z
|
||||
);
|
||||
} // for itr - a_Pieces[]
|
||||
}
|
||||
//*/
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// cPOCPieceGenerator:
|
||||
|
||||
cPOCPieceGenerator::cPOCPieceGenerator(int a_Seed) :
|
||||
m_Seed(a_Seed)
|
||||
{
|
||||
// Prepare a vector of available pieces:
|
||||
m_AvailPieces.push_back(new cPOCPiece(5, 3));
|
||||
m_AvailPieces.push_back(new cPOCPiece(7, 5));
|
||||
m_AvailPieces.push_back(new cPOCPiece(9, 5));
|
||||
m_AvailPieces.push_back(new cPOCPiece(5, 7));
|
||||
|
||||
// Generate the structure:
|
||||
cBFSPieceGenerator Gen(*this, a_Seed);
|
||||
Gen.PlacePieces(0, 50, 0, 6, m_Pieces);
|
||||
|
||||
// DebugPieces(m_Pieces);
|
||||
|
||||
// Get the smallest cuboid encompassing the entire generated structure:
|
||||
cCuboid Bounds(0, 50, 0, 0, 50, 0);
|
||||
for (cPlacedPieces::const_iterator itr = m_Pieces.begin(), end = m_Pieces.end(); itr != end; ++itr)
|
||||
{
|
||||
Vector3i MinCoords = (*itr)->GetCoords();
|
||||
Bounds.Engulf(MinCoords);
|
||||
Bounds.Engulf(MinCoords + (*itr)->GetPiece().GetSize());
|
||||
} // for itr - m_Pieces[]
|
||||
m_Bounds = Bounds;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
cPOCPieceGenerator::~cPOCPieceGenerator()
|
||||
{
|
||||
cPieceGenerator::FreePieces(m_Pieces);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cPOCPieceGenerator::GenFinish(cChunkDesc & a_ChunkDesc)
|
||||
{
|
||||
int BlockX = a_ChunkDesc.GetChunkX() * cChunkDef::Width;
|
||||
int BlockZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width;
|
||||
if (
|
||||
(BlockX + 16 < m_Bounds.p1.x) || (BlockX > m_Bounds.p2.x) || // X coords out of bounds of the generated structure
|
||||
(BlockZ + 16 < m_Bounds.p1.z) || (BlockZ > m_Bounds.p2.z) // Z coords out of bounds of the generated structure
|
||||
)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// Imprint each piece in the chunk:
|
||||
for (cPlacedPieces::const_iterator itr = m_Pieces.begin(), end = m_Pieces.end(); itr != end; ++itr)
|
||||
{
|
||||
const Vector3i & Pos = (*itr)->GetCoords();
|
||||
Vector3i Size = (*itr)->GetPiece().GetSize();
|
||||
if (((*itr)->GetNumCCWRotations() % 2) == 1)
|
||||
{
|
||||
std::swap(Size.x, Size.z);
|
||||
}
|
||||
if (
|
||||
(Pos.x >= BlockX + 16) || (Pos.x + Size.x - 1 < BlockX) ||
|
||||
(Pos.z >= BlockZ + 16) || (Pos.z + Size.z - 1 < BlockZ)
|
||||
)
|
||||
{
|
||||
// This piece doesn't intersect the chunk
|
||||
continue;
|
||||
}
|
||||
|
||||
((cPOCPiece &)(*itr)->GetPiece()).ImprintInChunk(a_ChunkDesc, Pos, (*itr)->GetNumCCWRotations());
|
||||
} // for itr - m_Pieces[]
|
||||
a_ChunkDesc.UpdateHeightmap();
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
cPieces cPOCPieceGenerator::GetPiecesWithConnector(int a_ConnectorType)
|
||||
{
|
||||
// Each piece has each connector
|
||||
return m_AvailPieces;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
cPieces cPOCPieceGenerator::GetStartingPieces(void)
|
||||
{
|
||||
// Any piece can be a starting piece
|
||||
return m_AvailPieces;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cPOCPieceGenerator::PiecePlaced(const cPiece & a_Piece)
|
||||
{
|
||||
UNUSED(a_Piece);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cPOCPieceGenerator::Reset(void)
|
||||
{
|
||||
// Nothing needed
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
|
||||
// POCPieceGenerator.h
|
||||
|
||||
// Declares the cPOCPieceGenerator class representing a Proof-Of_Concept structure generator using the cPieceGenerator technique
|
||||
// The generator generates a maze of rooms at {0, 100, 0}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "PieceGenerator.h"
|
||||
#include "ComposableGenerator.h"
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
class cPOCPieceGenerator :
|
||||
public cFinishGen,
|
||||
protected cPiecePool
|
||||
{
|
||||
public:
|
||||
cPOCPieceGenerator(int a_Seed);
|
||||
~cPOCPieceGenerator();
|
||||
|
||||
protected:
|
||||
int m_Seed;
|
||||
|
||||
/** The pieces from which the generated structure is built. */
|
||||
cPieces m_AvailPieces;
|
||||
|
||||
/** The placed pieces of the generated structure. */
|
||||
cPlacedPieces m_Pieces;
|
||||
|
||||
/** Bounds of the complete structure, to save on processing outside chunks. */
|
||||
cCuboid m_Bounds;
|
||||
|
||||
|
||||
// cFinishGen overrides:
|
||||
virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
|
||||
|
||||
// cPiecePool overrides:
|
||||
virtual cPieces GetPiecesWithConnector(int a_ConnectorType) override;
|
||||
virtual cPieces GetStartingPieces(void) override;
|
||||
virtual void PiecePlaced(const cPiece & a_Piece) override;
|
||||
virtual void Reset(void) override;
|
||||
} ;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,626 @@
|
|||
|
||||
// PieceGenerator.cpp
|
||||
|
||||
// Implements the cBFSPieceGenerator class and cDFSPieceGenerator class
|
||||
// representing base classes for generating structures composed of individual "pieces"
|
||||
|
||||
#include "Globals.h"
|
||||
#include "PieceGenerator.h"
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#ifdef SELF_TEST
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Self-test:
|
||||
|
||||
static class cPieceGeneratorSelfTest :
|
||||
public cPiecePool
|
||||
{
|
||||
public:
|
||||
cPieceGeneratorSelfTest(void)
|
||||
{
|
||||
// Prepare the internal state:
|
||||
InitializePieces();
|
||||
|
||||
// Generate:
|
||||
cBFSPieceGenerator Gen(*this, 0);
|
||||
cPlacedPieces OutPieces;
|
||||
Gen.PlacePieces(500, 50, 500, 3, OutPieces);
|
||||
|
||||
// Print out the pieces:
|
||||
printf("OutPieces.size() = %u\n", OutPieces.size());
|
||||
size_t idx = 0;
|
||||
for (cPlacedPieces::const_iterator itr = OutPieces.begin(), end = OutPieces.end(); itr != end; ++itr, ++idx)
|
||||
{
|
||||
const Vector3i & Coords = (*itr)->GetCoords();
|
||||
cCuboid Hitbox = (*itr)->GetHitBox();
|
||||
Hitbox.Sort();
|
||||
printf("%u: {%d, %d, %d}, rot %d, hitbox {%d, %d, %d} - {%d, %d, %d} (%d * %d * %d)\n", idx,
|
||||
Coords.x, Coords.y, Coords.z,
|
||||
(*itr)->GetNumCCWRotations(),
|
||||
Hitbox.p1.x, Hitbox.p1.y, Hitbox.p1.z,
|
||||
Hitbox.p2.x, Hitbox.p2.y, Hitbox.p2.z,
|
||||
Hitbox.DifX() + 1, Hitbox.DifY() + 1, Hitbox.DifZ() + 1
|
||||
);
|
||||
} // itr - OutPieces[]
|
||||
printf("Done.\n");
|
||||
|
||||
// Free the placed pieces properly:
|
||||
Gen.FreePieces(OutPieces);
|
||||
}
|
||||
|
||||
~cPieceGeneratorSelfTest()
|
||||
{
|
||||
// Dealloc all the pieces:
|
||||
for (cPieces::iterator itr = m_Pieces.begin(), end = m_Pieces.end(); itr != end; ++itr)
|
||||
{
|
||||
delete *itr;
|
||||
}
|
||||
m_Pieces.clear();
|
||||
}
|
||||
|
||||
protected:
|
||||
class cTestPiece :
|
||||
public cPiece
|
||||
{
|
||||
int m_Size;
|
||||
public:
|
||||
cTestPiece(int a_Size) :
|
||||
m_Size(a_Size)
|
||||
{
|
||||
}
|
||||
|
||||
virtual cConnectors GetConnectors(void) const override
|
||||
{
|
||||
// Each piece has 4 connectors, one of each type, plus one extra, at the center of its walls:
|
||||
cConnectors res;
|
||||
res.push_back(cConnector(m_Size / 2, 1, 0, 0, BLOCK_FACE_ZM));
|
||||
res.push_back(cConnector(m_Size / 2, 1, m_Size - 1, 1, BLOCK_FACE_ZP));
|
||||
res.push_back(cConnector(0, 1, m_Size / 2, 2, BLOCK_FACE_XM));
|
||||
res.push_back(cConnector(m_Size - 1, 1, m_Size / 2, m_Size % 3, BLOCK_FACE_XP));
|
||||
return res;
|
||||
}
|
||||
|
||||
virtual Vector3i GetSize(void) const override
|
||||
{
|
||||
return Vector3i(m_Size, 5, m_Size);
|
||||
}
|
||||
|
||||
virtual cCuboid GetHitBox(void) const override
|
||||
{
|
||||
return cCuboid(0, 0, 0, m_Size - 1, 4, m_Size - 1);
|
||||
}
|
||||
|
||||
virtual bool CanRotateCCW(int a_NumCCWRotations) const override
|
||||
{
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
cPieces m_Pieces;
|
||||
|
||||
virtual cPieces GetPiecesWithConnector(int a_ConnectorType) override
|
||||
{
|
||||
// Each piece contains each connector
|
||||
return m_Pieces;
|
||||
}
|
||||
|
||||
|
||||
virtual cPieces GetStartingPieces(void) override
|
||||
{
|
||||
return m_Pieces;
|
||||
}
|
||||
|
||||
|
||||
virtual void PiecePlaced(const cPiece & a_Piece) override
|
||||
{
|
||||
UNUSED(a_Piece);
|
||||
}
|
||||
|
||||
|
||||
virtual void Reset(void) override
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
void InitializePieces(void)
|
||||
{
|
||||
m_Pieces.push_back(new cTestPiece(5));
|
||||
m_Pieces.push_back(new cTestPiece(7));
|
||||
m_Pieces.push_back(new cTestPiece(9));
|
||||
}
|
||||
} g_Test;
|
||||
|
||||
#endif // SELF_TEST
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// cPiece:
|
||||
|
||||
|
||||
Vector3i cPiece::RotatePos(const Vector3i & a_Pos, int a_NumCCWRotations) const
|
||||
{
|
||||
Vector3i Size = GetSize();
|
||||
switch (a_NumCCWRotations)
|
||||
{
|
||||
case 0:
|
||||
{
|
||||
// No rotation needed
|
||||
return a_Pos;
|
||||
}
|
||||
case 1:
|
||||
{
|
||||
// 1 CCW rotation:
|
||||
return Vector3i(a_Pos.z, a_Pos.y, Size.x - a_Pos.x - 1);
|
||||
}
|
||||
case 2:
|
||||
{
|
||||
// 2 rotations ( = axis flip):
|
||||
return Vector3i(Size.x - a_Pos.x - 1, a_Pos.y, Size.z - a_Pos.z - 1);
|
||||
}
|
||||
case 3:
|
||||
{
|
||||
// 1 CW rotation:
|
||||
return Vector3i(Size.z - a_Pos.z - 1, a_Pos.y, a_Pos.x);
|
||||
}
|
||||
}
|
||||
ASSERT(!"Unhandled rotation");
|
||||
return a_Pos;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
cPiece::cConnector cPiece::RotateMoveConnector(const cConnector & a_Connector, int a_NumCCWRotations, int a_MoveX, int a_MoveY, int a_MoveZ) const
|
||||
{
|
||||
cPiece::cConnector res(a_Connector);
|
||||
|
||||
// Rotate the res connector:
|
||||
Vector3i Size = GetSize();
|
||||
switch (a_NumCCWRotations)
|
||||
{
|
||||
case 0:
|
||||
{
|
||||
// No rotation needed
|
||||
break;
|
||||
}
|
||||
case 1:
|
||||
{
|
||||
// 1 CCW rotation:
|
||||
res.m_Direction = RotateBlockFaceCCW(res.m_Direction);
|
||||
break;
|
||||
}
|
||||
case 2:
|
||||
{
|
||||
// 2 rotations ( = axis flip):
|
||||
res.m_Direction = MirrorBlockFaceY(res.m_Direction);
|
||||
break;
|
||||
}
|
||||
case 3:
|
||||
{
|
||||
// 1 CW rotation:
|
||||
res.m_Direction = RotateBlockFaceCW(res.m_Direction);
|
||||
break;
|
||||
}
|
||||
}
|
||||
res.m_Pos = RotatePos(a_Connector.m_Pos, a_NumCCWRotations);
|
||||
|
||||
// Move the res connector:
|
||||
res.m_Pos.x += a_MoveX;
|
||||
res.m_Pos.y += a_MoveY;
|
||||
res.m_Pos.z += a_MoveZ;
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
cCuboid cPiece::RotateHitBoxToConnector(
|
||||
const cPiece::cConnector & a_MyConnector,
|
||||
const Vector3i & a_ToConnectorPos,
|
||||
int a_NumCCWRotations
|
||||
) const
|
||||
{
|
||||
ASSERT(a_NumCCWRotations == (a_NumCCWRotations % 4));
|
||||
Vector3i ConnPos = RotatePos(a_MyConnector.m_Pos, a_NumCCWRotations);
|
||||
ConnPos = a_ToConnectorPos - ConnPos;
|
||||
return RotateMoveHitBox(a_NumCCWRotations, ConnPos.x, ConnPos.y, ConnPos.z);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
cCuboid cPiece::RotateMoveHitBox(int a_NumCCWRotations, int a_MoveX, int a_MoveY, int a_MoveZ) const
|
||||
{
|
||||
ASSERT(a_NumCCWRotations == (a_NumCCWRotations % 4));
|
||||
cCuboid res = GetHitBox();
|
||||
res.p1 = RotatePos(res.p1, a_NumCCWRotations);
|
||||
res.p2 = RotatePos(res.p2, a_NumCCWRotations);
|
||||
res.p1.Move(a_MoveX, a_MoveY, a_MoveZ);
|
||||
res.p2.Move(a_MoveX, a_MoveY, a_MoveZ);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// cPiece::cConnector:
|
||||
|
||||
cPiece::cConnector::cConnector(int a_X, int a_Y, int a_Z, int a_Type, eBlockFace a_Direction) :
|
||||
m_Pos(a_X, a_Y, a_Z),
|
||||
m_Type(a_Type),
|
||||
m_Direction(a_Direction)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
cPiece::cConnector::cConnector(const Vector3i & a_Pos, int a_Type, eBlockFace a_Direction) :
|
||||
m_Pos(a_Pos),
|
||||
m_Type(a_Type),
|
||||
m_Direction(a_Direction)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// cPlacedPiece:
|
||||
|
||||
cPlacedPiece::cPlacedPiece(const cPlacedPiece * a_Parent, const cPiece & a_Piece, const Vector3i & a_Coords, int a_NumCCWRotations) :
|
||||
m_Parent(a_Parent),
|
||||
m_Piece(&a_Piece),
|
||||
m_Coords(a_Coords),
|
||||
m_NumCCWRotations(a_NumCCWRotations)
|
||||
{
|
||||
m_Depth = (m_Parent == NULL) ? 0 : (m_Parent->GetDepth() + 1);
|
||||
m_HitBox = a_Piece.RotateMoveHitBox(a_NumCCWRotations, a_Coords.x, a_Coords.y, a_Coords.z);
|
||||
m_HitBox.Sort();
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// cPieceGenerator:
|
||||
|
||||
cPieceGenerator::cPieceGenerator(cPiecePool & a_PiecePool, int a_Seed) :
|
||||
m_PiecePool(a_PiecePool),
|
||||
m_Noise(a_Seed),
|
||||
m_Seed(a_Seed)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cPieceGenerator::FreePieces(cPlacedPieces & a_PlacedPieces)
|
||||
{
|
||||
for (cPlacedPieces::iterator itr = a_PlacedPieces.begin(), end = a_PlacedPieces.end(); itr != end; ++itr)
|
||||
{
|
||||
delete *itr;
|
||||
} // for itr - a_PlacedPieces[]
|
||||
a_PlacedPieces.clear();
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
cPlacedPiece * cPieceGenerator::PlaceStartingPiece(int a_BlockX, int a_BlockY, int a_BlockZ, cFreeConnectors & a_OutConnectors)
|
||||
{
|
||||
m_PiecePool.Reset();
|
||||
int rnd = m_Noise.IntNoise3DInt(a_BlockX, a_BlockY, a_BlockZ) / 7;
|
||||
|
||||
// Choose a random one of the starting pieces:
|
||||
cPieces StartingPieces = m_PiecePool.GetStartingPieces();
|
||||
cPiece * StartingPiece = StartingPieces[rnd % StartingPieces.size()];
|
||||
rnd = rnd >> 16;
|
||||
|
||||
// Choose a random supported rotation:
|
||||
int Rotations[4] = {0};
|
||||
int NumRotations = 1;
|
||||
for (int i = 1; i < ARRAYCOUNT(Rotations); i++)
|
||||
{
|
||||
if (StartingPiece->CanRotateCCW(i))
|
||||
{
|
||||
Rotations[NumRotations] = i;
|
||||
NumRotations += 1;
|
||||
}
|
||||
}
|
||||
int Rotation = Rotations[rnd % NumRotations];
|
||||
|
||||
cPlacedPiece * res = new cPlacedPiece(NULL, *StartingPiece, Vector3i(a_BlockX, a_BlockY, a_BlockZ), Rotation);
|
||||
|
||||
// Place the piece's connectors into a_OutConnectors:
|
||||
const cPiece::cConnectors & Conn = StartingPiece->GetConnectors();
|
||||
for (cPiece::cConnectors::const_iterator itr = Conn.begin(), end = Conn.end(); itr != end; ++itr)
|
||||
{
|
||||
a_OutConnectors.push_back(
|
||||
cFreeConnector(res, StartingPiece->RotateMoveConnector(*itr, Rotation, a_BlockX, a_BlockY, a_BlockZ))
|
||||
);
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
bool cPieceGenerator::TryPlacePieceAtConnector(
|
||||
const cPlacedPiece & a_ParentPiece,
|
||||
const cPiece::cConnector & a_Connector,
|
||||
cPlacedPieces & a_OutPieces,
|
||||
cPieceGenerator::cFreeConnectors & a_OutConnectors
|
||||
)
|
||||
{
|
||||
// Translation of direction - direction -> number of CCW rotations needed:
|
||||
// You need DirectionRotationTable[rot1][rot2] CCW turns to connect rot1 to rot2 (they are opposite)
|
||||
static const int DirectionRotationTable[6][6] =
|
||||
{
|
||||
/* YM, YP, ZM, ZP, XM, XP
|
||||
/* YM */ { 0, 0, 0, 0, 0, 0},
|
||||
/* YP */ { 0, 0, 0, 0, 0, 0},
|
||||
/* ZM */ { 0, 0, 2, 0, 1, 3},
|
||||
/* ZP */ { 0, 0, 0, 2, 3, 1},
|
||||
/* XM */ { 0, 0, 3, 1, 2, 0},
|
||||
/* XP */ { 0, 0, 1, 3, 0, 2},
|
||||
};
|
||||
|
||||
// Get a list of available connections:
|
||||
const int * RotTable = DirectionRotationTable[a_Connector.m_Direction];
|
||||
cConnections Connections;
|
||||
cPieces AvailablePieces = m_PiecePool.GetPiecesWithConnector(a_Connector.m_Type);
|
||||
Connections.reserve(AvailablePieces.size());
|
||||
Vector3i ConnPos = a_Connector.m_Pos; // The position at which the new connector should be placed - 1 block away from the connector
|
||||
AddFaceDirection(ConnPos.x, ConnPos.y, ConnPos.z, a_Connector.m_Direction);
|
||||
|
||||
/*
|
||||
// DEBUG:
|
||||
printf("Placing piece at connector pos {%d, %d, %d}, direction %s\n", ConnPos.x, ConnPos.y, ConnPos.z, BlockFaceToString(a_Connector.m_Direction).c_str());
|
||||
//*/
|
||||
|
||||
for (cPieces::iterator itrP = AvailablePieces.begin(), endP = AvailablePieces.end(); itrP != endP; ++itrP)
|
||||
{
|
||||
cPiece::cConnectors Connectors = (*itrP)->GetConnectors();
|
||||
for (cPiece::cConnectors::iterator itrC = Connectors.begin(), endC = Connectors.end(); itrC != endC; ++itrC)
|
||||
{
|
||||
if (itrC->m_Type != a_Connector.m_Type)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
// This is a same-type connector, find out how to rotate to it:
|
||||
int NumCCWRotations = RotTable[itrC->m_Direction];
|
||||
if (!(*itrP)->CanRotateCCW(NumCCWRotations))
|
||||
{
|
||||
// Doesn't support this rotation
|
||||
continue;
|
||||
}
|
||||
if (!CheckConnection(a_Connector, ConnPos, **itrP, *itrC, NumCCWRotations, a_OutPieces))
|
||||
{
|
||||
// Doesn't fit in this rotation
|
||||
continue;
|
||||
}
|
||||
Connections.push_back(cConnection(**itrP, *itrC, NumCCWRotations));
|
||||
} // for itrC - Connectors[]
|
||||
} // for itrP - AvailablePieces[]
|
||||
if (Connections.empty())
|
||||
{
|
||||
// No available connections, bail out
|
||||
return false;
|
||||
}
|
||||
|
||||
// Choose a random connection from the list:
|
||||
int rnd = m_Noise.IntNoise3DInt(a_Connector.m_Pos.x, a_Connector.m_Pos.y, a_Connector.m_Pos.z) / 7;
|
||||
cConnection & Conn = Connections[rnd % Connections.size()];
|
||||
|
||||
// Place the piece:
|
||||
/*
|
||||
// DEBUG
|
||||
printf("Chosen connector at {%d, %d, %d}, direction %s, needs %d rotations\n",
|
||||
Conn.m_Connector.m_Pos.x, Conn.m_Connector.m_Pos.y, Conn.m_Connector.m_Pos.z,
|
||||
BlockFaceToString(Conn.m_Connector.m_Direction).c_str(),
|
||||
Conn.m_NumCCWRotations
|
||||
);
|
||||
//*/
|
||||
|
||||
Vector3i NewPos = Conn.m_Piece->RotatePos(Conn.m_Connector.m_Pos, Conn.m_NumCCWRotations);
|
||||
ConnPos -= NewPos;
|
||||
cPlacedPiece * PlacedPiece = new cPlacedPiece(&a_ParentPiece, *(Conn.m_Piece), ConnPos, Conn.m_NumCCWRotations);
|
||||
a_OutPieces.push_back(PlacedPiece);
|
||||
|
||||
// Add the new piece's connectors to the list of free connectors:
|
||||
cPiece::cConnectors Connectors = Conn.m_Piece->GetConnectors();
|
||||
|
||||
/*
|
||||
// DEBUG:
|
||||
printf("Adding %u connectors to the pool\n", Connectors.size() - 1);
|
||||
//*/
|
||||
|
||||
for (cPiece::cConnectors::const_iterator itr = Connectors.begin(), end = Connectors.end(); itr != end; ++itr)
|
||||
{
|
||||
if (itr->m_Pos.Equals(Conn.m_Connector.m_Pos))
|
||||
{
|
||||
// This is the connector through which we have been connected to the parent, don't add
|
||||
continue;
|
||||
}
|
||||
a_OutConnectors.push_back(cFreeConnector(PlacedPiece, Conn.m_Piece->RotateMoveConnector(*itr, Conn.m_NumCCWRotations, ConnPos.x, ConnPos.y, ConnPos.z)));
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
bool cPieceGenerator::CheckConnection(
|
||||
const cPiece::cConnector & a_ExistingConnector,
|
||||
const Vector3i & a_ToPos,
|
||||
const cPiece & a_Piece,
|
||||
const cPiece::cConnector & a_NewConnector,
|
||||
int a_NumCCWRotations,
|
||||
const cPlacedPieces & a_OutPieces
|
||||
)
|
||||
{
|
||||
// For each placed piece, test the hitbox against the new piece:
|
||||
cCuboid RotatedHitBox = a_Piece.RotateHitBoxToConnector(a_NewConnector, a_ToPos, a_NumCCWRotations);
|
||||
RotatedHitBox.Sort();
|
||||
for (cPlacedPieces::const_iterator itr = a_OutPieces.begin(), end = a_OutPieces.end(); itr != end; ++itr)
|
||||
{
|
||||
if ((*itr)->GetHitBox().DoesIntersect(RotatedHitBox))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
//*
|
||||
// DEBUG:
|
||||
void cPieceGenerator::DebugConnectorPool(const cPieceGenerator::cFreeConnectors & a_ConnectorPool, size_t a_NumProcessed)
|
||||
{
|
||||
printf(" Connector pool: %u items\n", a_ConnectorPool.size() - a_NumProcessed);
|
||||
size_t idx = 0;
|
||||
for (cPieceGenerator::cFreeConnectors::const_iterator itr = a_ConnectorPool.begin() + a_NumProcessed, end = a_ConnectorPool.end(); itr != end; ++itr, ++idx)
|
||||
{
|
||||
printf(" %u: {%d, %d, %d}, type %d, direction %s, depth %d\n",
|
||||
idx,
|
||||
itr->m_Connector.m_Pos.x, itr->m_Connector.m_Pos.y, itr->m_Connector.m_Pos.z,
|
||||
itr->m_Connector.m_Type,
|
||||
BlockFaceToString(itr->m_Connector.m_Direction).c_str(),
|
||||
itr->m_Piece->GetDepth()
|
||||
);
|
||||
} // for itr - a_ConnectorPool[]
|
||||
}
|
||||
//*/
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// cPieceGenerator::cConnection:
|
||||
|
||||
cPieceGenerator::cConnection::cConnection(cPiece & a_Piece, cPiece::cConnector & a_Connector, int a_NumCCWRotations) :
|
||||
m_Piece(&a_Piece),
|
||||
m_Connector(a_Connector),
|
||||
m_NumCCWRotations(a_NumCCWRotations)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// cPieceGenerator::cFreeConnector:
|
||||
|
||||
cPieceGenerator::cFreeConnector::cFreeConnector(cPlacedPiece * a_Piece, const cPiece::cConnector & a_Connector) :
|
||||
m_Piece(a_Piece),
|
||||
m_Connector(a_Connector)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// cBFSPieceGenerator:
|
||||
|
||||
cBFSPieceGenerator::cBFSPieceGenerator(cPiecePool & a_PiecePool, int a_Seed) :
|
||||
super(a_PiecePool, a_Seed)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cBFSPieceGenerator::PlacePieces(int a_BlockX, int a_BlockY, int a_BlockZ, int a_MaxDepth, cPlacedPieces & a_OutPieces)
|
||||
{
|
||||
a_OutPieces.clear();
|
||||
cFreeConnectors ConnectorPool;
|
||||
|
||||
// Place the starting piece:
|
||||
a_OutPieces.push_back(PlaceStartingPiece(a_BlockX, a_BlockY, a_BlockZ, ConnectorPool));
|
||||
|
||||
/*
|
||||
// DEBUG:
|
||||
printf("Placed the starting piece at {%d, %d, %d}\n", a_BlockX, a_BlockY, a_BlockZ);
|
||||
cCuboid Hitbox = a_OutPieces[0]->GetHitBox();
|
||||
Hitbox.Sort();
|
||||
printf(" Hitbox: {%d, %d, %d} - {%d, %d, %d} (%d * %d * %d)\n",
|
||||
Hitbox.p1.x, Hitbox.p1.y, Hitbox.p1.z,
|
||||
Hitbox.p2.x, Hitbox.p2.y, Hitbox.p2.z,
|
||||
Hitbox.DifX() + 1, Hitbox.DifY() + 1, Hitbox.DifZ() + 1
|
||||
);
|
||||
DebugConnectorPool(ConnectorPool, 0);
|
||||
//*/
|
||||
|
||||
// Place pieces at the available connectors:
|
||||
/*
|
||||
Instead of removing them one by one from the pool, we process them sequentially and take note of the last
|
||||
processed one. To save on memory, once the number of processed connectors reaches a big number, a chunk
|
||||
of the connectors is removed.
|
||||
*/
|
||||
size_t NumProcessed = 0;
|
||||
while (ConnectorPool.size() > NumProcessed)
|
||||
{
|
||||
cFreeConnector & Conn = ConnectorPool[NumProcessed];
|
||||
if (Conn.m_Piece->GetDepth() < a_MaxDepth)
|
||||
{
|
||||
if (TryPlacePieceAtConnector(*Conn.m_Piece, Conn.m_Connector, a_OutPieces, ConnectorPool))
|
||||
{
|
||||
/*
|
||||
// DEBUG:
|
||||
const cPlacedPiece * NewPiece = a_OutPieces.back();
|
||||
const Vector3i & Coords = NewPiece->GetCoords();
|
||||
printf("Placed a new piece at {%d, %d, %d}, rotation %d\n", Coords.x, Coords.y, Coords.z, NewPiece->GetNumCCWRotations());
|
||||
cCuboid Hitbox = NewPiece->GetHitBox();
|
||||
Hitbox.Sort();
|
||||
printf(" Hitbox: {%d, %d, %d} - {%d, %d, %d} (%d * %d * %d)\n",
|
||||
Hitbox.p1.x, Hitbox.p1.y, Hitbox.p1.z,
|
||||
Hitbox.p2.x, Hitbox.p2.y, Hitbox.p2.z,
|
||||
Hitbox.DifX() + 1, Hitbox.DifY() + 1, Hitbox.DifZ() + 1
|
||||
);
|
||||
DebugConnectorPool(ConnectorPool, NumProcessed + 1);
|
||||
//*/
|
||||
}
|
||||
}
|
||||
NumProcessed++;
|
||||
if (NumProcessed > 1000)
|
||||
{
|
||||
ConnectorPool.erase(ConnectorPool.begin(), ConnectorPool.begin() + NumProcessed);
|
||||
NumProcessed = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,247 @@
|
|||
|
||||
// PieceGenerator.h
|
||||
|
||||
// Declares the cBFSPieceGenerator class and cDFSPieceGenerator class
|
||||
// representing base classes for generating structures composed of individual "pieces"
|
||||
|
||||
/*
|
||||
Each uses a slightly different approach to generating:
|
||||
- DFS extends pieces one by one until it hits the configured depth (or can't connect another piece anymore),
|
||||
then starts looking at adjacent connectors (like depth-first search).
|
||||
- BFS keeps a pool of currently-open connectors, chooses one at random and tries to place a piece on it,
|
||||
thus possibly extending the pool of open connectors (like breadth-first search).
|
||||
*/
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "../Defines.h"
|
||||
#include "../Cuboid.h"
|
||||
#include "../Noise.h"
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/** Represents a single piece. Can have multiple connectors of different types where other pieces can connect. */
|
||||
class cPiece
|
||||
{
|
||||
public:
|
||||
// Force a virtual destructor in all descendants
|
||||
virtual ~cPiece() {}
|
||||
|
||||
struct cConnector
|
||||
{
|
||||
/** Position relative to the piece */
|
||||
Vector3i m_Pos;
|
||||
|
||||
/** Type of the connector. Any arbitrary number; the generator connects only connectors of the same type. */
|
||||
int m_Type;
|
||||
|
||||
/** Direction in which the connector is facing.
|
||||
Will be matched by the opposite direction for the connecting connector. */
|
||||
eBlockFace m_Direction;
|
||||
|
||||
cConnector(int a_X, int a_Y, int a_Z, int a_Type, eBlockFace a_Direction);
|
||||
cConnector(const Vector3i & a_Pos, int a_Type, eBlockFace a_Direction);
|
||||
};
|
||||
|
||||
typedef std::vector<cConnector> cConnectors;
|
||||
|
||||
/** Returns all of the available connectors that the piece has.
|
||||
Each connector has a (relative) position in the piece, and a type associated with it. */
|
||||
virtual cConnectors GetConnectors(void) const = 0;
|
||||
|
||||
/** Returns the dimensions of this piece.
|
||||
The dimensions cover the entire piece, there is no block that the piece generates outside of this size. */
|
||||
virtual Vector3i GetSize(void) const = 0;
|
||||
|
||||
/** Returns the "hitbox" of this piece.
|
||||
A hitbox is what is compared and must not intersect other pieces' hitboxes when generating. */
|
||||
virtual cCuboid GetHitBox(void) const = 0;
|
||||
|
||||
/** Returns true if the piece can be rotated CCW the specific number of 90-degree turns. */
|
||||
virtual bool CanRotateCCW(int a_NumRotations) const = 0;
|
||||
|
||||
/** Returns a copy of the a_Pos after rotating the piece the specified number of CCW rotations. */
|
||||
Vector3i RotatePos(const Vector3i & a_Pos, int a_NumCCWRotations) const;
|
||||
|
||||
/** Returns a copy of the connector that is rotated and then moved by the specified amounts. */
|
||||
cConnector RotateMoveConnector(const cConnector & a_Connector, int a_NumCCWRotations, int a_MoveX, int a_MoveY, int a_MoveZ) const;
|
||||
|
||||
/** Returns the hitbox after the specified number of rotations and moved so that a_MyConnector is placed at a_ToConnectorPos. */
|
||||
cCuboid RotateHitBoxToConnector(const cConnector & a_MyConnector, const Vector3i & a_ToConnectorPos, int a_NumCCWRotations) const;
|
||||
|
||||
/** Returns the hitbox after the specified number of CCW rotations and moved by the specified amounts. */
|
||||
cCuboid RotateMoveHitBox(int a_NumCCWRotations, int a_MoveX, int a_MoveY, int a_MoveZ) const;
|
||||
};
|
||||
|
||||
typedef std::vector<cPiece *> cPieces;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/** This class is an interface that provides pieces for the generator. It can keep track of what pieces were
|
||||
placed and adjust the returned piece vectors. */
|
||||
class cPiecePool
|
||||
{
|
||||
public:
|
||||
// Force a virtual destructor in all descendants:
|
||||
virtual ~cPiecePool() {}
|
||||
|
||||
/** Returns a list of pieces that contain the specified connector type.
|
||||
The cPiece pointers returned are managed by the pool and the caller doesn't free them. */
|
||||
virtual cPieces GetPiecesWithConnector(int a_ConnectorType) = 0;
|
||||
|
||||
/** Returns the pieces that should be used as the starting point.
|
||||
Multiple starting points are supported, one of the returned piece will be chosen. */
|
||||
virtual cPieces GetStartingPieces(void) = 0;
|
||||
|
||||
/** Called after a piece is placed, to notify the pool that it has been used.
|
||||
The pool may adjust the pieces it will return the next time. */
|
||||
virtual void PiecePlaced(const cPiece & a_Piece) = 0;
|
||||
|
||||
/** Called when the pool has finished the current structure and should reset any piece-counters it has
|
||||
for a new structure. */
|
||||
virtual void Reset(void) = 0;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/** Represents a single piece that has been placed to specific coords in the world. */
|
||||
class cPlacedPiece
|
||||
{
|
||||
public:
|
||||
cPlacedPiece(const cPlacedPiece * a_Parent, const cPiece & a_Piece, const Vector3i & a_Coords, int a_NumCCWRotations);
|
||||
|
||||
const cPiece & GetPiece (void) const { return *m_Piece; }
|
||||
const Vector3i & GetCoords (void) const { return m_Coords; }
|
||||
const int GetNumCCWRotations(void) const { return m_NumCCWRotations; }
|
||||
const cCuboid & GetHitBox (void) const { return m_HitBox; }
|
||||
const int GetDepth (void) const { return m_Depth; }
|
||||
|
||||
protected:
|
||||
const cPlacedPiece * m_Parent;
|
||||
const cPiece * m_Piece;
|
||||
Vector3i m_Coords;
|
||||
int m_NumCCWRotations;
|
||||
cCuboid m_HitBox;
|
||||
int m_Depth;
|
||||
};
|
||||
|
||||
typedef std::vector<cPlacedPiece *> cPlacedPieces;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
class cPieceGenerator
|
||||
{
|
||||
public:
|
||||
cPieceGenerator(cPiecePool & a_PiecePool, int a_Seed);
|
||||
|
||||
/** Cleans up all the memory used by the placed pieces.
|
||||
Call this utility function instead of freeing the items on your own. */
|
||||
static void FreePieces(cPlacedPieces & a_PlacedPieces);
|
||||
|
||||
protected:
|
||||
/** The type used for storing a connection from one piece to another, while building the piece tree. */
|
||||
struct cConnection
|
||||
{
|
||||
cPiece * m_Piece; // The piece being connected
|
||||
cPiece::cConnector m_Connector; // The piece's connector being used (relative non-rotated coords)
|
||||
int m_NumCCWRotations; // Number of rotations necessary to match the two connectors
|
||||
|
||||
cConnection(cPiece & a_Piece, cPiece::cConnector & a_Connector, int a_NumCCWRotations);
|
||||
};
|
||||
typedef std::vector<cConnection> cConnections;
|
||||
|
||||
/** The type used for storing a pool of connectors that will be attempted to expand by another piece. */
|
||||
struct cFreeConnector
|
||||
{
|
||||
cPlacedPiece * m_Piece;
|
||||
cPiece::cConnector m_Connector;
|
||||
|
||||
cFreeConnector(cPlacedPiece * a_Piece, const cPiece::cConnector & a_Connector);
|
||||
};
|
||||
typedef std::vector<cFreeConnector> cFreeConnectors;
|
||||
|
||||
|
||||
cPiecePool & m_PiecePool;
|
||||
cNoise m_Noise;
|
||||
int m_Seed;
|
||||
|
||||
|
||||
/** Selects a starting piece and places it, including the rotations.
|
||||
Also puts the piece's connectors in a_OutConnectors. */
|
||||
cPlacedPiece * PlaceStartingPiece(int a_BlockX, int a_BlockY, int a_BlockZ, cFreeConnectors & a_OutConnectors);
|
||||
|
||||
/** Tries to place a new piece at the specified (placed) connector. Returns true if successful. */
|
||||
bool TryPlacePieceAtConnector(
|
||||
const cPlacedPiece & a_ParentPiece, // The existing piece to a new piece should be placed
|
||||
const cPiece::cConnector & a_Connector, // The existing connector (world-coords) to which a new piece should be placed
|
||||
cPlacedPieces & a_OutPieces, // Already placed pieces, to be checked for intersections
|
||||
cFreeConnectors & a_OutConnectors // List of free connectors to which the new connectors will be placed
|
||||
);
|
||||
|
||||
/** Checks if the specified piece would fit with the already-placed pieces, using the specified connector
|
||||
and number of CCW rotations.
|
||||
a_ExistingConnector is in world-coords and is already rotated properly
|
||||
a_ToPos is the world-coords position on which the new connector should be placed (1 block away from a_ExistingConnector, in its Direction)
|
||||
a_NewConnector is in the original (non-rotated) coords.
|
||||
Returns true if the piece fits, false if not. */
|
||||
bool CheckConnection(
|
||||
const cPiece::cConnector & a_ExistingConnector, // The existing connector
|
||||
const Vector3i & a_ToPos, // The position on which the new connector should be placed
|
||||
const cPiece & a_Piece, // The new piece
|
||||
const cPiece::cConnector & a_NewConnector, // The connector of the new piece
|
||||
int a_NumCCWRotations, // Number of rotations for the new piece to align the connector
|
||||
const cPlacedPieces & a_OutPieces // All the already-placed pieces to check
|
||||
);
|
||||
|
||||
/** DEBUG: Outputs all the connectors in the pool into stdout.
|
||||
a_NumProcessed signals the number of connectors from the pool that should be considered processed (not listed). */
|
||||
void DebugConnectorPool(const cPieceGenerator::cFreeConnectors & a_ConnectorPool, size_t a_NumProcessed);
|
||||
} ;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
class cBFSPieceGenerator :
|
||||
public cPieceGenerator
|
||||
{
|
||||
typedef cPieceGenerator super;
|
||||
|
||||
public:
|
||||
cBFSPieceGenerator(cPiecePool & a_PiecePool, int a_Seed);
|
||||
|
||||
/** Generates a placement for pieces at the specified coords.
|
||||
Caller must free each individual cPlacedPiece in a_OutPieces. */
|
||||
void PlacePieces(int a_BlockX, int a_BlockY, int a_BlockZ, int a_MaxDepth, cPlacedPieces & a_OutPieces);
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
class cDFSPieceGenerator :
|
||||
public cPieceGenerator
|
||||
{
|
||||
public:
|
||||
cDFSPieceGenerator(cPiecePool & a_PiecePool, int a_Seed);
|
||||
|
||||
/** Generates a placement for pieces at the specified coords.
|
||||
Caller must free each individual cPlacedPiece in a_OutPieces. */
|
||||
void PlacePieces(int a_BlockX, int a_BlockY, int a_BlockZ, cPlacedPieces & a_OutPieces);
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -595,7 +595,7 @@ void GetPineTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_Noise
|
|||
{
|
||||
break;
|
||||
}
|
||||
ASSERT(LayerSize < ARRAYCOUNT(BigOs));
|
||||
ASSERT((size_t)LayerSize < ARRAYCOUNT(BigOs));
|
||||
PushCoordBlocks(a_BlockX, h, a_BlockZ, a_OtherBlocks, BigOs[LayerSize].Coords, BigOs[LayerSize].Count, E_BLOCK_LEAVES, E_META_LEAVES_CONIFER);
|
||||
h--;
|
||||
}
|
||||
|
|
|
|||
22
src/Item.cpp
22
src/Item.cpp
|
|
@ -1,4 +1,4 @@
|
|||
|
||||
|
||||
#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules
|
||||
|
||||
#include "Item.h"
|
||||
|
|
@ -139,6 +139,16 @@ void cItem::GetJson(Json::Value & a_OutValue) const
|
|||
{
|
||||
a_OutValue["Lore"] = m_Lore;
|
||||
}
|
||||
|
||||
if ((m_ItemType == E_ITEM_FIREWORK_ROCKET) || (m_ItemType == E_ITEM_FIREWORK_STAR))
|
||||
{
|
||||
a_OutValue["Flicker"] = m_FireworkItem.m_HasFlicker;
|
||||
a_OutValue["Trail"] = m_FireworkItem.m_HasTrail;
|
||||
a_OutValue["Type"] = m_FireworkItem.m_Type;
|
||||
a_OutValue["FlightTimeInTicks"] = m_FireworkItem.m_FlightTimeInTicks;
|
||||
a_OutValue["Colours"] = m_FireworkItem.ColoursToString(m_FireworkItem);
|
||||
a_OutValue["FadeColours"] = m_FireworkItem.FadeColoursToString(m_FireworkItem);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -157,6 +167,16 @@ void cItem::FromJson(const Json::Value & a_Value)
|
|||
m_Enchantments.AddFromString(a_Value.get("ench", "").asString());
|
||||
m_CustomName = a_Value.get("Name", "").asString();
|
||||
m_Lore = a_Value.get("Lore", "").asString();
|
||||
|
||||
if ((m_ItemType == E_ITEM_FIREWORK_ROCKET) || (m_ItemType == E_ITEM_FIREWORK_STAR))
|
||||
{
|
||||
m_FireworkItem.m_HasFlicker = a_Value.get("Flicker", false).asBool();
|
||||
m_FireworkItem.m_HasTrail = a_Value.get("Trail", false).asBool();
|
||||
m_FireworkItem.m_Type = (NIBBLETYPE)a_Value.get("Type", 0).asInt();
|
||||
m_FireworkItem.m_FlightTimeInTicks = (short)a_Value.get("FlightTimeInTicks", 0).asInt();
|
||||
m_FireworkItem.ColoursFromString(a_Value.get("Colours", "").asString(), m_FireworkItem);
|
||||
m_FireworkItem.FadeColoursFromString(a_Value.get("FadeColours", "").asString(), m_FireworkItem);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
16
src/Item.h
16
src/Item.h
|
|
@ -11,6 +11,7 @@
|
|||
|
||||
#include "Defines.h"
|
||||
#include "Enchantments.h"
|
||||
#include "WorldStorage/FireworksSerializer.h"
|
||||
|
||||
|
||||
|
||||
|
|
@ -38,7 +39,8 @@ public:
|
|||
m_ItemCount(0),
|
||||
m_ItemDamage(0),
|
||||
m_CustomName(""),
|
||||
m_Lore("")
|
||||
m_Lore(""),
|
||||
m_FireworkItem()
|
||||
{
|
||||
}
|
||||
|
||||
|
|
@ -57,7 +59,8 @@ public:
|
|||
m_ItemDamage (a_ItemDamage),
|
||||
m_Enchantments(a_Enchantments),
|
||||
m_CustomName (a_CustomName),
|
||||
m_Lore (a_Lore)
|
||||
m_Lore (a_Lore),
|
||||
m_FireworkItem()
|
||||
{
|
||||
if (!IsValidItem(m_ItemType))
|
||||
{
|
||||
|
|
@ -77,7 +80,8 @@ public:
|
|||
m_ItemDamage (a_CopyFrom.m_ItemDamage),
|
||||
m_Enchantments(a_CopyFrom.m_Enchantments),
|
||||
m_CustomName (a_CopyFrom.m_CustomName),
|
||||
m_Lore (a_CopyFrom.m_Lore)
|
||||
m_Lore (a_CopyFrom.m_Lore),
|
||||
m_FireworkItem(a_CopyFrom.m_FireworkItem)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
@ -90,6 +94,7 @@ public:
|
|||
m_Enchantments.Clear();
|
||||
m_CustomName = "";
|
||||
m_Lore = "";
|
||||
m_FireworkItem.EmptyData();
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -115,7 +120,8 @@ public:
|
|||
(m_ItemDamage == a_Item.m_ItemDamage) &&
|
||||
(m_Enchantments == a_Item.m_Enchantments) &&
|
||||
(m_CustomName == a_Item.m_CustomName) &&
|
||||
(m_Lore == a_Item.m_Lore)
|
||||
(m_Lore == a_Item.m_Lore) &&
|
||||
m_FireworkItem.IsEqualTo(a_Item.m_FireworkItem)
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -177,6 +183,8 @@ public:
|
|||
cEnchantments m_Enchantments;
|
||||
AString m_CustomName;
|
||||
AString m_Lore;
|
||||
|
||||
cFireworkItem m_FireworkItem;
|
||||
};
|
||||
// tolua_end
|
||||
|
||||
|
|
|
|||
|
|
@ -21,6 +21,9 @@ class cItemHandler
|
|||
public:
|
||||
cItemHandler(int a_ItemType);
|
||||
|
||||
// Force virtual destructor
|
||||
virtual ~cItemHandler() {}
|
||||
|
||||
/// Called when the player tries to use the item (right mouse button). Return false to make the item unusable. DEFAULT: False
|
||||
virtual bool OnItemUse(cWorld * a_World, cPlayer * a_Player, const cItem & a_Item, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_Dir);
|
||||
|
||||
|
|
|
|||
|
|
@ -33,8 +33,8 @@ public:
|
|||
case E_BLOCK_TNT:
|
||||
{
|
||||
// Activate the TNT:
|
||||
a_World->BroadcastSoundEffect("game.tnt.primed", a_BlockX * 8, a_BlockY * 8, a_BlockZ * 8, 0.5f, 0.6f);
|
||||
a_World->SpawnPrimedTNT(a_BlockX + 0.5, a_BlockY + 0.5, a_BlockZ + 0.5, 4); // 4 seconds to boom
|
||||
a_World->BroadcastSoundEffect("game.tnt.primed", a_BlockX * 8, a_BlockY * 8, a_BlockZ * 8, 1.0f, 1.0f);
|
||||
a_World->SpawnPrimedTNT(a_BlockX + 0.5, a_BlockY + 0.5, a_BlockZ + 0.5); // 80 ticks to boom
|
||||
a_World->SetBlock(a_BlockX,a_BlockY,a_BlockZ, E_BLOCK_AIR, 0);
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ public:
|
|||
|
||||
Vector3d Pos = a_Player->GetThrowStartPos();
|
||||
Vector3d Speed = a_Player->GetLookVector() * m_SpeedCoeff;
|
||||
a_World->CreateProjectile(Pos.x, Pos.y, Pos.z, m_ProjectileKind, a_Player, &Speed);
|
||||
a_World->CreateProjectile(Pos.x, Pos.y, Pos.z, m_ProjectileKind, a_Player, a_Player->GetEquippedItem(), &Speed);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
|
@ -127,13 +127,13 @@ public:
|
|||
return false;
|
||||
}
|
||||
|
||||
a_World->CreateProjectile(a_BlockX + 0.5, a_BlockY + 1, a_BlockZ + 0.5, m_ProjectileKind, a_Player, a_Player->GetEquippedItem());
|
||||
|
||||
if (!a_Player->IsGameModeCreative())
|
||||
{
|
||||
a_Player->GetInventory().RemoveOneEquippedItem();
|
||||
}
|
||||
|
||||
a_World->CreateProjectile(a_BlockX + 0.5, a_BlockY + 1, a_BlockZ + 0.5, m_ProjectileKind, a_Player, 0);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -68,17 +68,28 @@ void cSheep::OnRightClicked(cPlayer & a_Player)
|
|||
|
||||
void cSheep::Tick(float a_Dt, cChunk & a_Chunk)
|
||||
{
|
||||
// The sheep should not move when he's eating so only handle the physics.
|
||||
super::Tick(a_Dt, a_Chunk);
|
||||
int PosX = POSX_TOINT;
|
||||
int PosY = POSY_TOINT - 1;
|
||||
int PosZ = POSZ_TOINT;
|
||||
|
||||
if ((PosY <= 0) || (PosY > cChunkDef::Height))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (m_TimeToStopEating > 0)
|
||||
{
|
||||
HandlePhysics(a_Dt, a_Chunk);
|
||||
m_bMovingToDestination = false; // The sheep should not move when he's eating
|
||||
m_TimeToStopEating--;
|
||||
|
||||
if (m_TimeToStopEating == 0)
|
||||
{
|
||||
if (m_World->GetBlock((int) GetPosX(), (int) GetPosY() - 1, (int) GetPosZ()) == E_BLOCK_GRASS)
|
||||
if (m_World->GetBlock(PosX, PosY, PosZ) == E_BLOCK_GRASS) // Make sure grass hasn't been destroyed in the meantime
|
||||
{
|
||||
// The sheep ate the grass so we change it to dirt.
|
||||
m_World->SetBlock((int) GetPosX(), (int) GetPosY() - 1, (int) GetPosZ(), E_BLOCK_DIRT, 0);
|
||||
// The sheep ate the grass so we change it to dirt
|
||||
m_World->SetBlock(PosX, PosY, PosZ, E_BLOCK_DIRT, 0);
|
||||
GetWorld()->BroadcastSoundParticleEffect(2001, PosX, PosY, PosX, E_BLOCK_GRASS);
|
||||
m_IsSheared = false;
|
||||
m_World->BroadcastEntityMetadata(*this);
|
||||
}
|
||||
|
|
@ -86,12 +97,11 @@ void cSheep::Tick(float a_Dt, cChunk & a_Chunk)
|
|||
}
|
||||
else
|
||||
{
|
||||
super::Tick(a_Dt, a_Chunk);
|
||||
if (m_World->GetTickRandomNumber(600) == 1)
|
||||
{
|
||||
if (m_World->GetBlock((int) GetPosX(), (int) GetPosY() - 1, (int) GetPosZ()) == E_BLOCK_GRASS)
|
||||
if (m_World->GetBlock(PosX, PosY, PosZ) == E_BLOCK_GRASS)
|
||||
{
|
||||
m_World->BroadcastEntityStatus(*this, 10);
|
||||
m_World->BroadcastEntityStatus(*this, ENTITY_STATUS_SHEEP_EATING);
|
||||
m_TimeToStopEating = 40;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -103,7 +103,7 @@ private:
|
|||
public:
|
||||
|
||||
cSocketThread(cSocketThreads * a_Parent);
|
||||
~cSocketThread();
|
||||
virtual ~cSocketThread();
|
||||
|
||||
// All these methods assume parent's m_CS is locked
|
||||
bool HasEmptySlot(void) const {return m_NumSlots < MAX_SLOTS; }
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ public:
|
|||
virtual ~cProtocol() {}
|
||||
|
||||
/// Called when client sends some data
|
||||
virtual void DataReceived(const char * a_Data, int a_Size) = 0;
|
||||
virtual void DataReceived(const char * a_Data, size_t a_Size) = 0;
|
||||
|
||||
// Sending stuff to clients (alphabetically sorted):
|
||||
virtual void SendAttachEntity (const cEntity & a_Entity, const cEntity * a_Vehicle) = 0;
|
||||
|
|
|
|||
|
|
@ -1186,7 +1186,7 @@ void cProtocol125::SendData(const char * a_Data, int a_Size)
|
|||
|
||||
|
||||
|
||||
void cProtocol125::DataReceived(const char * a_Data, int a_Size)
|
||||
void cProtocol125::DataReceived(const char * a_Data, size_t a_Size)
|
||||
{
|
||||
if (!m_ReceivedData.Write(a_Data, a_Size))
|
||||
{
|
||||
|
|
@ -1375,7 +1375,16 @@ int cProtocol125::ParseEntityAction(void)
|
|||
{
|
||||
HANDLE_PACKET_READ(ReadBEInt, int, EntityID);
|
||||
HANDLE_PACKET_READ(ReadChar, char, ActionID);
|
||||
m_Client->HandleEntityAction(EntityID, ActionID);
|
||||
|
||||
switch (ActionID)
|
||||
{
|
||||
case 1: m_Client->HandleEntityCrouch(EntityID, true); break; // Crouch
|
||||
case 2: m_Client->HandleEntityCrouch(EntityID, false); break; // Uncrouch
|
||||
case 3: m_Client->HandleEntityLeaveBed(EntityID); break; // Leave Bed
|
||||
case 4: m_Client->HandleEntitySprinting(EntityID, true); break; // Start sprinting
|
||||
case 5: m_Client->HandleEntitySprinting(EntityID, false); break; // Stop sprinting
|
||||
}
|
||||
|
||||
return PARSE_OK;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -11,6 +11,7 @@
|
|||
|
||||
#include "Protocol.h"
|
||||
#include "../ByteBuffer.h"
|
||||
#include "../Entities/Painting.h"
|
||||
|
||||
|
||||
|
||||
|
|
@ -24,7 +25,7 @@ public:
|
|||
cProtocol125(cClientHandle * a_Client);
|
||||
|
||||
/// Called when client sends some data:
|
||||
virtual void DataReceived(const char * a_Data, int a_Size) override;
|
||||
virtual void DataReceived(const char * a_Data, size_t a_Size) override;
|
||||
|
||||
/// Sending stuff to clients (alphabetically sorted):
|
||||
virtual void SendAttachEntity (const cEntity & a_Entity, const cEntity * a_Vehicle) override;
|
||||
|
|
@ -57,9 +58,17 @@ public:
|
|||
virtual void SendLogin (const cPlayer & a_Player, const cWorld & a_World) override;
|
||||
virtual void SendMapColumn (int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length) override;
|
||||
virtual void SendMapDecorators (int a_ID, const cMapDecoratorList & a_Decorators) override;
|
||||
virtual void SendMapInfo (int a_ID, unsigned int a_Scale) override {} // This protocol doesn't support such message
|
||||
virtual void SendMapInfo (int a_ID, unsigned int a_Scale) override
|
||||
{
|
||||
// This protocol doesn't support such message
|
||||
UNUSED(a_ID);
|
||||
UNUSED(a_Scale);
|
||||
}
|
||||
virtual void SendParticleEffect (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount) override;
|
||||
virtual void SendPaintingSpawn (const cPainting & a_Painting) override {};
|
||||
virtual void SendPaintingSpawn (const cPainting & a_Painting) override
|
||||
{
|
||||
UNUSED(a_Painting);
|
||||
};
|
||||
virtual void SendPickupSpawn (const cPickup & a_Pickup) override;
|
||||
virtual void SendPlayerAbilities (void) override {} // This protocol doesn't support such message
|
||||
virtual void SendEntityAnimation (const cEntity & a_Entity, char a_Animation) override;
|
||||
|
|
@ -73,7 +82,12 @@ public:
|
|||
virtual void SendRespawn (void) override;
|
||||
virtual void SendExperience (void) override;
|
||||
virtual void SendExperienceOrb (const cExpOrb & a_ExpOrb) override;
|
||||
virtual void SendScoreboardObjective (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode) override {} // This protocol doesn't support such message
|
||||
virtual void SendScoreboardObjective (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode) override
|
||||
{
|
||||
UNUSED(a_Name);
|
||||
UNUSED(a_DisplayName);
|
||||
UNUSED(a_Mode);
|
||||
} // This protocol doesn't support such message
|
||||
virtual void SendScoreUpdate (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode) override {} // This protocol doesn't support such message
|
||||
virtual void SendDisplayObjective (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display) override {} // This protocol doesn't support such message
|
||||
virtual void SendSoundEffect (const AString & a_SoundName, int a_SrcX, int a_SrcY, int a_SrcZ, float a_Volume, float a_Pitch) override; // a_Src coords are Block * 8
|
||||
|
|
|
|||
|
|
@ -108,7 +108,7 @@ cProtocol132::~cProtocol132()
|
|||
|
||||
|
||||
|
||||
void cProtocol132::DataReceived(const char * a_Data, int a_Size)
|
||||
void cProtocol132::DataReceived(const char * a_Data, size_t a_Size)
|
||||
{
|
||||
if (m_IsEncrypted)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ public:
|
|||
virtual ~cProtocol132();
|
||||
|
||||
/// Called when client sends some data:
|
||||
virtual void DataReceived(const char * a_Data, int a_Size) override;
|
||||
virtual void DataReceived(const char * a_Data, size_t a_Size) override;
|
||||
|
||||
// Sending commands (alphabetically sorted):
|
||||
virtual void SendBlockAction (int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType) override;
|
||||
|
|
|
|||
|
|
@ -184,7 +184,16 @@ int cProtocol161::ParseEntityAction(void)
|
|||
HANDLE_PACKET_READ(ReadBEInt, int, EntityID);
|
||||
HANDLE_PACKET_READ(ReadChar, char, ActionID);
|
||||
HANDLE_PACKET_READ(ReadBEInt, int, UnknownHorseVal);
|
||||
m_Client->HandleEntityAction(EntityID, ActionID);
|
||||
|
||||
switch (ActionID)
|
||||
{
|
||||
case 1: m_Client->HandleEntityCrouch(EntityID, true); break; // Crouch
|
||||
case 2: m_Client->HandleEntityCrouch(EntityID, false); break; // Uncrouch
|
||||
case 3: m_Client->HandleEntityLeaveBed(EntityID); break; // Leave Bed
|
||||
case 4: m_Client->HandleEntitySprinting(EntityID, true); break; // Start sprinting
|
||||
case 5: m_Client->HandleEntitySprinting(EntityID, false); break; // Stop sprinting
|
||||
}
|
||||
|
||||
return PARSE_OK;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -98,7 +98,7 @@ cProtocol172::cProtocol172(cClientHandle * a_Client, const AString & a_ServerAdd
|
|||
|
||||
|
||||
|
||||
void cProtocol172::DataReceived(const char * a_Data, int a_Size)
|
||||
void cProtocol172::DataReceived(const char * a_Data, size_t a_Size)
|
||||
{
|
||||
if (m_IsEncrypted)
|
||||
{
|
||||
|
|
@ -1244,7 +1244,7 @@ void cProtocol172::AddReceivedData(const char * a_Data, int a_Size)
|
|||
if (m_ReceivedData.GetReadableSpace() > 0)
|
||||
{
|
||||
AString AllData;
|
||||
int OldReadableSpace = m_ReceivedData.GetReadableSpace();
|
||||
size_t OldReadableSpace = m_ReceivedData.GetReadableSpace();
|
||||
m_ReceivedData.ReadAll(AllData);
|
||||
m_ReceivedData.ResetRead();
|
||||
m_ReceivedData.SkipRead(m_ReceivedData.GetReadableSpace() - OldReadableSpace);
|
||||
|
|
@ -1366,7 +1366,7 @@ void cProtocol172::AddReceivedData(const char * a_Data, int a_Size)
|
|||
if (g_ShouldLogCommIn && (m_ReceivedData.GetReadableSpace() > 0))
|
||||
{
|
||||
AString AllData;
|
||||
int OldReadableSpace = m_ReceivedData.GetReadableSpace();
|
||||
size_t OldReadableSpace = m_ReceivedData.GetReadableSpace();
|
||||
m_ReceivedData.ReadAll(AllData);
|
||||
m_ReceivedData.ResetRead();
|
||||
m_ReceivedData.SkipRead(m_ReceivedData.GetReadableSpace() - OldReadableSpace);
|
||||
|
|
@ -1732,7 +1732,15 @@ void cProtocol172::HandlePacketEntityAction(cByteBuffer & a_ByteBuffer)
|
|||
HANDLE_READ(a_ByteBuffer, ReadBEInt, int, PlayerID);
|
||||
HANDLE_READ(a_ByteBuffer, ReadByte, Byte, Action);
|
||||
HANDLE_READ(a_ByteBuffer, ReadBEInt, int, JumpBoost);
|
||||
m_Client->HandleEntityAction(PlayerID, Action);
|
||||
|
||||
switch (Action)
|
||||
{
|
||||
case 1: m_Client->HandleEntityCrouch(PlayerID, true); break; // Crouch
|
||||
case 2: m_Client->HandleEntityCrouch(PlayerID, false); break; // Uncrouch
|
||||
case 3: m_Client->HandleEntityLeaveBed(PlayerID); break; // Leave Bed
|
||||
case 4: m_Client->HandleEntitySprinting(PlayerID, true); break; // Start sprinting
|
||||
case 5: m_Client->HandleEntitySprinting(PlayerID, false); break; // Stop sprinting
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -2071,36 +2079,47 @@ void cProtocol172::ParseItemMetadata(cItem & a_Item, const AString & a_Metadata)
|
|||
// Load enchantments and custom display names from the NBT data:
|
||||
for (int tag = NBT.GetFirstChild(NBT.GetRoot()); tag >= 0; tag = NBT.GetNextSibling(tag))
|
||||
{
|
||||
if (
|
||||
(NBT.GetType(tag) == TAG_List) &&
|
||||
(
|
||||
(NBT.GetName(tag) == "ench") ||
|
||||
(NBT.GetName(tag) == "StoredEnchantments")
|
||||
)
|
||||
)
|
||||
AString TagName = NBT.GetName(tag);
|
||||
switch (NBT.GetType(tag))
|
||||
{
|
||||
EnchantmentSerializer::ParseFromNBT(a_Item.m_Enchantments, NBT, tag);
|
||||
}
|
||||
else if ((NBT.GetType(tag) == TAG_Compound) && (NBT.GetName(tag) == "display")) // Custom name and lore tag
|
||||
{
|
||||
for (int displaytag = NBT.GetFirstChild(tag); displaytag >= 0; displaytag = NBT.GetNextSibling(displaytag))
|
||||
case TAG_List:
|
||||
{
|
||||
if ((NBT.GetType(displaytag) == TAG_String) && (NBT.GetName(displaytag) == "Name")) // Custon name tag
|
||||
if ((TagName == "ench") || (TagName == "StoredEnchantments")) // Enchantments tags
|
||||
{
|
||||
a_Item.m_CustomName = NBT.GetString(displaytag);
|
||||
}
|
||||
else if ((NBT.GetType(displaytag) == TAG_List) && (NBT.GetName(displaytag) == "Lore")) // Lore tag
|
||||
{
|
||||
AString Lore;
|
||||
|
||||
for (int loretag = NBT.GetFirstChild(displaytag); loretag >= 0; loretag = NBT.GetNextSibling(loretag)) // Loop through array of strings
|
||||
{
|
||||
AppendPrintf(Lore, "%s`", NBT.GetString(loretag).c_str()); // Append the lore with a newline, used internally by MCS to display a new line in the client; don't forget to c_str ;)
|
||||
}
|
||||
|
||||
a_Item.m_Lore = Lore;
|
||||
EnchantmentSerializer::ParseFromNBT(a_Item.m_Enchantments, NBT, tag);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case TAG_Compound:
|
||||
{
|
||||
if (TagName == "display") // Custom name and lore tag
|
||||
{
|
||||
for (int displaytag = NBT.GetFirstChild(tag); displaytag >= 0; displaytag = NBT.GetNextSibling(displaytag))
|
||||
{
|
||||
if ((NBT.GetType(displaytag) == TAG_String) && (NBT.GetName(displaytag) == "Name")) // Custon name tag
|
||||
{
|
||||
a_Item.m_CustomName = NBT.GetString(displaytag);
|
||||
}
|
||||
else if ((NBT.GetType(displaytag) == TAG_List) && (NBT.GetName(displaytag) == "Lore")) // Lore tag
|
||||
{
|
||||
AString Lore;
|
||||
|
||||
for (int loretag = NBT.GetFirstChild(displaytag); loretag >= 0; loretag = NBT.GetNextSibling(loretag)) // Loop through array of strings
|
||||
{
|
||||
AppendPrintf(Lore, "%s`", NBT.GetString(loretag).c_str()); // Append the lore with a newline, used internally by MCS to display a new line in the client; don't forget to c_str ;)
|
||||
}
|
||||
|
||||
a_Item.m_Lore = Lore;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if ((TagName == "Fireworks") || (TagName == "Explosion"))
|
||||
{
|
||||
cFireworkItem::ParseFromNBT(a_Item.m_FireworkItem, NBT, tag, (ENUM_ITEM_ID)a_Item.m_ItemType);
|
||||
}
|
||||
break;
|
||||
}
|
||||
default: LOGD("Unimplemented NBT data when parsing!"); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -2264,7 +2283,7 @@ void cProtocol172::cPacketizer::WriteItem(const cItem & a_Item)
|
|||
WriteByte (a_Item.m_ItemCount);
|
||||
WriteShort(a_Item.m_ItemDamage);
|
||||
|
||||
if (a_Item.m_Enchantments.IsEmpty() && a_Item.IsBothNameAndLoreEmpty())
|
||||
if (a_Item.m_Enchantments.IsEmpty() && a_Item.IsBothNameAndLoreEmpty() && (a_Item.m_ItemType != E_ITEM_FIREWORK_ROCKET) && (a_Item.m_ItemType != E_ITEM_FIREWORK_STAR))
|
||||
{
|
||||
WriteShort(-1);
|
||||
return;
|
||||
|
|
@ -2303,6 +2322,10 @@ void cProtocol172::cPacketizer::WriteItem(const cItem & a_Item)
|
|||
}
|
||||
Writer.EndCompound();
|
||||
}
|
||||
if ((a_Item.m_ItemType == E_ITEM_FIREWORK_ROCKET) || (a_Item.m_ItemType == E_ITEM_FIREWORK_STAR))
|
||||
{
|
||||
cFireworkItem::WriteToNBTCompound(a_Item.m_FireworkItem, Writer, (ENUM_ITEM_ID)a_Item.m_ItemType);
|
||||
}
|
||||
Writer.Finish();
|
||||
AString Compressed;
|
||||
CompressStringGZIP(Writer.GetResult().data(), Writer.GetResult().size(), Compressed);
|
||||
|
|
@ -2479,10 +2502,22 @@ void cProtocol172::cPacketizer::WriteEntityMetadata(const cEntity & a_Entity)
|
|||
}
|
||||
case cEntity::etProjectile:
|
||||
{
|
||||
if (((cProjectileEntity &)a_Entity).GetProjectileKind() == cProjectileEntity::pkArrow)
|
||||
cProjectileEntity & Projectile = (cProjectileEntity &)a_Entity;
|
||||
switch (Projectile.GetProjectileKind())
|
||||
{
|
||||
WriteByte(0x10);
|
||||
WriteByte(((const cArrowEntity &)a_Entity).IsCritical() ? 1 : 0);
|
||||
case cProjectileEntity::pkArrow:
|
||||
{
|
||||
WriteByte(0x10);
|
||||
WriteByte(((const cArrowEntity &)a_Entity).IsCritical() ? 1 : 0);
|
||||
break;
|
||||
}
|
||||
case cProjectileEntity::pkFirework:
|
||||
{
|
||||
WriteByte(0xA8);
|
||||
WriteItem(((const cFireworkEntity &)a_Entity).GetItem());
|
||||
break;
|
||||
}
|
||||
default: break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -56,7 +56,7 @@ public:
|
|||
cProtocol172(cClientHandle * a_Client, const AString & a_ServerAddress, UInt16 a_ServerPort, UInt32 a_State);
|
||||
|
||||
/** Called when client sends some data: */
|
||||
virtual void DataReceived(const char * a_Data, int a_Size) override;
|
||||
virtual void DataReceived(const char * a_Data, size_t a_Size) override;
|
||||
|
||||
/** Sending stuff to clients (alphabetically sorted): */
|
||||
virtual void SendAttachEntity (const cEntity & a_Entity, const cEntity * a_Vehicle) override;
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ AString cProtocolRecognizer::GetVersionTextFromInt(int a_ProtocolVersion)
|
|||
|
||||
|
||||
|
||||
void cProtocolRecognizer::DataReceived(const char * a_Data, int a_Size)
|
||||
void cProtocolRecognizer::DataReceived(const char * a_Data, size_t a_Size)
|
||||
{
|
||||
if (m_Protocol == NULL)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@ public:
|
|||
static AString GetVersionTextFromInt(int a_ProtocolVersion);
|
||||
|
||||
/// Called when client sends some data:
|
||||
virtual void DataReceived(const char * a_Data, int a_Size) override;
|
||||
virtual void DataReceived(const char * a_Data, size_t a_Size) override;
|
||||
|
||||
/// Sending stuff to clients (alphabetically sorted):
|
||||
virtual void SendAttachEntity (const cEntity & a_Entity, const cEntity * a_Vehicle) override;
|
||||
|
|
|
|||
|
|
@ -593,7 +593,6 @@ bool cRoot::FindAndDoWithPlayer(const AString & a_PlayerName, cPlayerListCallbac
|
|||
unsigned m_NameLength;
|
||||
const AString m_PlayerName;
|
||||
|
||||
cPlayerListCallback & m_Callback;
|
||||
virtual bool Item (cPlayer * a_pPlayer)
|
||||
{
|
||||
unsigned int Rating = RateCompareString (m_PlayerName, a_pPlayer->GetName());
|
||||
|
|
@ -615,18 +614,17 @@ bool cRoot::FindAndDoWithPlayer(const AString & a_PlayerName, cPlayerListCallbac
|
|||
}
|
||||
|
||||
public:
|
||||
cCallback (const AString & a_PlayerName, cPlayerListCallback & a_Callback) :
|
||||
cCallback (const AString & a_PlayerName) :
|
||||
m_BestRating(0),
|
||||
m_NameLength(a_PlayerName.length()),
|
||||
m_PlayerName(a_PlayerName),
|
||||
m_Callback(a_Callback),
|
||||
m_BestMatch(NULL),
|
||||
m_NumMatches(0)
|
||||
{}
|
||||
|
||||
cPlayer * m_BestMatch;
|
||||
unsigned m_NumMatches;
|
||||
} Callback (a_PlayerName, a_Callback);
|
||||
} Callback (a_PlayerName);
|
||||
ForEachPlayer( Callback );
|
||||
|
||||
if (Callback.m_NumMatches == 1)
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@
|
|||
bool cDelayedFluidSimulatorChunkData::cSlot::Add(int a_RelX, int a_RelY, int a_RelZ)
|
||||
{
|
||||
ASSERT(a_RelZ >= 0);
|
||||
ASSERT(a_RelZ < ARRAYCOUNT(m_Blocks));
|
||||
ASSERT(a_RelZ < static_cast<int>(ARRAYCOUNT(m_Blocks)));
|
||||
|
||||
cCoordWithIntVector & Blocks = m_Blocks[a_RelZ];
|
||||
int Index = cChunkDef::MakeIndexNoCheck(a_RelX, a_RelY, a_RelZ);
|
||||
|
|
|
|||
|
|
@ -334,21 +334,33 @@ void cFireSimulator::RemoveFuelNeighbors(cChunk * a_Chunk, int a_RelX, int a_Rel
|
|||
for (size_t i = 0; i < ARRAYCOUNT(gNeighborCoords); i++)
|
||||
{
|
||||
BLOCKTYPE BlockType;
|
||||
NIBBLETYPE BlockMeta;
|
||||
if (!a_Chunk->UnboundedRelGetBlock(a_RelX + gNeighborCoords[i].x, a_RelY + gNeighborCoords[i].y, a_RelZ + gNeighborCoords[i].z, BlockType, BlockMeta))
|
||||
int X = a_RelX + gNeighborCoords[i].x;
|
||||
int Z = a_RelZ + gNeighborCoords[i].z;
|
||||
|
||||
cChunkPtr Neighbour = a_Chunk->GetRelNeighborChunkAdjustCoords(X, Z);
|
||||
if (Neighbour == NULL)
|
||||
{
|
||||
// Neighbor not accessible, ignore it
|
||||
continue;
|
||||
}
|
||||
BlockType = Neighbour->GetBlock(X, a_RelY + gCrossCoords[i].y, Z);
|
||||
|
||||
if (!IsFuel(BlockType))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (BlockType == E_BLOCK_TNT)
|
||||
{
|
||||
int AbsX = X + Neighbour->GetPosX() * cChunkDef::Width;
|
||||
int AbsZ = Z + Neighbour->GetPosZ() * cChunkDef::Width;
|
||||
|
||||
m_World.SpawnPrimedTNT(AbsX, a_RelY + gNeighborCoords[i].y, AbsZ, 0);
|
||||
Neighbour->SetBlock(X, a_RelY + gNeighborCoords[i].y, Z, E_BLOCK_AIR, 0);
|
||||
return;
|
||||
}
|
||||
|
||||
bool ShouldReplaceFuel = (m_World.GetTickRandomNumber(MAX_CHANCE_REPLACE_FUEL) < m_ReplaceFuelChance);
|
||||
a_Chunk->UnboundedRelSetBlock(
|
||||
a_RelX + gNeighborCoords[i].x, a_RelY + gNeighborCoords[i].y, a_RelZ + gNeighborCoords[i].z,
|
||||
ShouldReplaceFuel ? E_BLOCK_FIRE : E_BLOCK_AIR, 0
|
||||
);
|
||||
Neighbour->SetBlock(X, a_RelY + gNeighborCoords[i].y, Z, ShouldReplaceFuel ? E_BLOCK_FIRE : E_BLOCK_AIR, 0);
|
||||
} // for i - Coords[]
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -838,7 +838,7 @@ void cIncrementalRedstoneSimulator::HandleTNT(int a_BlockX, int a_BlockY, int a_
|
|||
if (AreCoordsPowered(a_BlockX, a_BlockY, a_BlockZ))
|
||||
{
|
||||
m_World.BroadcastSoundEffect("game.tnt.primed", a_BlockX * 8, a_BlockY * 8, a_BlockZ * 8, 0.5f, 0.6f);
|
||||
m_World.SpawnPrimedTNT(a_BlockX + 0.5, a_BlockY + 0.5, a_BlockZ + 0.5, 4); // 4 seconds to boom
|
||||
m_World.SpawnPrimedTNT(a_BlockX + 0.5, a_BlockY + 0.5, a_BlockZ + 0.5); // 80 ticks to boom
|
||||
m_World.SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_AIR, 0);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,11 @@
|
|||
|
||||
// Vector3i.cpp
|
||||
|
||||
// Implements the Vector3i class representing an int-based 3D vector
|
||||
|
||||
#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules
|
||||
|
||||
#include "math.h"
|
||||
#include "Vector3i.h"
|
||||
#include "Vector3d.h"
|
||||
|
||||
|
|
@ -8,9 +13,46 @@
|
|||
|
||||
|
||||
|
||||
Vector3i::Vector3i( const Vector3d & v )
|
||||
: x( (int)v.x )
|
||||
, y( (int)v.y )
|
||||
, z( (int)v.z )
|
||||
Vector3i::Vector3i(const Vector3d & v) :
|
||||
x((int)v.x),
|
||||
y((int)v.y),
|
||||
z((int)v.z)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Vector3i::Vector3i(void) :
|
||||
x(0),
|
||||
y(0),
|
||||
z(0)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Vector3i::Vector3i(int a_x, int a_y, int a_z) :
|
||||
x(a_x),
|
||||
y(a_y),
|
||||
z(a_z)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void Vector3i::Move(int a_MoveX, int a_MoveY, int a_MoveZ)
|
||||
{
|
||||
x += a_MoveX;
|
||||
y += a_MoveY;
|
||||
z += a_MoveZ;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,22 +1,45 @@
|
|||
|
||||
// Vector3i.h
|
||||
|
||||
// Declares the Vector3i class representing an int-based 3D vector
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <math.h>
|
||||
|
||||
|
||||
|
||||
|
||||
// fwd:
|
||||
class Vector3d;
|
||||
class Vector3i // tolua_export
|
||||
{ // tolua_export
|
||||
public: // tolua_export
|
||||
Vector3i( const Vector3d & v ); // tolua_export
|
||||
|
||||
Vector3i() : x(0), y(0), z(0) {} // tolua_export
|
||||
Vector3i(int a_x, int a_y, int a_z) : x(a_x), y(a_y), z(a_z) {} // tolua_export
|
||||
|
||||
inline void Set(int a_x, int a_y, int a_z) { x = a_x, y = a_y, z = a_z; } // tolua_export
|
||||
inline float Length() const { return sqrtf( (float)( x * x + y * y + z * z) ); } // tolua_export
|
||||
inline int SqrLength() const { return x * x + y * y + z * z; } // tolua_export
|
||||
|
||||
inline bool Equals( const Vector3i & v ) const { return (x == v.x && y == v.y && z == v.z ); } // tolua_export
|
||||
inline bool Equals( const Vector3i * v ) const { return (x == v->x && y == v->y && z == v->z ); } // tolua_export
|
||||
|
||||
|
||||
// tolua_begin
|
||||
class Vector3i
|
||||
{
|
||||
public:
|
||||
/** Creates an int vector based on the floor()-ed coords of a double vector. */
|
||||
Vector3i(const Vector3d & v);
|
||||
|
||||
Vector3i(void);
|
||||
Vector3i(int a_x, int a_y, int a_z);
|
||||
|
||||
inline void Set(int a_x, int a_y, int a_z) { x = a_x, y = a_y, z = a_z; }
|
||||
inline float Length() const { return sqrtf( (float)( x * x + y * y + z * z) ); }
|
||||
inline int SqrLength() const { return x * x + y * y + z * z; }
|
||||
|
||||
inline bool Equals( const Vector3i & v ) const { return (x == v.x && y == v.y && z == v.z ); }
|
||||
inline bool Equals( const Vector3i * v ) const { return (x == v->x && y == v->y && z == v->z ); }
|
||||
|
||||
void Move(int a_MoveX, int a_MoveY, int a_MoveZ);
|
||||
|
||||
// tolua_end
|
||||
|
||||
void operator += ( const Vector3i& a_V ) { x += a_V.x; y += a_V.y; z += a_V.z; }
|
||||
void operator += ( Vector3i* a_V ) { x += a_V->x; y += a_V->y; z += a_V->z; }
|
||||
|
|
|
|||
|
|
@ -1726,10 +1726,10 @@ int cWorld::SpawnMinecart(double a_X, double a_Y, double a_Z, int a_MinecartType
|
|||
|
||||
|
||||
|
||||
void cWorld::SpawnPrimedTNT(double a_X, double a_Y, double a_Z, double a_FuseTimeInSec, double a_InitialVelocityCoeff)
|
||||
void cWorld::SpawnPrimedTNT(double a_X, double a_Y, double a_Z, int a_FuseTicks, double a_InitialVelocityCoeff)
|
||||
{
|
||||
UNUSED(a_InitialVelocityCoeff);
|
||||
cTNTEntity * TNT = new cTNTEntity(a_X, a_Y, a_Z, a_FuseTimeInSec);
|
||||
cTNTEntity * TNT = new cTNTEntity(a_X, a_Y, a_Z, a_FuseTicks);
|
||||
TNT->Initialize(this);
|
||||
// TODO: Add a bit of speed in horiz and vert axes, based on the a_InitialVelocityCoeff
|
||||
}
|
||||
|
|
@ -2980,9 +2980,9 @@ int cWorld::SpawnMobFinalize(cMonster * a_Monster)
|
|||
|
||||
|
||||
|
||||
int cWorld::CreateProjectile(double a_PosX, double a_PosY, double a_PosZ, cProjectileEntity::eKind a_Kind, cEntity * a_Creator, const Vector3d * a_Speed)
|
||||
int cWorld::CreateProjectile(double a_PosX, double a_PosY, double a_PosZ, cProjectileEntity::eKind a_Kind, cEntity * a_Creator, const cItem a_Item, const Vector3d * a_Speed)
|
||||
{
|
||||
cProjectileEntity * Projectile = cProjectileEntity::Create(a_Kind, a_Creator, a_PosX, a_PosY, a_PosZ, a_Speed);
|
||||
cProjectileEntity * Projectile = cProjectileEntity::Create(a_Kind, a_Creator, a_PosX, a_PosY, a_PosZ, a_Item, a_Speed);
|
||||
if (Projectile == NULL)
|
||||
{
|
||||
return -1;
|
||||
|
|
@ -3005,18 +3005,18 @@ void cWorld::TabCompleteUserName(const AString & a_Text, AStringVector & a_Resul
|
|||
cCSLock Lock(m_CSPlayers);
|
||||
for (cPlayerList::iterator itr = m_Players.begin(), end = m_Players.end(); itr != end; ++itr)
|
||||
{
|
||||
size_t LastSpace = a_Text.find_last_of(" "); //Find the position of the last space
|
||||
size_t LastSpace = a_Text.find_last_of(" "); // Find the position of the last space
|
||||
|
||||
std::string LastWord = a_Text.substr(LastSpace + 1, a_Text.length()); //Find the last word
|
||||
std::string PlayerName ((*itr)->GetName());
|
||||
std::size_t Found = PlayerName.find(LastWord); //Try to find last word in playername
|
||||
AString LastWord = a_Text.substr(LastSpace + 1, a_Text.length()); // Find the last word
|
||||
AString PlayerName ((*itr)->GetName());
|
||||
size_t Found = PlayerName.find(LastWord); // Try to find last word in playername
|
||||
|
||||
if (Found!=0)
|
||||
if (Found == AString::npos)
|
||||
{
|
||||
continue; //No match
|
||||
continue; // No match
|
||||
}
|
||||
|
||||
a_Results.push_back((*itr)->GetName()); //Match!
|
||||
a_Results.push_back(PlayerName); // Match!
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -445,7 +445,7 @@ public:
|
|||
int SpawnExperienceOrb(double a_X, double a_Y, double a_Z, int a_Reward);
|
||||
|
||||
/** Spawns a new primed TNT entity at the specified block coords and specified fuse duration. Initial velocity is given based on the relative coefficient provided */
|
||||
void SpawnPrimedTNT(double a_X, double a_Y, double a_Z, double a_FuseTimeInSec, double a_InitialVelocityCoeff = 1);
|
||||
void SpawnPrimedTNT(double a_X, double a_Y, double a_Z, int a_FuseTimeInSec = 80, double a_InitialVelocityCoeff = 1);
|
||||
|
||||
// tolua_end
|
||||
|
||||
|
|
@ -708,7 +708,7 @@ public:
|
|||
int SpawnMobFinalize(cMonster* a_Monster);
|
||||
|
||||
/** Creates a projectile of the specified type. Returns the projectile's EntityID if successful, <0 otherwise */
|
||||
int CreateProjectile(double a_PosX, double a_PosY, double a_PosZ, cProjectileEntity::eKind a_Kind, cEntity * a_Creator, const Vector3d * a_Speed = NULL); // tolua_export
|
||||
int CreateProjectile(double a_PosX, double a_PosY, double a_PosZ, cProjectileEntity::eKind a_Kind, cEntity * a_Creator, const cItem a_Item, const Vector3d * a_Speed = NULL); // tolua_export
|
||||
|
||||
/** Returns a random number from the m_TickRand in range [0 .. a_Range]. To be used only in the tick thread! */
|
||||
int GetTickRandomNumber(unsigned a_Range) { return (int)(m_TickRand.randInt(a_Range)); }
|
||||
|
|
|
|||
|
|
@ -309,7 +309,7 @@ protected:
|
|||
eTagType m_ItemType; // for TAG_List, the element type
|
||||
} ;
|
||||
|
||||
static const int MAX_STACK = 50; // Highliy doubtful that an NBT would be constructed this many levels deep
|
||||
static const int MAX_STACK = 50; // Highly doubtful that an NBT would be constructed this many levels deep
|
||||
|
||||
// These two fields emulate a stack. A raw array is used due to speed issues - no reallocations are allowed.
|
||||
sParent m_Stack[MAX_STACK];
|
||||
|
|
|
|||
|
|
@ -0,0 +1,252 @@
|
|||
|
||||
#include "Globals.h"
|
||||
#include "FireworksSerializer.h"
|
||||
#include "WorldStorage/FastNBT.h"
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cFireworkItem::WriteToNBTCompound(const cFireworkItem & a_FireworkItem, cFastNBTWriter & a_Writer, const ENUM_ITEM_ID a_Type)
|
||||
{
|
||||
switch (a_Type)
|
||||
{
|
||||
case E_ITEM_FIREWORK_ROCKET:
|
||||
{
|
||||
a_Writer.BeginCompound("Fireworks");
|
||||
a_Writer.AddByte("Flight", a_FireworkItem.m_FlightTimeInTicks / 20);
|
||||
a_Writer.BeginList("Explosions", TAG_Compound);
|
||||
a_Writer.BeginCompound("");
|
||||
a_Writer.AddByte("Flicker", a_FireworkItem.m_HasFlicker);
|
||||
a_Writer.AddByte("Trail", a_FireworkItem.m_HasTrail);
|
||||
a_Writer.AddByte("Type", a_FireworkItem.m_Type);
|
||||
a_Writer.AddIntArray("Colors", &(a_FireworkItem.m_Colours[0]), a_FireworkItem.m_Colours.size());
|
||||
a_Writer.AddIntArray("FadeColors", &(a_FireworkItem.m_FadeColours[0]), a_FireworkItem.m_FadeColours.size());
|
||||
a_Writer.EndCompound();
|
||||
a_Writer.EndList();
|
||||
a_Writer.EndCompound();
|
||||
break;
|
||||
}
|
||||
case E_ITEM_FIREWORK_STAR:
|
||||
{
|
||||
a_Writer.BeginCompound("Explosion");
|
||||
a_Writer.AddByte("Flicker", a_FireworkItem.m_HasFlicker);
|
||||
a_Writer.AddByte("Trail", a_FireworkItem.m_HasTrail);
|
||||
a_Writer.AddByte("Type", a_FireworkItem.m_Type);
|
||||
if (!a_FireworkItem.m_Colours.empty())
|
||||
{
|
||||
a_Writer.AddIntArray("Colors", &(a_FireworkItem.m_Colours[0]), a_FireworkItem.m_Colours.size());
|
||||
}
|
||||
if (!a_FireworkItem.m_FadeColours.empty())
|
||||
{
|
||||
a_Writer.AddIntArray("FadeColors", &(a_FireworkItem.m_FadeColours[0]), a_FireworkItem.m_FadeColours.size());
|
||||
}
|
||||
a_Writer.EndCompound();
|
||||
break;
|
||||
}
|
||||
default: ASSERT(!"Unhandled firework item!"); break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cFireworkItem::ParseFromNBT(cFireworkItem & a_FireworkItem, const cParsedNBT & a_NBT, int a_TagIdx, const ENUM_ITEM_ID a_Type)
|
||||
{
|
||||
if (a_TagIdx < 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
switch (a_Type)
|
||||
{
|
||||
case E_ITEM_FIREWORK_STAR:
|
||||
{
|
||||
for (int explosiontag = a_NBT.GetFirstChild(a_TagIdx); explosiontag >= 0; explosiontag = a_NBT.GetNextSibling(explosiontag))
|
||||
{
|
||||
eTagType TagType = a_NBT.GetType(explosiontag);
|
||||
if (TagType == TAG_Byte) // Custon name tag
|
||||
{
|
||||
AString ExplosionName = a_NBT.GetName(explosiontag);
|
||||
|
||||
if (ExplosionName == "Flicker")
|
||||
{
|
||||
a_FireworkItem.m_HasFlicker = (a_NBT.GetByte(explosiontag) == 1);
|
||||
}
|
||||
else if (ExplosionName == "Trail")
|
||||
{
|
||||
a_FireworkItem.m_HasTrail = (a_NBT.GetByte(explosiontag) == 1);
|
||||
}
|
||||
else if (ExplosionName == "Type")
|
||||
{
|
||||
a_FireworkItem.m_Type = a_NBT.GetByte(explosiontag);
|
||||
}
|
||||
}
|
||||
else if (TagType == TAG_IntArray)
|
||||
{
|
||||
AString ExplosionName = a_NBT.GetName(explosiontag);
|
||||
|
||||
if (ExplosionName == "Colors")
|
||||
{
|
||||
// Divide by four as data length returned in bytes
|
||||
int DataLength = a_NBT.GetDataLength(explosiontag) / 4;
|
||||
if (DataLength == 0)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
const int * ColourData = (const int *)(a_NBT.GetData(explosiontag));
|
||||
for (int i = 0; i < DataLength; i++)
|
||||
{
|
||||
a_FireworkItem.m_Colours.push_back(ntohl(ColourData[i]));
|
||||
}
|
||||
}
|
||||
else if (ExplosionName == "FadeColors")
|
||||
{
|
||||
int DataLength = a_NBT.GetDataLength(explosiontag) / 4;
|
||||
if (DataLength == 0)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
const int * FadeColourData = (const int *)(a_NBT.GetData(explosiontag));
|
||||
for (int i = 0; i < DataLength; i++)
|
||||
{
|
||||
a_FireworkItem.m_FadeColours.push_back(ntohl(FadeColourData[i]));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case E_ITEM_FIREWORK_ROCKET:
|
||||
{
|
||||
for (int fireworkstag = a_NBT.GetFirstChild(a_TagIdx); fireworkstag >= 0; fireworkstag = a_NBT.GetNextSibling(fireworkstag))
|
||||
{
|
||||
eTagType TagType = a_NBT.GetType(fireworkstag);
|
||||
if (TagType == TAG_Byte) // Custon name tag
|
||||
{
|
||||
if (a_NBT.GetName(fireworkstag) == "Flight")
|
||||
{
|
||||
a_FireworkItem.m_FlightTimeInTicks = a_NBT.GetByte(fireworkstag) * 20;
|
||||
}
|
||||
}
|
||||
else if ((TagType == TAG_List) && (a_NBT.GetName(fireworkstag) == "Explosions"))
|
||||
{
|
||||
int ExplosionsChild = a_NBT.GetFirstChild(fireworkstag);
|
||||
if ((a_NBT.GetType(ExplosionsChild) == TAG_Compound) && (a_NBT.GetName(ExplosionsChild).empty()))
|
||||
{
|
||||
ParseFromNBT(a_FireworkItem, a_NBT, ExplosionsChild, E_ITEM_FIREWORK_STAR);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
default: ASSERT(!"Unhandled firework item!"); break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
AString cFireworkItem::ColoursToString(const cFireworkItem & a_FireworkItem)
|
||||
{
|
||||
AString Result;
|
||||
|
||||
for (std::vector<int>::const_iterator itr = a_FireworkItem.m_Colours.begin(); itr != a_FireworkItem.m_Colours.end(); ++itr)
|
||||
{
|
||||
AppendPrintf(Result, "%i;", *itr);
|
||||
}
|
||||
|
||||
return Result;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cFireworkItem::ColoursFromString(const AString & a_String, cFireworkItem & a_FireworkItem)
|
||||
{
|
||||
AStringVector Split = StringSplit(a_String, ";");
|
||||
|
||||
for (size_t itr = 0; itr < Split.size(); ++itr)
|
||||
{
|
||||
if (Split[itr].empty())
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
a_FireworkItem.m_Colours.push_back(atoi(Split[itr].c_str()));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
AString cFireworkItem::FadeColoursToString(const cFireworkItem & a_FireworkItem)
|
||||
{
|
||||
AString Result;
|
||||
|
||||
for (std::vector<int>::const_iterator itr = a_FireworkItem.m_FadeColours.begin(); itr != a_FireworkItem.m_FadeColours.end(); ++itr)
|
||||
{
|
||||
AppendPrintf(Result, "%i;", *itr);
|
||||
}
|
||||
|
||||
return Result;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cFireworkItem::FadeColoursFromString(const AString & a_String, cFireworkItem & a_FireworkItem)
|
||||
{
|
||||
AStringVector Split = StringSplit(a_String, ";");
|
||||
|
||||
for (size_t itr = 0; itr < Split.size(); ++itr)
|
||||
{
|
||||
if (Split[itr].empty())
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
a_FireworkItem.m_FadeColours.push_back(atoi(Split[itr].c_str()));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
int cFireworkItem::GetVanillaColourCodeFromDye(short a_DyeMeta)
|
||||
{
|
||||
/*
|
||||
Colours are supposed to be calculated via: R << 16 + G << 8 + B
|
||||
However, the RGB values fireworks use aren't the same as the ones for dyes (the ones listed in the MC Wiki)
|
||||
Therefore, here is a list of numbers gotten via the Protocol Proxy
|
||||
*/
|
||||
|
||||
switch (a_DyeMeta)
|
||||
{
|
||||
case E_META_DYE_BLACK: return 0x1E1B1B;
|
||||
case E_META_DYE_RED: return 0xB3312C;
|
||||
case E_META_DYE_GREEN: return 0x3B511A;
|
||||
case E_META_DYE_BROWN: return 0x51301A;
|
||||
case E_META_DYE_BLUE: return 0x253192;
|
||||
case E_META_DYE_PURPLE: return 0x7B2FBE;
|
||||
case E_META_DYE_CYAN: return 0x287697;
|
||||
case E_META_DYE_LIGHTGRAY: return 0xABABAB;
|
||||
case E_META_DYE_GRAY: return 0x434343;
|
||||
case E_META_DYE_PINK: return 0xD88198;
|
||||
case E_META_DYE_LIGHTGREEN: return 0x41CD34;
|
||||
case E_META_DYE_YELLOW: return 0xDECF2A;
|
||||
case E_META_DYE_LIGHTBLUE: return 0x6689D3;
|
||||
case E_META_DYE_MAGENTA: return 0xC354CD;
|
||||
case E_META_DYE_ORANGE: return 0xEB8844;
|
||||
case E_META_DYE_WHITE: return 0xF0F0F0;
|
||||
default: ASSERT(!"Unhandled dye meta whilst trying to get colour code for fireworks!"); return 0;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,92 @@
|
|||
|
||||
// FireworksSerializer.h
|
||||
|
||||
// Declares the cFireworkItem class representing a firework or firework star
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "Defines.h"
|
||||
|
||||
class cFastNBTWriter;
|
||||
class cParsedNBT;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
class cFireworkItem
|
||||
{
|
||||
public:
|
||||
cFireworkItem(void) :
|
||||
m_HasFlicker(false),
|
||||
m_HasTrail(false),
|
||||
m_Type(0),
|
||||
m_FlightTimeInTicks(0)
|
||||
{
|
||||
}
|
||||
|
||||
inline void CopyFrom(const cFireworkItem & a_Item)
|
||||
{
|
||||
m_FlightTimeInTicks = a_Item.m_FlightTimeInTicks;
|
||||
m_HasFlicker = a_Item.m_HasFlicker;
|
||||
m_HasTrail = a_Item.m_HasTrail;
|
||||
m_Type = a_Item.m_Type;
|
||||
m_Colours = a_Item.m_Colours;
|
||||
m_FadeColours = a_Item.m_FadeColours;
|
||||
}
|
||||
|
||||
inline void EmptyData(void)
|
||||
{
|
||||
m_FlightTimeInTicks = 0;
|
||||
m_HasFlicker = false;
|
||||
m_Type = 0;
|
||||
m_HasTrail = false;
|
||||
m_Colours.clear();
|
||||
m_FadeColours.clear();
|
||||
}
|
||||
|
||||
inline bool IsEqualTo(const cFireworkItem & a_Item) const
|
||||
{
|
||||
return
|
||||
(
|
||||
(m_FlightTimeInTicks == a_Item.m_FlightTimeInTicks) &&
|
||||
(m_HasFlicker == a_Item.m_HasFlicker) &&
|
||||
(m_HasTrail == a_Item.m_HasTrail) &&
|
||||
(m_Type == a_Item.m_Type) &&
|
||||
(m_Colours == a_Item.m_Colours) &&
|
||||
(m_FadeColours == a_Item.m_FadeColours)
|
||||
);
|
||||
}
|
||||
|
||||
/** Writes firework NBT data to a Writer object */
|
||||
static void WriteToNBTCompound(const cFireworkItem & a_FireworkItem, cFastNBTWriter & a_Writer, const ENUM_ITEM_ID a_Type);
|
||||
|
||||
/** Reads NBT data from a NBT object and populates a FireworkItem with it */
|
||||
static void ParseFromNBT(cFireworkItem & a_FireworkItem, const cParsedNBT & a_NBT, int a_TagIdx, const ENUM_ITEM_ID a_Type);
|
||||
|
||||
/** Converts the firework's vector of colours into a string of values separated by a semicolon */
|
||||
static AString ColoursToString(const cFireworkItem & a_FireworkItem);
|
||||
|
||||
/** Parses a string containing encoded firework colours and populates a FireworkItem with it */
|
||||
static void ColoursFromString(const AString & a_String, cFireworkItem & a_FireworkItem);
|
||||
|
||||
/** Converts the firework's vector of fade colours into a string of values separated by a semicolon */
|
||||
static AString FadeColoursToString(const cFireworkItem & a_FireworkItem);
|
||||
|
||||
/** Parses a string containing encoded firework fade colours and populates a FireworkItem with it */
|
||||
static void FadeColoursFromString(const AString & a_String, cFireworkItem & a_FireworkItem);
|
||||
|
||||
/** Returns a colour code for fireworks used by the network code */
|
||||
static int GetVanillaColourCodeFromDye(short a_DyeMeta);
|
||||
|
||||
bool m_HasFlicker;
|
||||
bool m_HasTrail;
|
||||
NIBBLETYPE m_Type;
|
||||
short m_FlightTimeInTicks;
|
||||
std::vector<int> m_Colours;
|
||||
std::vector<int> m_FadeColours;
|
||||
};
|
||||
|
|
@ -28,6 +28,7 @@
|
|||
#include "../Entities/Minecart.h"
|
||||
#include "../Entities/Pickup.h"
|
||||
#include "../Entities/ProjectileEntity.h"
|
||||
#include "../Entities/TNTEntity.h"
|
||||
|
||||
#include "../Mobs/Monster.h"
|
||||
#include "../Mobs/Bat.h"
|
||||
|
|
@ -91,11 +92,19 @@ void cNBTChunkSerializer::AddItem(const cItem & a_Item, int a_Slot, const AStrin
|
|||
}
|
||||
|
||||
// Write the enchantments:
|
||||
if (!a_Item.m_Enchantments.IsEmpty())
|
||||
if (!a_Item.m_Enchantments.IsEmpty() || ((a_Item.m_ItemType == E_ITEM_FIREWORK_ROCKET) || (a_Item.m_ItemType == E_ITEM_FIREWORK_STAR)))
|
||||
{
|
||||
const char * TagName = (a_Item.m_ItemType == E_ITEM_BOOK) ? "StoredEnchantments" : "ench";
|
||||
m_Writer.BeginCompound("tag");
|
||||
EnchantmentSerializer::WriteToNBTCompound(a_Item.m_Enchantments, m_Writer, TagName);
|
||||
if ((a_Item.m_ItemType == E_ITEM_FIREWORK_ROCKET) || (a_Item.m_ItemType == E_ITEM_FIREWORK_STAR))
|
||||
{
|
||||
cFireworkItem::WriteToNBTCompound(a_Item.m_FireworkItem, m_Writer, (ENUM_ITEM_ID)a_Item.m_ItemType);
|
||||
}
|
||||
|
||||
if (!a_Item.m_Enchantments.IsEmpty())
|
||||
{
|
||||
const char * TagName = (a_Item.m_ItemType == E_ITEM_BOOK) ? "StoredEnchantments" : "ench";
|
||||
EnchantmentSerializer::WriteToNBTCompound(a_Item.m_Enchantments, m_Writer, TagName);
|
||||
}
|
||||
m_Writer.EndCompound();
|
||||
}
|
||||
|
||||
|
|
@ -583,6 +592,18 @@ void cNBTChunkSerializer::AddProjectileEntity(cProjectileEntity * a_Projectile)
|
|||
|
||||
|
||||
|
||||
void cNBTChunkSerializer::AddTNTEntity(cTNTEntity * a_TNT)
|
||||
{
|
||||
m_Writer.BeginCompound("");
|
||||
AddBasicEntity(a_TNT, "PrimedTnt");
|
||||
m_Writer.AddByte("Fuse", (unsigned char)a_TNT->GetFuseTicks());
|
||||
m_Writer.EndCompound();
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cNBTChunkSerializer::AddMinecartChestContents(cMinecartWithChest * a_Minecart)
|
||||
{
|
||||
m_Writer.BeginList("Items", TAG_Compound);
|
||||
|
|
@ -662,7 +683,7 @@ void cNBTChunkSerializer::Entity(cEntity * a_Entity)
|
|||
case cEntity::etMonster: AddMonsterEntity ((cMonster *) a_Entity); break;
|
||||
case cEntity::etPickup: AddPickupEntity ((cPickup *) a_Entity); break;
|
||||
case cEntity::etProjectile: AddProjectileEntity ((cProjectileEntity *)a_Entity); break;
|
||||
case cEntity::etTNT: /* TODO */ break;
|
||||
case cEntity::etTNT: AddTNTEntity ((cTNTEntity *) a_Entity); break;
|
||||
case cEntity::etExpOrb: /* TODO */ break;
|
||||
case cEntity::etItemFrame: /* TODO */ break;
|
||||
case cEntity::etPainting: /* TODO */ break;
|
||||
|
|
|
|||
|
|
@ -41,6 +41,7 @@ class cMonster;
|
|||
class cPickup;
|
||||
class cItemGrid;
|
||||
class cProjectileEntity;
|
||||
class cTNTEntity;
|
||||
|
||||
|
||||
|
||||
|
|
@ -107,6 +108,7 @@ protected:
|
|||
void AddMonsterEntity (cMonster * a_Monster);
|
||||
void AddPickupEntity (cPickup * a_Pickup);
|
||||
void AddProjectileEntity (cProjectileEntity * a_Projectile);
|
||||
void AddTNTEntity (cTNTEntity * a_TNT);
|
||||
|
||||
void AddMinecartChestContents(cMinecartWithChest * a_Minecart);
|
||||
|
||||
|
|
|
|||
|
|
@ -36,6 +36,7 @@
|
|||
#include "../Entities/Minecart.h"
|
||||
#include "../Entities/Pickup.h"
|
||||
#include "../Entities/ProjectileEntity.h"
|
||||
#include "../Entities/TNTEntity.h"
|
||||
|
||||
|
||||
|
||||
|
|
@ -663,6 +664,12 @@ bool cWSSAnvil::LoadItemFromNBT(cItem & a_Item, const cParsedNBT & a_NBT, int a_
|
|||
{
|
||||
EnchantmentSerializer::ParseFromNBT(a_Item.m_Enchantments, a_NBT, EnchTag);
|
||||
}
|
||||
|
||||
int FireworksTag = a_NBT.FindChildByName(TagTag, ((a_Item.m_ItemType == E_ITEM_FIREWORK_STAR) ? "Fireworks" : "Explosion"));
|
||||
if (EnchTag > 0)
|
||||
{
|
||||
cFireworkItem::ParseFromNBT(a_Item.m_FireworkItem, a_NBT, FireworksTag, (ENUM_ITEM_ID)a_Item.m_ItemType);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
|
@ -1231,6 +1238,10 @@ void cWSSAnvil::LoadEntityFromNBT(cEntityList & a_Entities, const cParsedNBT & a
|
|||
{
|
||||
LoadPigZombieFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
|
||||
}
|
||||
else if (strncmp(a_IDTag, "PrimedTnt", a_IDTagLength) == 0)
|
||||
{
|
||||
LoadTNTFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
|
||||
}
|
||||
// TODO: other entities
|
||||
}
|
||||
|
||||
|
|
@ -2167,6 +2178,28 @@ void cWSSAnvil::LoadPigZombieFromNBT(cEntityList & a_Entities, const cParsedNBT
|
|||
|
||||
|
||||
|
||||
void cWSSAnvil::LoadTNTFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx)
|
||||
{
|
||||
std::auto_ptr<cTNTEntity> TNT(new cTNTEntity(0.0, 0.0, 0.0, 0));
|
||||
if (!LoadEntityBaseFromNBT(*TNT.get(), a_NBT, a_TagIdx))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// Load Fuse Ticks:
|
||||
int FuseTicks = a_NBT.FindChildByName(a_TagIdx, "Fuse");
|
||||
if (FuseTicks > 0)
|
||||
{
|
||||
TNT->SetFuseTicks((int) a_NBT.GetByte(FuseTicks));
|
||||
}
|
||||
|
||||
a_Entities.push_back(TNT.release());
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
bool cWSSAnvil::LoadEntityBaseFromNBT(cEntity & a_Entity, const cParsedNBT & a_NBT, int a_TagIdx)
|
||||
{
|
||||
double Pos[3];
|
||||
|
|
|
|||
|
|
@ -192,6 +192,7 @@ protected:
|
|||
void LoadWolfFromNBT (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
|
||||
void LoadZombieFromNBT (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
|
||||
void LoadPigZombieFromNBT (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
|
||||
void LoadTNTFromNBT (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
|
||||
|
||||
/// Loads entity common data from the NBT compound; returns true if successful
|
||||
bool LoadEntityBaseFromNBT(cEntity & a_Entity, const cParsedNBT & a_NBT, int a_TagIdx);
|
||||
|
|
|
|||
Loading…
Reference in New Issue