Dram27/minecraft-pe-0.6.1
1
0
Fork 0
forked from Kolyah35/minecraft-pe-0.6.1
Code Pull Requests Projects Activity
Files
0370944cf62359d77fb457919fb9d9dbc71088cc
minecraft-pe-0.6.1/src/world/entity/player/Player.cpp
Kolyah35 f0617a5d22 the whole game
2026-03-02 22:04:18 +03:00

925 lines
24 KiB
C++
Executable File
Raw Blame History

#include "Player.h"
#include "Inventory.h"
#include "../item/ItemEntity.h"
#include "../../level/Level.h"
#include "../../item/ItemInstance.h"
#include "../../item/BowItem.h"
#include "../../inventory/BaseContainerMenu.h"
#include "../../../nbt/CompoundTag.h"
#include "../../../network/RakNetInstance.h"
#include "../../../network/packet/AnimatePacket.h"
#include "../../inventory/FurnaceMenu.h"
#include "../SharedFlags.h"
#include "../../level/tile/BedTile.h"
#include "../../Direction.h"
#include "../EntityEvent.h"
#include "../../Difficulty.h"
#include "../../item/ArmorItem.h"
const float Player::DEFAULT_WALK_SPEED = 0.1f;
const float Player::DEFAULT_FLY_SPEED = 0.02f;
// @todo: Move out to ArmorInventory
static ListTag* saveArmor(ItemInstance* armor);
static void loadArmor(ItemInstance* armor, ListTag* listTag);
Player::Player(Level* level, bool isCreative)
: super(level),
userType(0),
playerHasRespawnPosition(false),
hasFakeInventory(false),
containerMenu(NULL),
useItemDuration(0),
playerIsSleeping(false),
sleepCounter(0),
bedOffsetX(0),
bedOffsetY(0),
bedOffsetZ(0),
respawnPosition(0, -1, 0),
allPlayersSleeping(false)
{
canRemove = false;
_init();
entityRendererId = ER_PLAYER_RENDERER;
autoSendPosRot = false;
inventory = new Inventory(this, isCreative);
//inventoryMenu = /*new*/ InventoryMenu(inventory, !level.isOnline);
//containerMenu = inventoryMenu;
heightOffset = 1.62f;
Pos spawnPos = level->getSharedSpawnPos();
this->moveTo((float)spawnPos.x + 0.5f, (float)(spawnPos.y + 1), (float)spawnPos.z + 0.5f, 0, 0);
health = MAX_HEALTH;
modelName = "humanoid";
rotOffs = 180;
flameTime = 20;
textureName = "mob/char.png";
entityData.define(DATA_PLAYER_FLAGS_ID, (PlayerFlagIDType) 0);
entityData.define(DATA_BED_POSITION_ID, Pos());
//entityData.define(DATA_PLAYER_RUNNING_ID, (SynchedEntityData::TypeChar) 0);
}
Player::~Player() {
delete inventory;
}
bool Player::isSleeping() {
return playerIsSleeping;
}
int Player::startSleepInBed( int x, int y, int z ) {
if(!level->isClientSide) {
if(isSleeping() || !isAlive()) {
return BedSleepingResult::OTHER_PROBLEM;
}
if(Mth::abs(this->x - x) > 3 || Mth::abs(this->y - y) > 4 || Mth::abs(this->z - z) > 3) {
return BedSleepingResult::TOO_FAR_AWAY;
}
if(level->dimension->isNaturalDimension()) {
return BedSleepingResult::NOT_POSSIBLE_HERE;
}
if(level->isDay()) {
return BedSleepingResult::NOT_POSSIBLE_NOW;
}
float hRange = 8;
float vRange = 5;
EntityList monsters;
level->getEntitiesOfClass(MobTypes::BaseEnemy, AABB(x- hRange, y - vRange, z - hRange, x + hRange, y + vRange, z + hRange), monsters);
if(!monsters.empty()) {
return BedSleepingResult::NOT_SAFE;
}
}
setSize(0.2f, 0.2f);
heightOffset = 0.2f;
if(level->hasChunkAt(x, y, z)) {
int data = level->getData(x, y, z);
int direction = BedTile::getDirection(data);
float xo = 0.5f, zo = 0.5f;
switch(direction) {
case Direction::SOUTH:
zo = 0.9f;
break;
case Direction::NORTH:
zo = 0.1f;
break;
case Direction::WEST:
xo = 0.1f;
break;
case Direction::EAST:
xo = 0.9f;
break;
}
setBedOffset(direction);
setPos(x + xo, y + 15.0f / 16.0f, z + zo);
} else {
setPos(x + 0.5f, y + 1.0f / 16.0f, z + 0.5f);
}
playerIsSleeping = true;
sleepCounter = 0;
bedPosition = Pos(x, y, z);
xd = zd = yd = 0;
if(!level->isClientSide) {
level->updateSleepingPlayerList();
}
entityData.set<Pos>(DATA_BED_POSITION_ID, bedPosition);
entityData.setFlag<SharedFlagsInformation::SharedFlagsInformationType>(DATA_PLAYER_FLAGS_ID, PLAYER_SLEEP_FLAG);
return BedSleepingResult::OK;
}
void Player::stopSleepInBed( bool forcefulWakeUp, bool updateLevelList, bool saveRespawnPoint ) {
if(!isSleeping())
return;
setSize(0.6f, 1.8f);
setDefaultHeadHeight();
Pos standUp = bedPosition;
if(level->getTile(int(bedPosition.x), int(bedPosition.y), int(bedPosition.z)) == Tile::bed->id) {
BedTile::setOccupied(level, int(bedPosition.x), int(bedPosition.y), int(bedPosition.z), false);
bool foundStandUpPosition = BedTile::findStandUpPosition(level, int(bedPosition.x), int(bedPosition.y), int(bedPosition.z), 0, standUp);
if(!foundStandUpPosition) {
standUp = Pos(bedPosition.x, bedPosition.y, bedPosition.z);
}
setPos(standUp.x + 0.5f, standUp.y + heightOffset + 0.1f, standUp.z + 0.5f);
}
playerIsSleeping = false;
if(!level->isClientSide && updateLevelList) {
level->updateSleepingPlayerList();
}
if(forcefulWakeUp) {
sleepCounter = 0;
} else {
sleepCounter = SLEEP_DURATION;
}
// Quick fix to make the spawn position always saved, not sure if we always want to save this position but I like it.
if(true || saveRespawnPoint) {
Pos newRespawnPos;
BedTile::findStandUpPosition(level, bedPosition.x, bedPosition.y, bedPosition.z, 0, newRespawnPos);
setRespawnPosition(newRespawnPos);
}
entityData.clearFlag<SharedFlagsInformation::SharedFlagsInformationType>(DATA_PLAYER_FLAGS_ID, PLAYER_SLEEP_FLAG);
allPlayersSleeping = false;
}
int Player::getSleepTimer() {
return allPlayersSleeping ? sleepCounter : 0;
}
void Player::setAllPlayersSleeping() {
sleepCounter = 0;
allPlayersSleeping = true;
}
void Player::setBedOffset( int bedDirection ) {
bedOffsetX = 0;
bedOffsetZ = 0;
switch(bedDirection) {
case Direction::SOUTH:
bedOffsetZ = -1.8f;
break;
case Direction::NORTH:
bedOffsetZ = 1.8f;
break;
case Direction::WEST:
bedOffsetX = 1.8f;
break;
case Direction::EAST:
bedOffsetX = -1.8f;
break;
}
}
bool Player::isSleepingLongEnough() {
return isSleeping() && sleepCounter >= SLEEP_DURATION;
}
float Player::getSleepRotation() {
if(isSleeping()) {
int data = level->getData(bedPosition.x, bedPosition.y, bedPosition.z);
int direction = BedTile::getDirection(data);
switch(direction) {
case Direction::SOUTH:
return 90;
case Direction::WEST:
return 0;
case Direction::NORTH:
return 270;
case Direction::EAST:
return 180;
}
}
return 0;
}
bool Player::checkBed() {
return (level->getTile(bedPosition.x, bedPosition.y, bedPosition.z) == Tile::bed->id);
}
void Player::tick() {
bool shouldSleep = entityData.getFlag<SharedFlagsInformation::SharedFlagsInformationType>(DATA_PLAYER_FLAGS_ID, PLAYER_SLEEP_FLAG);
if(shouldSleep != isSleeping()) {
if(isSleeping()) {
stopSleepInBed(true, true, true);
} else {
bedPosition = entityData.getPos(DATA_BED_POSITION_ID);
startSleepInBed(bedPosition.x, bedPosition.y, bedPosition.z);
}
}
if(isSleeping()) {
sleepCounter++;
if(sleepCounter > SLEEP_DURATION) {
sleepCounter = SLEEP_DURATION;
}
if(!level->isClientSide) {
if(!checkBed()) {
stopSleepInBed(true, true, false);
} else if(level->isDay()) {
stopSleepInBed(false, true, true);
}
}
} else if(sleepCounter > 0) {
sleepCounter++;
if(sleepCounter >= (SLEEP_DURATION + WAKE_UP_DURATION)) {
sleepCounter = 0;
}
}
super::tick();
if (!level->isClientSide) {
foodData.tick(this);
// if (containerMenu != NULL && !containerMenu->stillValid(this)) {
// closeContainer();
// }
}
}
int Player::getMaxHealth() {
return MAX_HEALTH;
}
//
// Use items
//
bool Player::isUsingItem() {
return !useItem.isNull();
}
ItemInstance* Player::getUseItem() {
return &useItem;
}
void Player::spawnEatParticles(const ItemInstance* useItem, int count) {
if (useItem->getUseAnimation() == UseAnim::drink) {
level->playSound(this, "random.drink", 0.5f, level->random.nextFloat() * 0.1f + 0.9f);
}
else if (useItem->getUseAnimation() == UseAnim::eat) {
for (int i = 0; i < count; i++) {
const float xx = -xRot * Mth::PI / 180;
const float yy = -yRot * Mth::PI / 180;
Vec3 d((random.nextFloat() - 0.5f) * 0.1f, Mth::random() * 0.1f + 0.1f, 0);
d.xRot(xx);
d.yRot(yy);
Vec3 p((random.nextFloat() - 0.5f) * 0.3f, -random.nextFloat() * 0.6f - 0.3f, 0.6f);
p.xRot(xx);
p.yRot(yy);
p = p.add(x, y + getHeadHeight(), z);
level->addParticle(PARTICLETYPE(iconcrack), p.x, p.y, p.z, d.x, d.y + 0.05f, d.z, useItem->getItem()->id);
}
level->playSound(this, "random.eat", .5f + .5f * random.nextInt(2), (random.nextFloat() - random.nextFloat()) * 0.2f + 1.0f);
}
}
void Player::startUsingItem(ItemInstance instance, int duration) {
if(instance == useItem) return;
useItem = instance;
useItemDuration = duration;
if(!level->isClientSide) {
setSharedFlag(SharedFlagsInformation::FLAG_USINGITEM, true);
}
}
void Player::stopUsingItem() {
if(getCarriedItem() != NULL && useItem.id == getCarriedItem()->id)
getCarriedItem()->setAuxValue(useItem.getAuxValue());
useItem.setNull();
useItemDuration = 0;
if(!level->isClientSide) {
setSharedFlag(SharedFlagsInformation::FLAG_USINGITEM, false);
}
}
void Player::releaseUsingItem() {
if(!useItem.isNull()) {
useItem.releaseUsing(level, this, useItemDuration);
}
stopUsingItem();
}
void Player::completeUsingItem() {
if(!useItem.isNull()) {
spawnEatParticles(&useItem, 10);
// Check if the item is valid, and if we should overwrite the
// inventory item afterwards.
ItemInstance* selected = inventory->getSelected();
bool doOverwrite = selected && ItemInstance::matches(&useItem, selected);
ItemInstance itemInstance = useItem.useTimeDepleted(level, this);
if (doOverwrite) {
*selected = useItem;
if (selected->count == 0)
inventory->clearSlot(inventory->selected);
}
/*
int oldCount = useItem.count;
if (!itemInstance.matches(&useItem)) {
ItemInstance* selected = inventory->getSelected();
if (ItemInstance::matches(&useItem, selected)) {
if (selected) *selected = itemInstance;
if (itemInstance.count == 0) {
inventory->clearSlot(inventory->selected);
}
}
}
*/
stopUsingItem();
}
}
int Player::getUseItemDuration() {
return useItemDuration;
}
int Player::getTicksUsingItem() {
if(isUsingItem()) {
return useItem.getUseDuration() - useItemDuration;
}
return 0;
}
void Player::travel(float xa, float ya) {
if (abilities.flying) {
float ydo = yd;
float ofs = flyingSpeed;
flyingSpeed = 0.05f;
super::travel(xa, ya);
yd = ydo * 0.6f;
flyingSpeed = ofs;
} else {
super::travel(xa, ya);
}
}
/*protected*/
bool Player::isImmobile() {
return health <= 0 || isSleeping();
}
/*protected*/
void Player::closeContainer() {
containerMenu = NULL;
//containerMenu = inventoryMenu;
}
void Player::resetPos(bool clearMore) {
if(!isSleeping()) {
heightOffset = 1.62f;
setSize(0.6f, 1.8f);
super::resetPos(clearMore);
}
invisible = false;
if (clearMore) {
health = getMaxHealth();
deathTime = 0;
playerIsSleeping = false;
}
}
/*protected*/
void Player::updateAi() {
updateAttackAnim();
}
int Player::getItemInHandIcon(ItemInstance* item, int layer) {
int icon = item->getIcon();
if(useItem.id != 0 && item->id == Item::bow->id) {
int ticksHeld = (item->getUseDuration() - useItemDuration);
if(ticksHeld >= BowItem::MAX_DRAW_DURATION - 2) {
return 5 + 8 * 16;
}
if(ticksHeld > (2 * BowItem::MAX_DRAW_DURATION) / 3) {
return 5 + 7*16;
}
if(ticksHeld > 0) {
return 5 + 6 * 16;
}
}
return icon;
}
void Player::aiStep() {
if (level->difficulty == Difficulty::PEACEFUL && health < MAX_HEALTH) {
if (tickCount % (12 * SharedConstants::TicksPerSecond) == 0) heal(1);
}
//inventory.tick();
oBob = bob;
// moved the super::aiStep() part to the local player
float tBob = (float) Mth::sqrt(xd * xd + zd * zd);
float tTilt = (float) Mth::atan(-yd * 0.2f) * 15.f;
if (tBob > 0.1f) tBob = 0.1f;
if (!onGround || health <= 0) tBob = 0;
if (onGround || health <= 0) tTilt = 0;
bob += (tBob - bob) * 0.4f;
tilt += (tTilt - tilt) * 0.8f;
if (health > 0) {
EntityList& entities = level->getEntities(this, bb.grow(1, 0, 1));
for (unsigned int i = 0; i < entities.size(); i++) {
Entity* e = entities[i];
if (!e->removed) {
touch(e);
}
}
}
}
/*private*/
void Player::touch(Entity* entity) {
entity->playerTouch(this);
}
int Player::getScore() {
return score;
}
void Player::die(Entity* source) {
super::die(source);
this->setSize(0.2f, 0.2f);
setPos(x, y, z);
yd = 0.1f;
//inventory->dropAll(level->isClientSide);
if (source != NULL) {
xd = -(float) Mth::cos((hurtDir + yRot) * Mth::PI / 180) * 0.1f;
zd = -(float) Mth::sin((hurtDir + yRot) * Mth::PI / 180) * 0.1f;
} else {
xd = zd = 0;
}
this->heightOffset = 0.1f;
}
void Player::reset() {
super::reset();
this->_init();
}
void Player::_init() {
oBob = bob = 0;
swinging = 0;
swingTime = 0;
score = 0;
}
float Player::getWalkingSpeedModifier() {
return 1.0f;
}
void Player::awardKillScore(Entity* victim, int score) {
this->score += score;
}
bool Player::isShootable() {
return true;
}
bool Player::isCreativeModeAllowed() {
return true;
}
//void Player::drop() {
// //drop(inventory.removeItem(inventory.selected, 1), false);
//}
void Player::drop(ItemInstance* item) {
drop(item, false);
}
void Player::drop(ItemInstance* item, bool randomly) {
if (item == NULL || item->isNull())
return;
ItemEntity* thrownItem = new ItemEntity(level, x, y - 0.3f + getHeadHeight(), z, *item);
{ //@todo:itementity
delete item;
item = NULL;
}
thrownItem->throwTime = 20 * 2;
float pow = 0.1f;
if (randomly) {
float _pow = random.nextFloat() * 0.5f;
float dir = random.nextFloat() * Mth::PI * 2;
thrownItem->xd = -Mth::sin(dir) * _pow;
thrownItem->zd = Mth::cos(dir) * _pow;
thrownItem->yd = 0.2f;
} else {
pow = 0.3f;
thrownItem->xd = -Mth::sin(yRot / 180 * Mth::PI) * Mth::cos(xRot / 180 * Mth::PI) * pow;
thrownItem->zd = Mth::cos(yRot / 180 * Mth::PI) * Mth::cos(xRot / 180 * Mth::PI) * pow;
thrownItem->yd = -Mth::sin(xRot / 180 * Mth::PI) * pow + 0.1f;
pow = 0.02f;
float dir = random.nextFloat() * Mth::PI * 2;
pow *= random.nextFloat();
thrownItem->xd += Mth::cos(dir) * pow;
thrownItem->yd += (random.nextFloat() - random.nextFloat()) * 0.1f;
thrownItem->zd += Mth::sin(dir) * pow;
}
reallyDrop(thrownItem);
}
/*protected*/
void Player::reallyDrop(ItemEntity* thrownItem) {
level->addEntity(thrownItem);
}
float Player::getDestroySpeed(Tile* tile) {
float speed = inventory->getDestroySpeed(tile);
//if (isUnderLiquid(Material.water)) speed /= 5;
//if (!onGround) speed /= 5;
return speed;
}
bool Player::canDestroy(Tile* tile) {
return inventory->canDestroy(tile);
}
//@SuppressWarnings("unchecked")
void Player::readAdditionalSaveData(CompoundTag* entityTag) {
super::readAdditionalSaveData(entityTag);
if (entityTag->contains("Inventory", Tag::TAG_List)) {
ListTag* inventoryList = entityTag->getList("Inventory");
inventory->load(inventoryList);
}
if (entityTag->contains("Armor", Tag::TAG_List)) {
loadArmor(armor, entityTag->getList("Armor"));
}
dimension = entityTag->getInt("Dimension");
//return;
if(entityTag->contains("Sleeping") && entityTag->contains("SleepTimer")
&& entityTag->contains("BedPositionX") && entityTag->contains("BedPositionY") && entityTag->contains("BedPositionZ")) {
playerIsSleeping = entityTag->getBoolean("Sleeping");
sleepCounter = entityTag->getShort("SleepTimer");
bedPosition = Pos(entityTag->getInt("BedPositionX"), entityTag->getInt("BedPositionY"), entityTag->getInt("BedPositionZ"));
} else {
playerIsSleeping = false;
bedPosition = Pos(0,0,0);
}
if(!playerIsSleeping) {
stopSleepInBed(true, true, false);
entityData.clearFlag<SharedFlagsInformation::SharedFlagsInformationType>(DATA_PLAYER_FLAGS_ID, PLAYER_SLEEP_FLAG);
} else {
playerIsSleeping = false;
startSleepInBed(bedPosition.x, bedPosition.y, bedPosition.z);
entityData.setFlag<SharedFlagsInformation::SharedFlagsInformationType>(DATA_PLAYER_FLAGS_ID, PLAYER_SLEEP_FLAG);
}
entityData.set<Pos>(DATA_BED_POSITION_ID, bedPosition);
if (entityTag->contains("SpawnX") && entityTag->contains("SpawnY") && entityTag->contains("SpawnZ")) {
respawnPosition.set(entityTag->getInt("SpawnX"), entityTag->getInt("SpawnY"), entityTag->getInt("SpawnZ"));
}
playerHasRespawnPosition = respawnPosition.y >= 0;
}
void Player::addAdditonalSaveData(CompoundTag* entityTag) {
super::addAdditonalSaveData(entityTag);
ListTag* inventoryTag = inventory->save(new ListTag());
// if (inventoryTag->size() > 0)
entityTag->put("Inventory", inventoryTag);
//else
// delete inventoryTag;
ListTag* armorTag = saveArmor(armor);
entityTag->put("Armor", armorTag);
entityTag->putInt("Dimension", dimension);
//return;
entityTag->putBoolean("Sleeping", isSleeping());
entityTag->putShort("SleepTimer", sleepCounter);
entityTag->putInt("BedPositionX", bedPosition.x);
entityTag->putInt("BedPositionY", bedPosition.y);
entityTag->putInt("BedPositionZ", bedPosition.z);
entityTag->putInt("SpawnX", respawnPosition.x);
entityTag->putInt("SpawnY", respawnPosition.y);
entityTag->putInt("SpawnZ", respawnPosition.z);
}
//static Pos getRespawnPosition(Level level, CompoundTag entityTag) {
// if (entityTag.contains("SpawnX") && entityTag.contains("SpawnY") && entityTag.contains("SpawnZ")) {
// return /*new*/ Pos(entityTag.getInt("SpawnX"), entityTag.getInt("SpawnY"), entityTag.getInt("SpawnZ"));
// }
// return level.getSharedSpawnPos();
//}
void Player::startCrafting(int x, int y, int z, int tableSize) {
}
void Player::startStonecutting(int x, int y, int z) {
}
void Player::openFurnace(FurnaceTileEntity* e) {
}
void Player::take(Entity* e, int orgCount) {
}
float Player::getHeadHeight() {
return 0.12f; // heightOffset; // 0.12f;
}
/*protected*/
void Player::setDefaultHeadHeight() {
heightOffset = 1.62f;
}
bool Player::isHurt() {
return health > 0 && health < getMaxHealth();
}
bool Player::hurt(Entity* source, int dmg) {
if (abilities.invulnerable) return false;
noActionTime = 0;
if (health <= 0) return false;
if(isSleeping() && !level->isClientSide) {
stopSleepInBed(true, true, false);
}
if (source != NULL && (source->getCreatureBaseType() == MobTypes::BaseEnemy
|| source->getEntityTypeId() == EntityTypes::IdArrow)) {
if (source->isMob() && level->adventureSettings.noMvP)
return false;
if (level->difficulty == Difficulty::PEACEFUL) dmg = 0;
else if (level->difficulty == Difficulty::EASY) dmg = dmg / 3 + 1;
else if (level->difficulty == Difficulty::HARD) dmg = dmg * 3 / 2;
}
if (dmg == 0) return false;
// Entity* attacker = source;
// //if (attacker instanceof Arrow) {
// // if (((Arrow) attacker).owner != NULL) {
// // attacker = ((Arrow) attacker).owner;
// // }
// //}
return super::hurt(source, dmg);
}
void Player::interact(Entity* entity) {
if (entity->interact(this)) return;
ItemInstance* item = inventory->getSelected();
if (item != NULL && entity->isMob()) {
item->interactEnemy((Mob*)entity);
if (item->count <= 0) {
//item.snap(this);
inventory->clearSlot(inventory->selected);
}
}
}
//void Player::swing() {
//LOGI("swinging: %d\n", swinging);
// if (!swinging || swingTime >= 3 || swingTime < 0) {
// swingTime = -1;
// swinging = true;
// }
//level->raknetInstance->send(owner, new AnimatePacket(AnimatePacket::Swing, this));
//}
//}
void Player::attack(Entity* entity) {
int dmg = inventory->getAttackDamage(entity);
if (dmg > 0) {
entity->hurt(this, dmg);
ItemInstance* item = inventory->getSelected();
if (item != NULL && entity->isMob() && abilities.instabuild != true) {
item->hurtEnemy((Mob*) entity);
if (item->count <= 0) {
//item->snap(this);
inventory->clearSlot(inventory->selected);
}
}
}
}
void Player::respawn() {
}
/*protected static*/
void Player::animateRespawn(Player* player, Level* level) {
//for (int i = 0; i < 45; i++) {
// float angle = i * Mth::PI * 4.0f / 25.0f;
// float xo = Mth::cos(angle) * .7f;
// float zo = Mth::sin(angle) * .7f;
//}
}
/*virtual*/
void Player::animateRespawn() {}
//void carriedChanged(ItemInstance carried) {
//}
ItemInstance* Player::getCarriedItem() {
return inventory->getSelected();
}
void Player::remove() {
invisible = true;
super::remove();
}
//@Override
bool Player::isInWall() {
return super::isInWall();
}
bool Player::hasResource( int id ) {
return inventory->hasResource(id);
}
/**
* This method is currently only relevant to client-side players. It will
* try to load the messageId from the language file and display it to the
* client.
*/
void Player::displayClientMessage(const std::string& messageId) {
}
Pos Player::getRespawnPosition() {
return respawnPosition;
}
void Player::setRespawnPosition(const Pos& respawnPosition) { // @attn WARNING CHECK THIS THROUGH @fix @todo: rewrite
if (respawnPosition.y < 0) {
playerHasRespawnPosition = false;
}
else {
playerHasRespawnPosition = true;
}
this->respawnPosition = respawnPosition;
}
bool Player::isPlayer() { return true; }
/*static*/
bool Player::isPlayer( Entity* e ) {
return e && e->isPlayer();
}
Player* Player::asPlayer( Entity* e ) {
return isPlayer(e)? (Player*) e : NULL;
}
void Player::openContainer(ChestTileEntity* container)
{
}
void Player::tileEntityDestroyed( int tileEntityId ) {
//LOGI("TileEntityDestroyed, container: %p, %p\n", this, containerMenu);
if (!containerMenu) return;
//LOGI("TileEntityDestroyed, id: %d, %p, %d\n", this, tileEntityId, ((FurnaceMenu*)containerMenu)->furnaceTileEntityId);
if (containerMenu->tileEntityDestroyedIsInvalid(tileEntityId))
closeContainer();
}
bool Player::canUseCarriedItemWhileMoving() {
ItemInstance* item = getCarriedItem();
return item &&
( item->id == Item::bow->id
|| item->getItem()->isFood());
}
void Player::handleEntityEvent( char id ) {
if (id == EntityEvent::USE_ITEM_COMPLETE) {
completeUsingItem();
} else {
super::handleEntityEvent(id);
}
}
ItemInstance* Player::getSelectedItem() {
return inventory->getSelected();
}
bool Player::hasRespawnPosition(){
return playerHasRespawnPosition;
}
void Player::openTextEdit( TileEntity* tileEntity ) {
// Do nothing on the server, this is a client thing :)
}
//
// Armor code. Move this out to an ArmorInventory
//
static ListTag* saveArmor(ItemInstance* armor) {
ListTag* listTag = new ListTag();
for (int i = 0; i < 4; ++i) {
CompoundTag* tag = new CompoundTag();
armor[i].save(tag);
listTag->add(tag);
}
return listTag;
}
static void loadArmor(ItemInstance* armor, ListTag* listTag) {
if (!listTag)
return;
const int count = Mth::Min(4, listTag->size());
for (int i = 0; i < count; ++i) {
Tag* tag = listTag->get(i);
if (tag->getId() != Tag::TAG_Compound) continue;
armor[i].load((CompoundTag*) tag);
}
}
ItemInstance* Player::getArmor(int slot) {
if (slot < 0 || slot >= NUM_ARMOR)
return NULL;
if (armor[slot].isNull())
return NULL;
return &armor[slot];
}
void Player::setArmor(int slot, const ItemInstance* item) {
if (item == NULL)
armor[slot].setNull();
else {
armor[slot] = *item;
}
}
void Player::hurtArmor( int dmg ) {
dmg = Mth::Max(1, dmg / 4);
for (int i = 0; i < NUM_ARMOR; i++) {
ItemInstance& item = armor[i];
if (!ItemInstance::isArmorItem(&item))
continue;
item.hurt(dmg);
if (item.count == 0) {
item.setNull();
}
}
}
int Player::getArmorTypeHash() {
return (armor[0].id ) +
(armor[1].id << 8) +
(armor[2].id << 16) +
(armor[3].id << 24);
}
int Player::getArmorValue() {
int val = 0;
for (int i = 0; i < NUM_ARMOR; i++) {
ItemInstance& item = armor[i];
if (!ItemInstance::isArmorItem(&item))
continue;
int baseProtection = ((ArmorItem*) item.getItem())->defense;
val += baseProtection;
}
return val;
}
View Git Blame Copy Permalink