109 lines
3.3 KiB
C++
109 lines
3.3 KiB
C++
#pragma once
|
|
|
|
#include <cstdint>
|
|
#include "Block.h"
|
|
|
|
namespace vf {
|
|
|
|
enum class ItemId : uint16_t {
|
|
None = 0,
|
|
|
|
Grass, Dirt, Stone, Sand, Wood, Leaves, Snow,
|
|
CoalOre, IronOre, GoldOre, Gravel, Glowstone,
|
|
Cobblestone, Planks, Sandstone, Ice, Obsidian,
|
|
DiamondOre, RedstoneOre, EmeraldOre, LapisOre,
|
|
CraftingTable, Furnace, Chest, Torch,
|
|
RedstoneWire, RedstoneTorch, RedstoneLamp,
|
|
Lever, Button, RedstoneBlock, Repeater, Comparator,
|
|
Piston, PistonSticky, Tnt, Ladder,
|
|
|
|
Stick, Gunpowder,
|
|
CoalLump, IronIngot, GoldIngot, DiamondGem, EmeraldGem, RedstoneDust, LapisLazuli,
|
|
|
|
WoodPickaxe, WoodAxe, WoodShovel, WoodSword, WoodHoe,
|
|
StonePickaxe, StoneAxe, StoneShovel, StoneSword, StoneHoe,
|
|
IronPickaxe, IronAxe, IronShovel, IronSword, IronHoe,
|
|
GoldPickaxe, GoldAxe, GoldShovel, GoldSword, GoldHoe,
|
|
DiamondPickaxe, DiamondAxe, DiamondShovel, DiamondSword, DiamondHoe,
|
|
|
|
Apple, Bread,
|
|
RawPorkchop, CookedPorkchop,
|
|
RawBeef, CookedBeef,
|
|
RawMutton, CookedMutton,
|
|
RottenFlesh,
|
|
|
|
Count
|
|
};
|
|
|
|
enum class ItemKind : uint8_t { Block, Material, Tool, Food };
|
|
enum class ToolType : uint8_t { None, Pickaxe, Axe, Shovel, Sword, Hoe };
|
|
enum class ToolTier : uint8_t { None, Wood, Stone, Iron, Gold, Diamond };
|
|
|
|
constexpr int defaultStackSize = 64;
|
|
|
|
struct ItemInfo {
|
|
ItemKind kind = ItemKind::Material;
|
|
int maxStack = defaultStackSize;
|
|
ToolType toolType = ToolType::None;
|
|
ToolTier toolTier = ToolTier::None;
|
|
int foodHunger = 0;
|
|
float foodSaturation = 0.0f;
|
|
};
|
|
|
|
const ItemInfo& itemInfo(ItemId id);
|
|
|
|
bool isBlockItem(ItemId id);
|
|
bool isTool(ItemId id);
|
|
bool isFood(ItemId id);
|
|
|
|
int maxStackSize(ItemId id);
|
|
int toolMaxDurability(ItemId id);
|
|
|
|
// Bidirectional mapping between placeable/obtainable blocks and their item form.
|
|
// blockForItem returns Block::Air and itemForBlock returns ItemId::None when the
|
|
// given side has no counterpart.
|
|
Block blockForItem(ItemId id);
|
|
ItemId itemForBlock(Block block);
|
|
|
|
// The tool type that is efficient against a block, or ToolType::None when no
|
|
// tool gives a bonus (bare hands are as fast as any tool).
|
|
ToolType correctToolFor(Block block);
|
|
|
|
// Base multiplier for a tool tier regardless of block, 1.0 for bare hands.
|
|
float toolTierSpeedMultiplier(ToolTier tier);
|
|
|
|
// Combines correctToolFor and toolTierSpeedMultiplier: 1.0 unless toolItem is a
|
|
// tool whose type matches the block's preferred class.
|
|
float miningSpeedMultiplier(ItemId toolItem, Block block);
|
|
|
|
struct FoodValue {
|
|
int hunger = 0;
|
|
float saturation = 0.0f;
|
|
};
|
|
|
|
FoodValue foodValue(ItemId id);
|
|
|
|
struct ItemSlot {
|
|
ItemId item = ItemId::None;
|
|
int count = 0;
|
|
int durability = 0;
|
|
|
|
bool empty() const { return count <= 0 || item == ItemId::None; }
|
|
};
|
|
|
|
ItemSlot makeToolStack(ItemId toolItem);
|
|
|
|
// Moves as many items as possible from `from` into `into` (same item, same
|
|
// durability, respecting the item's max stack). Returns the amount moved.
|
|
int mergeStacks(ItemSlot& into, ItemSlot& from);
|
|
|
|
// Removes up to `amount` items from `stack` and returns them as a new stack.
|
|
ItemSlot splitStack(ItemSlot& stack, int amount);
|
|
|
|
// Reduces a tool's durability by `amount`. Clears the slot to empty and
|
|
// returns true when durability reaches zero. No-op (returns false) on
|
|
// non-tool stacks.
|
|
bool damageTool(ItemSlot& stack, int amount = 1);
|
|
|
|
} // namespace vf
|