mirror of
https://github.com/4jcraft/4jcraft.git
synced 2026-04-23 19:33:36 +00:00
420 lines
16 KiB
C++
420 lines
16 KiB
C++
#include "../Platform/stdafx.h"
|
||
#include "../Headers/net.minecraft.world.item.h"
|
||
#include "../Headers/net.minecraft.world.item.alchemy.h"
|
||
#include "../Headers/net.minecraft.world.effect.h"
|
||
#include "../Headers/net.minecraft.world.level.h"
|
||
#include "../Headers/net.minecraft.world.entity.ai.attributes.h"
|
||
#include "../Headers/net.minecraft.world.entity.player.h"
|
||
#include "../Headers/net.minecraft.world.entity.projectile.h"
|
||
#include "../Headers/net.minecraft.world.h"
|
||
#include "../Entities/MobEffectInstance.h"
|
||
#include "../Util/StringHelpers.h"
|
||
#include "../Util/SharedConstants.h"
|
||
#include "PotionItem.h"
|
||
#include "../Util/SoundTypes.h"
|
||
|
||
const std::wstring PotionItem::DEFAULT_ICON = L"potion";
|
||
const std::wstring PotionItem::THROWABLE_ICON = L"potion_splash";
|
||
const std::wstring PotionItem::CONTENTS_ICON = L"potion_contents";
|
||
|
||
// 4J Added
|
||
std::vector<std::pair<int, int> > PotionItem::s_uniquePotionValues;
|
||
|
||
PotionItem::PotionItem(int id) : Item(id) {
|
||
setMaxStackSize(1);
|
||
setStackedByData(true);
|
||
setMaxDamage(0);
|
||
|
||
iconThrowable = NULL;
|
||
iconDrinkable = NULL;
|
||
iconOverlay = NULL;
|
||
}
|
||
|
||
std::vector<MobEffectInstance*>* PotionItem::getMobEffects(
|
||
std::shared_ptr<ItemInstance> potion) {
|
||
if (!potion->hasTag() ||
|
||
!potion->getTag()->contains(L"CustomPotionEffects")) {
|
||
std::vector<MobEffectInstance*>* effects = NULL;
|
||
AUTO_VAR(it, cachedMobEffects.find(potion->getAuxValue()));
|
||
if (it != cachedMobEffects.end()) effects = it->second;
|
||
if (effects == NULL) {
|
||
effects = PotionBrewing::getEffects(potion->getAuxValue(), false);
|
||
cachedMobEffects[potion->getAuxValue()] = effects;
|
||
}
|
||
|
||
// Result should be a new (unmanaged) vector, so create a new one
|
||
return effects == NULL ? NULL
|
||
: new std::vector<MobEffectInstance*>(*effects);
|
||
} else {
|
||
std::vector<MobEffectInstance*>* effects =
|
||
new std::vector<MobEffectInstance*>();
|
||
ListTag<CompoundTag>* customList =
|
||
(ListTag<CompoundTag>*)potion->getTag()->getList(
|
||
L"CustomPotionEffects");
|
||
|
||
for (int i = 0; i < customList->size(); i++) {
|
||
CompoundTag* tag = customList->get(i);
|
||
effects->push_back(MobEffectInstance::load(tag));
|
||
}
|
||
|
||
return effects;
|
||
}
|
||
}
|
||
|
||
std::vector<MobEffectInstance*>* PotionItem::getMobEffects(int auxValue) {
|
||
std::vector<MobEffectInstance*>* effects = NULL;
|
||
AUTO_VAR(it, cachedMobEffects.find(auxValue));
|
||
if (it != cachedMobEffects.end()) effects = it->second;
|
||
if (effects == NULL) {
|
||
effects = PotionBrewing::getEffects(auxValue, false);
|
||
if (effects != NULL)
|
||
cachedMobEffects.insert(
|
||
std::pair<int, std::vector<MobEffectInstance*>*>(auxValue,
|
||
effects));
|
||
}
|
||
return effects;
|
||
}
|
||
|
||
std::shared_ptr<ItemInstance> PotionItem::useTimeDepleted(
|
||
std::shared_ptr<ItemInstance> instance, Level* level,
|
||
std::shared_ptr<Player> player) {
|
||
if (!player->abilities.instabuild) instance->count--;
|
||
|
||
if (!level->isClientSide) {
|
||
std::vector<MobEffectInstance*>* effects = getMobEffects(instance);
|
||
if (effects != NULL) {
|
||
// for (MobEffectInstance effect : effects)
|
||
for (AUTO_VAR(it, effects->begin()); it != effects->end(); ++it) {
|
||
player->addEffect(new MobEffectInstance(*it));
|
||
}
|
||
}
|
||
}
|
||
if (!player->abilities.instabuild) {
|
||
if (instance->count <= 0) {
|
||
return std::shared_ptr<ItemInstance>(
|
||
new ItemInstance(Item::glassBottle));
|
||
} else {
|
||
player->inventory->add(std::shared_ptr<ItemInstance>(
|
||
new ItemInstance(Item::glassBottle)));
|
||
}
|
||
}
|
||
|
||
return instance;
|
||
}
|
||
|
||
int PotionItem::getUseDuration(std::shared_ptr<ItemInstance> itemInstance) {
|
||
return DRINK_DURATION;
|
||
}
|
||
|
||
UseAnim PotionItem::getUseAnimation(
|
||
std::shared_ptr<ItemInstance> itemInstance) {
|
||
return UseAnim_drink;
|
||
}
|
||
|
||
bool PotionItem::TestUse(std::shared_ptr<ItemInstance> itemInstance,
|
||
Level* level, std::shared_ptr<Player> player) {
|
||
return true;
|
||
}
|
||
|
||
std::shared_ptr<ItemInstance> PotionItem::use(
|
||
std::shared_ptr<ItemInstance> instance, Level* level,
|
||
std::shared_ptr<Player> player) {
|
||
if (isThrowable(instance->getAuxValue())) {
|
||
if (!player->abilities.instabuild) instance->count--;
|
||
level->playEntitySound(player, eSoundType_RANDOM_BOW, 0.5f,
|
||
0.4f / (random->nextFloat() * 0.4f + 0.8f));
|
||
if (!level->isClientSide)
|
||
level->addEntity(std::shared_ptr<ThrownPotion>(
|
||
new ThrownPotion(level, player, instance->getAuxValue())));
|
||
return instance;
|
||
}
|
||
player->startUsingItem(instance, getUseDuration(instance));
|
||
return instance;
|
||
}
|
||
|
||
bool PotionItem::useOn(std::shared_ptr<ItemInstance> itemInstance,
|
||
std::shared_ptr<Player> player, Level* level, int x,
|
||
int y, int z, int face, float clickX, float clickY,
|
||
float clickZ, bool bTestUseOnOnly) {
|
||
return false;
|
||
}
|
||
|
||
Icon* PotionItem::getIcon(int auxValue) {
|
||
if (isThrowable(auxValue)) {
|
||
return iconThrowable;
|
||
}
|
||
return iconDrinkable;
|
||
}
|
||
|
||
Icon* PotionItem::getLayerIcon(int auxValue, int spriteLayer) {
|
||
if (spriteLayer == 0) {
|
||
return iconOverlay;
|
||
}
|
||
return Item::getLayerIcon(auxValue, spriteLayer);
|
||
}
|
||
|
||
bool PotionItem::isThrowable(int auxValue) {
|
||
return ((auxValue & PotionBrewing::THROWABLE_MASK) != 0);
|
||
}
|
||
|
||
int PotionItem::getColor(int data) {
|
||
return PotionBrewing::getColorValue(data, false);
|
||
}
|
||
|
||
int PotionItem::getColor(std::shared_ptr<ItemInstance> item, int spriteLayer) {
|
||
if (spriteLayer > 0) {
|
||
return 0xffffff;
|
||
}
|
||
return PotionBrewing::getColorValue(item->getAuxValue(), false);
|
||
}
|
||
|
||
bool PotionItem::hasMultipleSpriteLayers() { return true; }
|
||
|
||
bool PotionItem::hasInstantenousEffects(int itemAuxValue) {
|
||
std::vector<MobEffectInstance*>* mobEffects = getMobEffects(itemAuxValue);
|
||
if (mobEffects == NULL || mobEffects->empty()) {
|
||
return false;
|
||
}
|
||
// for (MobEffectInstance effect : mobEffects) {
|
||
for (AUTO_VAR(it, mobEffects->begin()); it != mobEffects->end(); ++it) {
|
||
MobEffectInstance* effect = *it;
|
||
if (MobEffect::effects[effect->getId()]->isInstantenous()) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
std::wstring PotionItem::getHoverName(
|
||
std::shared_ptr<ItemInstance> itemInstance) {
|
||
if (itemInstance->getAuxValue() == 0) {
|
||
return app.GetString(
|
||
IDS_ITEM_WATER_BOTTLE); // I18n.get("item.emptyPotion.name").trim();
|
||
}
|
||
|
||
std::wstring elementName = Item::getHoverName(itemInstance);
|
||
if (isThrowable(itemInstance->getAuxValue())) {
|
||
// elementName = I18n.get("potion.prefix.grenade").trim() + " " +
|
||
// elementName;
|
||
elementName = replaceAll(elementName, L"{*splash*}",
|
||
app.GetString(IDS_POTION_PREFIX_GRENADE));
|
||
} else {
|
||
elementName = replaceAll(elementName, L"{*splash*}", L"");
|
||
}
|
||
|
||
std::vector<MobEffectInstance*>* effects =
|
||
((PotionItem*)Item::potion)->getMobEffects(itemInstance);
|
||
if (effects != NULL && !effects->empty()) {
|
||
// String postfixString = effects.get(0).getDescriptionId();
|
||
// postfixString += ".postfix";
|
||
// return elementName + " " + I18n.get(postfixString).trim();
|
||
|
||
elementName = replaceAll(elementName, L"{*prefix*}", L"");
|
||
elementName = replaceAll(
|
||
elementName, L"{*postfix*}",
|
||
app.GetString(effects->at(0)->getPostfixDescriptionId()));
|
||
} else {
|
||
// String appearanceName =
|
||
// PotionBrewing.getAppearanceName(itemInstance.getAuxValue()); return
|
||
// I18n.get(appearanceName).trim() + " " + elementName;
|
||
|
||
elementName = replaceAll(elementName, L"{*prefix*}",
|
||
app.GetString(PotionBrewing::getAppearanceName(
|
||
itemInstance->getAuxValue())));
|
||
elementName = replaceAll(elementName, L"{*postfix*}", L"");
|
||
}
|
||
return elementName;
|
||
}
|
||
|
||
void PotionItem::appendHoverText(std::shared_ptr<ItemInstance> itemInstance,
|
||
std::shared_ptr<Player> player,
|
||
std::vector<HtmlString>* lines,
|
||
bool advanced) {
|
||
if (itemInstance->getAuxValue() == 0) {
|
||
return;
|
||
}
|
||
std::vector<MobEffectInstance*>* effects =
|
||
((PotionItem*)Item::potion)->getMobEffects(itemInstance);
|
||
attrAttrModMap modifiers;
|
||
if (effects != NULL && !effects->empty()) {
|
||
// for (MobEffectInstance effect : effects)
|
||
for (AUTO_VAR(it, effects->begin()); it != effects->end(); ++it) {
|
||
MobEffectInstance* effect = *it;
|
||
std::wstring effectString =
|
||
app.GetString(effect->getDescriptionId());
|
||
|
||
MobEffect* mobEffect = MobEffect::effects[effect->getId()];
|
||
std::unordered_map<Attribute*, AttributeModifier*>*
|
||
effectModifiers = mobEffect->getAttributeModifiers();
|
||
|
||
if (effectModifiers != NULL && effectModifiers->size() > 0) {
|
||
for (AUTO_VAR(it, effectModifiers->begin());
|
||
it != effectModifiers->end(); ++it) {
|
||
// 4J - anonymous modifiers added here are destroyed
|
||
// shortly?
|
||
AttributeModifier* original = it->second;
|
||
AttributeModifier* modifier = new AttributeModifier(
|
||
mobEffect->getAttributeModifierValue(
|
||
effect->getAmplifier(), original),
|
||
original->getOperation());
|
||
modifiers.insert(
|
||
std::pair<eATTRIBUTE_ID, AttributeModifier*>(
|
||
it->first->getId(), modifier));
|
||
}
|
||
}
|
||
|
||
// Don't want to delete this (that's a pointer to mobEffects
|
||
// internal vector of modifiers) delete effectModifiers;
|
||
|
||
if (effect->getAmplifier() > 0) {
|
||
std::wstring potencyString = L"";
|
||
switch (effect->getAmplifier()) {
|
||
case 1:
|
||
potencyString = L" ";
|
||
potencyString += app.GetString(IDS_POTION_POTENCY_1);
|
||
break;
|
||
case 2:
|
||
potencyString = L" ";
|
||
potencyString += app.GetString(IDS_POTION_POTENCY_2);
|
||
break;
|
||
case 3:
|
||
potencyString = L" ";
|
||
potencyString += app.GetString(IDS_POTION_POTENCY_3);
|
||
break;
|
||
default:
|
||
potencyString = app.GetString(IDS_POTION_POTENCY_0);
|
||
break;
|
||
}
|
||
effectString +=
|
||
potencyString; // + I18n.get("potion.potency." +
|
||
// effect.getAmplifier()).trim();
|
||
}
|
||
if (effect->getDuration() > SharedConstants::TICKS_PER_SECOND) {
|
||
effectString +=
|
||
L" (" + MobEffect::formatDuration(effect) + L")";
|
||
}
|
||
|
||
eMinecraftColour color = eMinecraftColour_NOT_SET;
|
||
|
||
if (mobEffect->isHarmful()) {
|
||
color = eHTMLColor_c;
|
||
} else {
|
||
color = eHTMLColor_7;
|
||
}
|
||
|
||
lines->push_back(HtmlString(effectString, color));
|
||
}
|
||
} else {
|
||
std::wstring effectString = app.GetString(
|
||
IDS_POTION_EMPTY); // I18n.get("potion.empty").trim();
|
||
|
||
lines->push_back(HtmlString(effectString, eHTMLColor_7)); //"<22>7"
|
||
}
|
||
|
||
if (!modifiers.empty()) {
|
||
// Add new line
|
||
lines->push_back(HtmlString(L""));
|
||
lines->push_back(HtmlString(app.GetString(IDS_POTION_EFFECTS_WHENDRANK),
|
||
eHTMLColor_5));
|
||
|
||
// Add modifier descriptions
|
||
for (AUTO_VAR(it, modifiers.begin()); it != modifiers.end(); ++it) {
|
||
// 4J: Moved modifier string building to AttributeModifier
|
||
lines->push_back(it->second->getHoverText(it->first));
|
||
}
|
||
}
|
||
}
|
||
|
||
bool PotionItem::isFoil(std::shared_ptr<ItemInstance> itemInstance) {
|
||
std::vector<MobEffectInstance*>* mobEffects = getMobEffects(itemInstance);
|
||
return mobEffects != NULL && !mobEffects->empty();
|
||
}
|
||
|
||
unsigned int PotionItem::getUseDescriptionId(
|
||
std::shared_ptr<ItemInstance> instance) {
|
||
int brew = instance->getAuxValue();
|
||
if (brew == 0)
|
||
return IDS_POTION_DESC_WATER_BOTTLE;
|
||
else if (MACRO_POTION_IS_REGENERATION(brew))
|
||
return IDS_POTION_DESC_REGENERATION;
|
||
else if (MACRO_POTION_IS_SPEED(brew))
|
||
return IDS_POTION_DESC_MOVESPEED;
|
||
else if (MACRO_POTION_IS_FIRE_RESISTANCE(brew))
|
||
return IDS_POTION_DESC_FIRERESISTANCE;
|
||
else if (MACRO_POTION_IS_INSTANTHEALTH(brew))
|
||
return IDS_POTION_DESC_HEAL;
|
||
else if (MACRO_POTION_IS_NIGHTVISION(brew))
|
||
return IDS_POTION_DESC_NIGHTVISION;
|
||
else if (MACRO_POTION_IS_INVISIBILITY(brew))
|
||
return IDS_POTION_DESC_INVISIBILITY;
|
||
else if (MACRO_POTION_IS_WEAKNESS(brew))
|
||
return IDS_POTION_DESC_WEAKNESS;
|
||
else if (MACRO_POTION_IS_STRENGTH(brew))
|
||
return IDS_POTION_DESC_DAMAGEBOOST;
|
||
else if (MACRO_POTION_IS_SLOWNESS(brew))
|
||
return IDS_POTION_DESC_MOVESLOWDOWN;
|
||
else if (MACRO_POTION_IS_POISON(brew))
|
||
return IDS_POTION_DESC_POISON;
|
||
else if (MACRO_POTION_IS_INSTANTDAMAGE(brew))
|
||
return IDS_POTION_DESC_HARM;
|
||
return IDS_POTION_DESC_EMPTY;
|
||
}
|
||
|
||
void PotionItem::registerIcons(IconRegister* iconRegister) {
|
||
iconDrinkable = iconRegister->registerIcon(DEFAULT_ICON);
|
||
iconThrowable = iconRegister->registerIcon(THROWABLE_ICON);
|
||
iconOverlay = iconRegister->registerIcon(CONTENTS_ICON);
|
||
}
|
||
|
||
Icon* PotionItem::getTexture(const std::wstring& name) {
|
||
if (name.compare(DEFAULT_ICON) == 0) return Item::potion->iconDrinkable;
|
||
if (name.compare(THROWABLE_ICON) == 0) return Item::potion->iconThrowable;
|
||
if (name.compare(CONTENTS_ICON) == 0) return Item::potion->iconOverlay;
|
||
return NULL;
|
||
}
|
||
|
||
// 4J Stu - Based loosely on a function that gets added in java much later on
|
||
// (1.3)
|
||
std::vector<std::pair<int, int> >* PotionItem::getUniquePotionValues() {
|
||
if (s_uniquePotionValues.empty()) {
|
||
for (int brew = 0; brew <= PotionBrewing::BREW_MASK; ++brew) {
|
||
std::vector<MobEffectInstance*>* effects =
|
||
PotionBrewing::getEffects(brew, false);
|
||
|
||
if (effects != NULL) {
|
||
if (!effects->empty()) {
|
||
// 4J Stu - Based on implementation of Java List.hashCode()
|
||
// at
|
||
// http://docs.oracle.com/javase/6/docs/api/java/util/List.html#hashCode()
|
||
// and adding deleting to clear up as we go
|
||
int effectsHashCode = 1;
|
||
for (AUTO_VAR(it, effects->begin()); it != effects->end();
|
||
++it) {
|
||
MobEffectInstance* mei = *it;
|
||
effectsHashCode = 31 * effectsHashCode +
|
||
(mei == NULL ? 0 : mei->hashCode());
|
||
delete (*it);
|
||
}
|
||
|
||
bool toAdd = true;
|
||
for (AUTO_VAR(it, s_uniquePotionValues.begin());
|
||
it != s_uniquePotionValues.end(); ++it) {
|
||
// Some potions hash the same (identical effects) but
|
||
// are throwable so account for that
|
||
if (it->first == effectsHashCode &&
|
||
!(!isThrowable(it->second) && isThrowable(brew))) {
|
||
toAdd = false;
|
||
break;
|
||
}
|
||
}
|
||
if (toAdd) {
|
||
s_uniquePotionValues.push_back(
|
||
std::pair<int, int>(effectsHashCode, brew));
|
||
}
|
||
}
|
||
delete effects;
|
||
}
|
||
}
|
||
}
|
||
return &s_uniquePotionValues;
|
||
} |