// ----------------------------------------------------------------------
private FastEnumMap<Statistic, Integer> getStatistics() {
FastEnumMap<Statistic, Integer> newMap = new FastEnumMap<Statistic, Integer>(Statistic.class);
for (Statistic stat : Statistic.values()) {
newMap.put(stat, getStatistic(stat));
}
return newMap;
}
// ----------------------------------------------------------------------
protected void calculateVariableMap() {
variableMap.clear();
for (Statistic s : Statistic.values()) {
variableMap.put(s.toString().toLowerCase(), statistics.get(s));
}
for (GameEventHandler handler : getAllHandlers()) {
for (Statistic s : Statistic.values()) {
String key = s.toString().toLowerCase();
variableMap.put(key, variableMap.get(key) + handler.getStatistic(baseVariableMap, s));
}
}
variableMap.put("hp", HP);
for (EquipmentSlot slot : EquipmentSlot.values()) {
Item equipped = inventory.getEquip(slot);
if (equipped != null && equipped.type != null) {
variableMap.put(equipped.type, 1);
}
}
for (StatusEffectStack s : stacks) {
variableMap.put(s.effect.name.toLowerCase(), s.count);
}
for (Statistic s : Statistic.values()) {
variableMap.put(s.toString().toLowerCase(), getStatistic(s));
}
variableMap.put("maxhp", variableMap.get(Statistic.CONSTITUTION.toString().toLowerCase()) * 10);
if (inventory.getEquip(EquipmentSlot.WEAPON) != null) {
Item wep = inventory.getEquip(EquipmentSlot.WEAPON);
int atk =
Global.calculateScaledAttack(
Statistic.statsBlockToVariableBlock(wep.getStatistics(variableMap)), variableMap);
String key = Statistic.ATTACK.toString().toLowerCase();
variableMap.put(key, variableMap.get(key) + atk);
}
}
// ----------------------------------------------------------------------
protected void calculateBaseVariableMap() {
baseVariableMap.clear();
for (Statistic s : Statistic.values()) {
baseVariableMap.put(
s.toString().toLowerCase(),
statistics.get(s) + inventory.getStatistic(Statistic.emptyMap, s));
}
baseVariableMap.put(
"maxhp", baseVariableMap.get(Statistic.CONSTITUTION.toString().toLowerCase()) * 10);
baseVariableMap.put("hp", HP);
for (EquipmentSlot slot : EquipmentSlot.values()) {
Item equipped = inventory.getEquip(slot);
if (equipped != null && equipped.type != null) {
baseVariableMap.put(equipped.type, 1);
}
}
for (StatusEffectStack s : stacks) {
baseVariableMap.put(s.effect.name.toLowerCase(), s.count);
}
}
// ----------------------------------------------------------------------
protected void baseInternalLoad(Element xml) {
name = xml.get("Name", name);
size = xml.getInt("Size", size);
if (size < 1) {
size = 1;
}
tile = new GameTile[size][size];
quality = xml.getInt("Quality", quality);
Element spriteElement = xml.getChildByName("Sprite");
if (spriteElement != null) {
sprite = AssetManager.loadSprite(xml.getChildByName("Sprite"));
}
if (sprite != null) {
sprite.size[0] = size;
sprite.size[1] = size;
}
Element raisedSpriteElement = xml.getChildByName("TilingSprite");
if (raisedSpriteElement != null) {
tilingSprite = TilingSprite.load(raisedSpriteElement);
}
if (tilingSprite != null) {
// for (Sprite sprite : tilingSprite.sprites)
// {
// sprite.size = size;
// }
}
Element lightElement = xml.getChildByName("Light");
if (lightElement != null) {
light = Roguelike.Lights.Light.load(lightElement);
}
Element statElement = xml.getChildByName("Statistics");
if (statElement != null) {
Statistic.load(statElement, statistics);
HP = getMaxHP();
statistics.put(Statistic.WALK, 1);
// statistics.put( Statistic.ENTITY, 1 );
}
Element inventoryElement = xml.getChildByName("Inventory");
if (inventoryElement != null) {
inventory.load(inventoryElement);
}
Element immuneElement = xml.getChildByName("Immune");
if (immuneElement != null) {
immune = immuneElement.getText().toLowerCase().split(",");
}
canTakeDamage = xml.getBoolean("CanTakeDamage", canTakeDamage);
UID = getClass().getSimpleName() + " " + name + ": ID " + hashCode();
}
public abstract class Entity implements IGameObject {
// ----------------------------------------------------------------------
public abstract void update(float delta);
// ----------------------------------------------------------------------
public abstract int getStatistic(Statistic stat);
// ----------------------------------------------------------------------
protected abstract void internalLoad(String file);
// ----------------------------------------------------------------------
public abstract Array<GameEventHandler> getAllHandlers();
// ----------------------------------------------------------------------
protected void baseInternalLoad(Element xml) {
name = xml.get("Name", name);
size = xml.getInt("Size", size);
if (size < 1) {
size = 1;
}
tile = new GameTile[size][size];
quality = xml.getInt("Quality", quality);
Element spriteElement = xml.getChildByName("Sprite");
if (spriteElement != null) {
sprite = AssetManager.loadSprite(xml.getChildByName("Sprite"));
}
if (sprite != null) {
sprite.size[0] = size;
sprite.size[1] = size;
}
Element raisedSpriteElement = xml.getChildByName("TilingSprite");
if (raisedSpriteElement != null) {
tilingSprite = TilingSprite.load(raisedSpriteElement);
}
if (tilingSprite != null) {
// for (Sprite sprite : tilingSprite.sprites)
// {
// sprite.size = size;
// }
}
Element lightElement = xml.getChildByName("Light");
if (lightElement != null) {
light = Roguelike.Lights.Light.load(lightElement);
}
Element statElement = xml.getChildByName("Statistics");
if (statElement != null) {
Statistic.load(statElement, statistics);
HP = getMaxHP();
statistics.put(Statistic.WALK, 1);
// statistics.put( Statistic.ENTITY, 1 );
}
Element inventoryElement = xml.getChildByName("Inventory");
if (inventoryElement != null) {
inventory.load(inventoryElement);
}
Element immuneElement = xml.getChildByName("Immune");
if (immuneElement != null) {
immune = immuneElement.getText().toLowerCase().split(",");
}
canTakeDamage = xml.getBoolean("CanTakeDamage", canTakeDamage);
UID = getClass().getSimpleName() + " " + name + ": ID " + hashCode();
}
// ----------------------------------------------------------------------
public int getVariable(Statistic stat) {
return getVariableMap().get(stat.toString().toLowerCase());
}
// ----------------------------------------------------------------------
private FastEnumMap<Statistic, Integer> getStatistics() {
FastEnumMap<Statistic, Integer> newMap = new FastEnumMap<Statistic, Integer>(Statistic.class);
for (Statistic stat : Statistic.values()) {
newMap.put(stat, getStatistic(stat));
}
return newMap;
}
// ----------------------------------------------------------------------
public HashMap<String, Integer> getVariableMap() {
recalculateMaps();
return variableMap;
}
// ----------------------------------------------------------------------
public HashMap<String, Integer> getBaseVariableMap() {
recalculateMaps();
return baseVariableMap;
}
// ----------------------------------------------------------------------
public void recalculateMaps() {
if (isVariableMapDirty) {
isVariableMapDirty = false;
calculateBaseVariableMap();
calculateVariableMap();
travelType = Passability.variableMapToTravelType(variableMap);
}
}
// ----------------------------------------------------------------------
protected void calculateVariableMap() {
variableMap.clear();
for (Statistic s : Statistic.values()) {
variableMap.put(s.toString().toLowerCase(), statistics.get(s));
}
for (GameEventHandler handler : getAllHandlers()) {
for (Statistic s : Statistic.values()) {
String key = s.toString().toLowerCase();
variableMap.put(key, variableMap.get(key) + handler.getStatistic(baseVariableMap, s));
}
}
variableMap.put("hp", HP);
for (EquipmentSlot slot : EquipmentSlot.values()) {
Item equipped = inventory.getEquip(slot);
if (equipped != null && equipped.type != null) {
variableMap.put(equipped.type, 1);
}
}
for (StatusEffectStack s : stacks) {
variableMap.put(s.effect.name.toLowerCase(), s.count);
}
for (Statistic s : Statistic.values()) {
variableMap.put(s.toString().toLowerCase(), getStatistic(s));
}
variableMap.put("maxhp", variableMap.get(Statistic.CONSTITUTION.toString().toLowerCase()) * 10);
if (inventory.getEquip(EquipmentSlot.WEAPON) != null) {
Item wep = inventory.getEquip(EquipmentSlot.WEAPON);
int atk =
Global.calculateScaledAttack(
Statistic.statsBlockToVariableBlock(wep.getStatistics(variableMap)), variableMap);
String key = Statistic.ATTACK.toString().toLowerCase();
variableMap.put(key, variableMap.get(key) + atk);
}
}
// ----------------------------------------------------------------------
protected void calculateBaseVariableMap() {
baseVariableMap.clear();
for (Statistic s : Statistic.values()) {
baseVariableMap.put(
s.toString().toLowerCase(),
statistics.get(s) + inventory.getStatistic(Statistic.emptyMap, s));
}
baseVariableMap.put(
"maxhp", baseVariableMap.get(Statistic.CONSTITUTION.toString().toLowerCase()) * 10);
baseVariableMap.put("hp", HP);
for (EquipmentSlot slot : EquipmentSlot.values()) {
Item equipped = inventory.getEquip(slot);
if (equipped != null && equipped.type != null) {
baseVariableMap.put(equipped.type, 1);
}
}
for (StatusEffectStack s : stacks) {
baseVariableMap.put(s.effect.name.toLowerCase(), s.count);
}
}
// ----------------------------------------------------------------------
public Inventory getInventory() {
return inventory;
}
// ----------------------------------------------------------------------
public void applyDamage(int dam, Entity damager) {
if (!canTakeDamage || HP == 0) {
return;
}
HP = Math.max(HP - dam, 0);
if (HP == 0) {
for (GameEventHandler handler : getAllHandlers()) {
handler.onDeath(this, damager);
}
}
damageAccumulator += dam;
hasDamage = true;
extraUIHP += dam;
if (HP + extraUIHP > getMaxHP()) {
extraUIHP = getMaxHP() - HP;
}
if (dam != 0) {
isVariableMapDirty = true;
}
}
// ----------------------------------------------------------------------
public void applyHealing(int heal) {
if (!canTakeDamage) {
return;
}
int appliedHeal = Math.min(heal, getMaxHP() - HP);
HP += appliedHeal;
extraUIHP -= appliedHeal;
if (extraUIHP < 0) {
extraUIHP = 0;
}
healingAccumulator += appliedHeal;
if (heal != 0) {
isVariableMapDirty = true;
}
}
// ----------------------------------------------------------------------
public int getMaxHP() {
return getVariable(Statistic.CONSTITUTION) * 10;
}
// ----------------------------------------------------------------------
public Array<StatusEffectStack> stackStatusEffects() {
Array<StatusEffectStack> stacks = new Array<StatusEffectStack>();
for (StatusEffect se : statusEffects) {
boolean found = false;
for (StatusEffectStack stack : stacks) {
if (stack.effect.name.equals(se.name)) {
stack.count++;
found = true;
break;
}
}
if (!found) {
StatusEffectStack stack = new StatusEffectStack();
stack.count = 1;
stack.effect = se;
stacks.add(stack);
}
}
return stacks;
}
// ----------------------------------------------------------------------
public boolean isImmune(String name) {
if (immune == null) {
return false;
}
for (String s : immune) {
if (s.equalsIgnoreCase(name)) {
return true;
}
}
return false;
}
// ----------------------------------------------------------------------
public void addStatusEffect(StatusEffect se) {
if (!canTakeDamage) {
return;
}
if (isImmune(se.getName().toLowerCase())) {
return;
}
pendingStatusEffects.add(se);
}
// ----------------------------------------------------------------------
public void processStatuses() {
processPendingStatuses();
boolean removedStatusEffect = false;
Iterator<StatusEffect> itr = statusEffects.iterator();
while (itr.hasNext()) {
StatusEffect se = itr.next();
if (se.duration <= 0) {
se.onExpire(this);
itr.remove();
isVariableMapDirty = true;
}
}
if (removedStatusEffect) {
stacks = stackStatusEffects();
}
processPendingStatuses();
replacementSprite = null;
additionalSprites.clear();
for (StatusEffect se : statusEffects) {
if (se.replacementSprite != null) {
replacementSprite = se.replacementSprite;
}
for (AdditionalSprite as : se.additionalSprites) {
additionalSprites.add(as);
}
}
}
// ----------------------------------------------------------------------
public void processPendingStatuses() {
if (pendingStatusEffects.size > 0) {
for (StatusEffect se : pendingStatusEffects) {
boolean needsAdding = true;
if (!se.stackable) {
for (StatusEffect ose : statusEffects) {
if (ose.name.equals(se.name)) {
ose.duration = Math.max(ose.duration, se.duration);
needsAdding = false;
break;
}
}
}
if (needsAdding) {
statusEffects.add(se);
}
}
stacks = stackStatusEffects();
isVariableMapDirty = true;
pendingStatusEffects.clear();
}
}
// ----------------------------------------------------------------------
public void removeStatusEffect(String se) {
for (int i = 0; i < statusEffects.size; i++) {
if (statusEffects.get(i).name.equals(se)) {
statusEffects.removeIndex(i);
isVariableMapDirty = true;
break;
}
}
stacks = stackStatusEffects();
}
// ----------------------------------------------------------------------
public void setPopupText(String text, float duration) {
if (popup != null && popup.equals(text)) {
return;
}
popup = text;
displayedPopup = "";
popupDuration = duration;
popupFade = 1;
popupAccumulator = 0;
}
// ----------------------------------------------------------------------
public abstract void removeFromTile();
// ----------------------------------------------------------------------
public void updateShadowCast() {
visibilityCache.getShadowCast(
tile[0][0].level.Grid,
tile[0][0].x,
tile[0][0].y,
getStatistic(Statistic.PERCEPTION),
this);
}
// ----------------------------------------------------------------------
@Override
public String getName() {
return name;
}
// ----------------------------------------------------------------------
@Override
public String getDescription() {
return "";
}
// ----------------------------------------------------------------------
@Override
public Sprite getIcon() {
return sprite;
}
// ----------------------------------------------------------------------
public Sprite replacementSprite;
public Array<AdditionalSprite> additionalSprites = new Array<AdditionalSprite>();
// ----------------------------------------------------------------------
public boolean weaponSheathed = false;
// ----------------------------------------------------------------------
public boolean isVariableMapDirty = true;
// ----------------------------------------------------------------------
protected HashMap<String, Integer> baseVariableMap = new HashMap<String, Integer>();
protected HashMap<String, Integer> variableMap = new HashMap<String, Integer>();
protected EnumBitflag<Passability> travelType = new EnumBitflag<Passability>();
// ----------------------------------------------------------------------
public int damageAccumulator = 0;
public int healingAccumulator = 0;
public boolean hasDamage = false;
// ----------------------------------------------------------------------
public Array<Message> pendingMessages = new Array<Message>();
public float messageAccumulator = 0;
public static final float MESSAGE_DELAY = 0.4f;
// ----------------------------------------------------------------------
public String[] immune;
public FastEnumMap<Statistic, Integer> statistics = Statistic.getStatisticsBlock();
public Array<StatusEffect> statusEffects = new Array<StatusEffect>(false, 16);
public Array<StatusEffect> pendingStatusEffects = new Array<StatusEffect>();
public Array<StatusEffectStack> stacks = new Array<StatusEffectStack>();
public Inventory inventory = new Inventory();
// ----------------------------------------------------------------------
public String name = "";
// ----------------------------------------------------------------------
public String popup;
public String displayedPopup;
public float popupDuration = 0;
public float popupFade = 0;
public float popupAccumulator = 0;
// ----------------------------------------------------------------------
public Sprite sprite;
public TilingSprite tilingSprite;
public Light light;
// ----------------------------------------------------------------------
public GameTile[][] tile = new GameTile[1][1];
public int size = 1;
public Direction location = Direction.CENTER;
// ----------------------------------------------------------------------
public int HP = 1;
public int extraUIHP = 0;
public float extraUIHPAccumulator = 0;
public int essence = 0;
// ----------------------------------------------------------------------
public boolean canTakeDamage = true;
// ----------------------------------------------------------------------
public int quality = 1;
// ----------------------------------------------------------------------
public String UID;
// ----------------------------------------------------------------------
public ShadowCastCache visibilityCache = new ShadowCastCache();
// ----------------------------------------------------------------------
public static class StatusEffectStack {
public StatusEffect effect;
public int count;
}
}
// ----------------------------------------------------------------------
public int getVariable(Statistic stat) {
return getVariableMap().get(stat.toString().toLowerCase());
}