Exemple #1
0
  // ----------------------------------------------------------------------
  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;
  }
Exemple #2
0
  // ----------------------------------------------------------------------
  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);
    }
  }
Exemple #3
0
  // ----------------------------------------------------------------------
  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);
    }
  }
Exemple #4
0
  // ----------------------------------------------------------------------
  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();
  }
Exemple #5
0
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;
  }
}
Exemple #6
0
 // ----------------------------------------------------------------------
 public int getVariable(Statistic stat) {
   return getVariableMap().get(stat.toString().toLowerCase());
 }