forked from Kolyah35/minecraft-pe-0.6.1
243 lines
7.4 KiB
C++
Executable File
243 lines
7.4 KiB
C++
Executable File
#include "DoorTile.h"
|
|
#include "LevelEvent.h"
|
|
#include "../Level.h"
|
|
#include "../../item/Item.h"
|
|
#include "../../entity/player/Player.h"
|
|
|
|
DoorTile::DoorTile(int id, const Material* material)
|
|
: super(id, material)
|
|
{
|
|
tex = 1 + 6 * 16;
|
|
if (material == Material::metal) tex++;
|
|
|
|
float r = 0.5f;
|
|
float h = 1.0f;
|
|
super::setShape(0.5f - r, 0, 0.5f - r, 0.5f + r, h, 0.5f + r);
|
|
}
|
|
|
|
int DoorTile::getTexture(LevelSource* level, int x, int y, int z, int face) {
|
|
if (face == 0 || face == 1) return tex;
|
|
|
|
int compositeData = getCompositeData(level, x, y, z);
|
|
int texture = tex;
|
|
if ((compositeData & C_IS_UPPER_MASK) != 0) texture -= 16;
|
|
|
|
int dir = compositeData & C_DIR_MASK;
|
|
bool isOpen = (compositeData & C_OPEN_MASK) != 0;
|
|
if (isOpen) {
|
|
if (dir == 0 && face == 2) texture = -texture;
|
|
else if (dir == 1 && face == 5) texture = -texture;
|
|
else if (dir == 2 && face == 3) texture = -texture;
|
|
else if (dir == 3 && face == 4) texture = -texture;
|
|
} else {
|
|
if (dir == 0 && face == 5) texture = -texture;
|
|
else if (dir == 1 && face == 3) texture = -texture;
|
|
else if (dir == 2 && face == 4) texture = -texture;
|
|
else if (dir == 3 && face == 2) texture = -texture;
|
|
if ((compositeData & C_RIGHT_HINGE_MASK) != 0) texture = -texture;
|
|
}
|
|
|
|
return texture;
|
|
}
|
|
|
|
bool DoorTile::blocksLight() {
|
|
return false;
|
|
}
|
|
|
|
bool DoorTile::isSolidRender() {
|
|
return false;
|
|
}
|
|
|
|
bool DoorTile::isCubeShaped() {
|
|
return false;
|
|
}
|
|
|
|
int DoorTile::getRenderShape() {
|
|
return Tile::SHAPE_DOOR;
|
|
}
|
|
|
|
int DoorTile::getRenderLayer() {
|
|
return Tile::RENDERLAYER_ALPHATEST;
|
|
}
|
|
|
|
AABB DoorTile::getTileAABB(Level* level, int x, int y, int z) {
|
|
updateShape(level, x, y, z);
|
|
return super::getTileAABB(level, x, y, z);
|
|
}
|
|
|
|
AABB* DoorTile::getAABB(Level* level, int x, int y, int z) {
|
|
updateShape(level, x, y, z);
|
|
return super::getAABB(level, x, y, z);
|
|
}
|
|
|
|
void DoorTile::updateShape(LevelSource* level, int x, int y, int z) {
|
|
setShape(getCompositeData(level, x, y, z));
|
|
}
|
|
|
|
void DoorTile::setShape(int compositeData) {
|
|
float r = 3 / 16.0f;
|
|
super::setShape(0, 0, 0, 1, 2, 1);
|
|
int dir = compositeData & C_DIR_MASK;
|
|
bool open = (compositeData & C_OPEN_MASK) != 0;
|
|
bool hasRightHinge = (compositeData & C_RIGHT_HINGE_MASK) != 0;
|
|
if (dir == 0) {
|
|
if (open) {
|
|
if (!hasRightHinge) super::setShape(0, 0, 0, 1, 1, r);
|
|
else super::setShape(0, 0, 1 - r, 1, 1, 1);
|
|
} else super::setShape(0, 0, 0, r, 1, 1);
|
|
} else if (dir == 1) {
|
|
if (open) {
|
|
if (!hasRightHinge) super::setShape(1 - r, 0, 0, 1, 1, 1);
|
|
else super::setShape(0, 0, 0, r, 1, 1);
|
|
} else super::setShape(0, 0, 0, 1, 1, r);
|
|
} else if (dir == 2) {
|
|
if (open) {
|
|
if (!hasRightHinge) super::setShape(0, 0, 1 - r, 1, 1, 1);
|
|
else super::setShape(0, 0, 0, 1, 1, r);
|
|
} else super::setShape(1 - r, 0, 0, 1, 1, 1);
|
|
} else if (dir == 3) {
|
|
if (open) {
|
|
if (!hasRightHinge) super::setShape(0, 0, 0, r, 1, 1);
|
|
else super::setShape(1 - r, 0, 0, 1, 1, 1);
|
|
} else super::setShape(0, 0, 1 - r, 1, 1, 1);
|
|
}
|
|
}
|
|
|
|
void DoorTile::attack(Level* level, int x, int y, int z, Player* player) {
|
|
use(level, x, y, z, player);
|
|
}
|
|
|
|
bool DoorTile::use(Level* level, int x, int y, int z, Player* player) {
|
|
if (material == Material::metal) return true;
|
|
|
|
int compositeData = getCompositeData(level, x, y, z);
|
|
int lowerData = compositeData & C_LOWER_DATA_MASK;
|
|
lowerData ^= 4;
|
|
if ((compositeData & C_IS_UPPER_MASK) == 0) {
|
|
level->setData(x, y, z, lowerData);
|
|
level->setTilesDirty(x, y, z, x, y, z);
|
|
} else {
|
|
level->setData(x, y - 1, z, lowerData);
|
|
level->setTilesDirty(x, y - 1, z, x, y, z);
|
|
}
|
|
|
|
level->levelEvent(player, LevelEvent::SOUND_OPEN_DOOR, x, y, z, 0);
|
|
return true;
|
|
}
|
|
|
|
bool DoorTile::isOpen( LevelSource* level, int x, int y, int z )
|
|
{
|
|
return (getCompositeData(level, x, y, z) & C_OPEN_MASK) != 0;
|
|
}
|
|
|
|
void DoorTile::setOpen(Level* level, int x, int y, int z, bool shouldOpen) {
|
|
int compositeData = getCompositeData(level, x, y, z);
|
|
bool isOpen = (compositeData & C_OPEN_MASK) != 0;
|
|
if (isOpen == shouldOpen) return;
|
|
|
|
int lowerData = compositeData & C_LOWER_DATA_MASK;
|
|
lowerData ^= 4;
|
|
if ((compositeData & C_IS_UPPER_MASK) == 0) {
|
|
level->setData(x, y, z, lowerData);
|
|
level->setTilesDirty(x, y, z, x, y, z);
|
|
} else {
|
|
level->setData(x, y - 1, z, lowerData);
|
|
level->setTilesDirty(x, y - 1, z, x, y, z);
|
|
}
|
|
|
|
level->levelEvent(NULL, LevelEvent::SOUND_OPEN_DOOR, x, y, z, 0);
|
|
}
|
|
|
|
void DoorTile::neighborChanged(Level* level, int x, int y, int z, int type) {
|
|
int data = level->getData(x, y, z);
|
|
if ((data & UPPER_BIT) == 0) {
|
|
bool spawn = false;
|
|
if (level->getTile(x, y + 1, z) != id) {
|
|
level->setTile(x, y, z, 0);
|
|
spawn = true;
|
|
}
|
|
if (!level->isSolidBlockingTile(x, y - 1, z)) {
|
|
level->setTile(x, y, z, 0);
|
|
spawn = true;
|
|
if (level->getTile(x, y + 1, z) == id) {
|
|
level->setTile(x, y + 1, z, 0);
|
|
}
|
|
}
|
|
if (spawn) {
|
|
if (!level->isClientSide) {
|
|
// use default chance (1.0) so the drop always occurs
|
|
spawnResources(level, x, y, z, data);
|
|
}
|
|
} else {
|
|
bool signal = level->hasNeighborSignal(x, y, z) || level->hasNeighborSignal(x, y + 1, z);
|
|
if ((signal || ((type > 0 && Tile::tiles[type]->isSignalSource()) || type == 0)) && type != id) {
|
|
setOpen(level, x, y, z, signal);
|
|
}
|
|
}
|
|
} else {
|
|
// upper half: removal should not drop a second door. the
|
|
// lower half neighbour handler takes care of spawning the item
|
|
// whenever the door is broken from either end.
|
|
if (level->getTile(x, y - 1, z) != id) {
|
|
level->setTile(x, y, z, 0);
|
|
// no resource spawn here
|
|
}
|
|
if (type > 0 && type != id) {
|
|
neighborChanged(level, x, y - 1, z, type);
|
|
}
|
|
}
|
|
}
|
|
|
|
int DoorTile::getResource(int data, Random* random) {
|
|
// only the lower half should return a resource ID; the upper half
|
|
// itself never drops anything and playerDestroy suppresses spawning
|
|
// from the top. This prevents duplicate drops if the bottom half is
|
|
// mined.
|
|
if ((data & UPPER_BIT) != 0) return 0;
|
|
if (material == Material::metal) return Item::door_iron->id;
|
|
return Item::door_wood->id;
|
|
}
|
|
|
|
HitResult DoorTile::clip(Level* level, int xt, int yt, int zt, const Vec3& a, const Vec3& b) {
|
|
updateShape(level, xt, yt, zt);
|
|
return super::clip(level, xt, yt, zt, a, b);
|
|
}
|
|
|
|
// override to prevent double-dropping when top half is directly mined
|
|
void DoorTile::playerDestroy(Level* level, Player* player, int x, int y, int z, int data) {
|
|
if ((data & UPPER_BIT) == 0) {
|
|
// only let the lower half handle the actual spawning
|
|
super::playerDestroy(level, player, x, y, z, data);
|
|
}
|
|
}
|
|
|
|
int DoorTile::getDir(LevelSource* level, int x, int y, int z) {
|
|
return getCompositeData(level, x, y, z) & C_DIR_MASK;
|
|
}
|
|
|
|
bool DoorTile::mayPlace(Level* level, int x, int y, int z, unsigned char face) {
|
|
if (y >= Level::DEPTH - 1) return false;
|
|
|
|
return (level->isSolidBlockingTile(x, y - 1, z)
|
|
&& super::mayPlace(level, x, y, z)
|
|
&& super::mayPlace(level, x, y + 1, z));
|
|
}
|
|
|
|
int DoorTile::getCompositeData( LevelSource* level, int x, int y, int z ) {
|
|
int data = level->getData(x, y, z);
|
|
bool isUpper = (data & UPPER_BIT) != 0;
|
|
int lowerData;
|
|
int upperData;
|
|
if (isUpper) {
|
|
lowerData = level->getData(x, y - 1, z);
|
|
upperData = data;
|
|
} else {
|
|
lowerData = data;
|
|
upperData = level->getData(x, y + 1, z);
|
|
}
|
|
|
|
// bits: dir, dir, open/closed, isUpper, isRightHinge
|
|
bool isRightHinge = (upperData & 1) != 0;
|
|
return lowerData & C_LOWER_DATA_MASK | (isUpper ? 8 : 0) | (isRightHinge ? 16 : 0);
|
|
}
|