private boolean actPickUp(HeroAction.PickUp action) {
    int dst = action.dst;
    if (pos == dst) {

      Heap heap = Dungeon.level.heaps.get(pos);
      if (heap != null) {
        Item item = heap.pickUp();
        if (item.doPickUp(this)) {

          if (item instanceof Dewdrop) {
            // Do nothing
          } else {
            boolean important =
                ((item instanceof ScrollOfUpgrade || item instanceof ScrollOfEnchantment)
                        && ((Scroll) item).isKnown())
                    || ((item instanceof PotionOfStrength || item instanceof PotionOfMight)
                        && ((Potion) item).isKnown());
            if (important) {
              GLog.p(TXT_YOU_NOW_HAVE, item.name());
            } else {
              GLog.i(TXT_YOU_NOW_HAVE, item.name());
            }
            if (Dungeon.isChallenged(Challenges.INSID)) {
              if (!item.isIdentified()) {
                item.identify();
              }
            }
          }

          if (!heap.isEmpty()) {
            GLog.i(TXT_SOMETHING_ELSE);
          }
          curAction = null;
        } else {
          Dungeon.level.drop(item, pos).sprite.drop();
          ready();
        }
      } else {
        ready();
      }

      return false;

    } else if (getCloser(dst)) {

      return true;

    } else {
      ready();
      return false;
    }
  }
  public Hero() {
    super();
    name = "you";

    if (Dungeon.isChallenged(Challenges.MOREHP)) {
      HP = HT = 2000;
    } else {
      HP = HT = 20;
    }
    STR = STARTING_STR;
    awareness = 0.1f;

    belongings = new Belongings(this);

    visibleEnemies = new ArrayList<Mob>();
  }
public class Hero extends Char {

  private static final String TXT_LEAVE = "One does not simply leave Pixel Dungeon.";

  private static final String TXT_LEVEL_UP = "level up!";
  private static final String TXT_NEW_LEVEL =
      "Welcome to level %d! Now you are healthier and more focused. "
          + "It's easier for you to hit enemies and dodge their attacks.";

  public static final String TXT_YOU_NOW_HAVE = "You now have %s";

  private static final String TXT_SOMETHING_ELSE = "There is something else here";
  private static final String TXT_LOCKED_CHEST =
      "This chest is locked and you don't have matching key";
  private static final String TXT_LOCKED_DOOR = "You don't have a matching key";
  private static final String TXT_NOTICED_SMTH = "You noticed something";

  private static final String TXT_WAIT = "...";
  private static final String TXT_SEARCH = "search";

  public static final int STARTING_STR = 10;

  private static final float TIME_TO_REST = 1f;
  private static final float TIME_TO_SEARCH = 2f;

  public HeroClass heroClass = HeroClass.ROGUE;
  public HeroSubClass subClass = HeroSubClass.NONE;

  private int attackSkill = Dungeon.isChallenged(Challenges.HIGHSKILL) ? 50 : 10;
  private int defenseSkill = Dungeon.isChallenged(Challenges.HIGHSKILL) ? 40 : 5;

  public boolean ready = false;

  public HeroAction curAction = null;
  public HeroAction lastAction = null;

  private Char enemy;

  public Armor.Glyph killerGlyph = null;

  private Item theKey;

  public boolean restoreHealth = false;

  public MissileWeapon rangedWeapon = null;
  public Belongings belongings;

  public int STR;
  public boolean weakened = false;

  public float awareness;

  public int lvl = 1;
  public int exp = 0;

  private ArrayList<Mob> visibleEnemies;

  public Hero() {
    super();
    name = "you";

    if (Dungeon.isChallenged(Challenges.MOREHP)) {
      HP = HT = 2000;
    } else {
      HP = HT = 20;
    }
    STR = STARTING_STR;
    awareness = 0.1f;

    belongings = new Belongings(this);

    visibleEnemies = new ArrayList<Mob>();
  }

  public int STR() {
    return weakened ? STR - 2 : STR;
  }

  private static final String ATTACK = "attackSkill";
  private static final String DEFENSE = "defenseSkill";
  private static final String STRENGTH = "STR";
  private static final String LEVEL = "lvl";
  private static final String EXPERIENCE = "exp";

  @Override
  public void storeInBundle(Bundle bundle) {
    super.storeInBundle(bundle);

    heroClass.storeInBundle(bundle);
    subClass.storeInBundle(bundle);

    bundle.put(ATTACK, attackSkill);
    bundle.put(DEFENSE, defenseSkill);

    bundle.put(STRENGTH, STR);

    bundle.put(LEVEL, lvl);
    bundle.put(EXPERIENCE, exp);

    belongings.storeInBundle(bundle);
  }

  @Override
  public void restoreFromBundle(Bundle bundle) {
    super.restoreFromBundle(bundle);

    heroClass = HeroClass.restoreInBundle(bundle);
    subClass = HeroSubClass.restoreInBundle(bundle);

    attackSkill = bundle.getInt(ATTACK);
    defenseSkill = bundle.getInt(DEFENSE);

    STR = bundle.getInt(STRENGTH);
    updateAwareness();

    lvl = bundle.getInt(LEVEL);
    exp = bundle.getInt(EXPERIENCE);

    belongings.restoreFromBundle(bundle);
  }

  public static void preview(GamesInProgress.Info info, Bundle bundle) {
    info.level = bundle.getInt(LEVEL);
  }

  public String className() {
    return subClass == null || subClass == HeroSubClass.NONE ? heroClass.title() : subClass.title();
  }

  public void live() {
    Buff.affect(this, Regeneration.class);
    Buff.affect(this, Hunger.class);
  }

  public int tier() {
    return belongings.armor == null ? 0 : belongings.armor.tier;
  }

  public boolean shoot(Char enemy, MissileWeapon wep) {

    rangedWeapon = wep;
    boolean result = attack(enemy);
    rangedWeapon = null;

    return result;
  }

  @Override
  public int attackSkill(Char target) {

    int bonus = 0;
    for (Buff buff : buffs(RingOfAccuracy.Accuracy.class)) {
      bonus += ((RingOfAccuracy.Accuracy) buff).level;
    }
    float accuracy = (bonus == 0) ? 1 : (float) Math.pow(1.4, bonus);
    if (rangedWeapon != null && Level.distance(pos, target.pos) == 1) {
      accuracy *= 0.5f;
    }

    KindOfWeapon wep = rangedWeapon != null ? rangedWeapon : belongings.weapon;
    if (wep != null) {
      return (int) (attackSkill * accuracy * wep.acuracyFactor(this));
    } else {
      return (int) (attackSkill * accuracy);
    }
  }

  @Override
  public int defenseSkill(Char enemy) {

    int bonus = 0;
    for (Buff buff : buffs(RingOfEvasion.Evasion.class)) {
      bonus += ((RingOfEvasion.Evasion) buff).level;
    }
    float evasion = bonus == 0 ? 1 : (float) Math.pow(1.2, bonus);
    if (paralysed) {
      evasion /= 2;
    }

    int aEnc = belongings.armor != null ? belongings.armor.STR - STR() : 0;

    if (aEnc > 0) {
      return (int) (defenseSkill * evasion / Math.pow(1.5, aEnc));
    } else {

      if (heroClass == HeroClass.ROGUE) {

        if (curAction != null && subClass == HeroSubClass.FREERUNNER && !isStarving()) {
          evasion *= 2;
        }

        return (int) ((defenseSkill - aEnc) * evasion);
      } else {
        return (int) (defenseSkill * evasion);
      }
    }
  }

  @Override
  public int dr() {
    int dr = belongings.armor != null ? Math.max(belongings.armor.DR(), 0) : 0;
    Barkskin barkskin = buff(Barkskin.class);
    if (barkskin != null) {
      dr += barkskin.level();
    }
    return dr;
  }

  @Override
  public int damageRoll() {
    KindOfWeapon wep = rangedWeapon != null ? rangedWeapon : belongings.weapon;
    int dmg;
    if (wep != null) {
      dmg = wep.damageRoll(this);
    } else {
      dmg = STR() > 10 ? Random.IntRange(1, STR() - 9) : 1;
    }
    return buff(Fury.class) != null ? (int) (dmg * 1.5f) : dmg;
  }

  @Override
  public float speed() {

    int aEnc = belongings.armor != null ? belongings.armor.STR - STR() : 0;
    if (aEnc > 0) {

      return (float) (super.speed() * Math.pow(1.3, -aEnc));

    } else {

      float speed = super.speed();
      return ((HeroSprite) sprite).sprint(subClass == HeroSubClass.FREERUNNER && !isStarving())
          ? 1.6f * speed
          : speed;
    }
  }

  public float attackDelay() {
    KindOfWeapon wep = rangedWeapon != null ? rangedWeapon : belongings.weapon;
    if (wep != null) {

      return wep.speedFactor(this);

    } else {
      return 1f;
    }
  }

  @Override
  public void spend(float time) {
    int hasteLevel = 0;
    for (Buff buff : buffs(RingOfHaste.Haste.class)) {
      hasteLevel += ((RingOfHaste.Haste) buff).level;
    }
    super.spend(hasteLevel == 0 ? time : (float) (time * Math.pow(1.1, -hasteLevel)));
  };

  public void spendAndNext(float time) {
    busy();
    spend(time);
    next();
  }

  @Override
  public boolean act() {

    super.act();

    if (paralysed) {

      curAction = null;

      spendAndNext(TICK);
      return false;
    }

    checkVisibleMobs();
    AttackIndicator.updateState();

    if (curAction == null) {

      if (restoreHealth) {
        if (isStarving() || HP >= HT) {
          restoreHealth = false;
        } else {
          spend(TIME_TO_REST);
          next();
          return false;
        }
      }

      ready();
      return false;

    } else {

      restoreHealth = false;

      ready = false;

      if (curAction instanceof HeroAction.Move) {

        return actMove((HeroAction.Move) curAction);

      } else if (curAction instanceof HeroAction.Interact) {

        return actInteract((HeroAction.Interact) curAction);

      } else if (curAction instanceof HeroAction.Buy) {

        return actBuy((HeroAction.Buy) curAction);

      } else if (curAction instanceof HeroAction.PickUp) {

        return actPickUp((HeroAction.PickUp) curAction);

      } else if (curAction instanceof HeroAction.OpenChest) {

        return actOpenChest((HeroAction.OpenChest) curAction);

      } else if (curAction instanceof HeroAction.Unlock) {

        return actUnlock((HeroAction.Unlock) curAction);

      } else if (curAction instanceof HeroAction.Descend) {

        return actDescend((HeroAction.Descend) curAction);

      } else if (curAction instanceof HeroAction.Ascend) {

        return actAscend((HeroAction.Ascend) curAction);

      } else if (curAction instanceof HeroAction.Attack) {

        return actAttack((HeroAction.Attack) curAction);

      } else if (curAction instanceof HeroAction.Cook) {

        return actCook((HeroAction.Cook) curAction);
      }
    }

    return false;
  }

  public void busy() {
    ready = false;
  }

  private void ready() {
    sprite.idle();
    curAction = null;
    ready = true;

    GameScene.ready();
  }

  public void interrupt() {
    if (isAlive() && curAction != null && curAction.dst != pos) {
      lastAction = curAction;
    }
    curAction = null;
  }

  public void resume() {
    curAction = lastAction;
    lastAction = null;
    act();
  }

  private boolean actMove(HeroAction.Move action) {

    if (getCloser(action.dst)) {

      return true;

    } else {
      if (Dungeon.level.map[pos] == Terrain.SIGN) {
        Sign.read(pos);
      }
      ready();

      return false;
    }
  }

  private boolean actInteract(HeroAction.Interact action) {

    NPC npc = action.npc;

    if (Level.adjacent(pos, npc.pos)) {

      ready();
      sprite.turnTo(pos, npc.pos);
      npc.interact();
      return false;

    } else {

      if (Level.fieldOfView[npc.pos] && getCloser(npc.pos)) {

        return true;

      } else {
        ready();
        return false;
      }
    }
  }

  private boolean actBuy(HeroAction.Buy action) {
    int dst = action.dst;
    if (pos == dst || Level.adjacent(pos, dst)) {

      ready();

      Heap heap = Dungeon.level.heaps.get(dst);
      if (heap != null && heap.type == Type.FOR_SALE && heap.size() == 1) {
        GameScene.show(new WndTradeItem(heap, true));
      }

      return false;

    } else if (getCloser(dst)) {

      return true;

    } else {
      ready();
      return false;
    }
  }

  private boolean actCook(HeroAction.Cook action) {
    int dst = action.dst;
    if (Dungeon.visible[dst]) {

      ready();
      AlchemyPot.operate(this, dst);
      return false;

    } else if (getCloser(dst)) {

      return true;

    } else {
      ready();
      return false;
    }
  }

  private boolean actPickUp(HeroAction.PickUp action) {
    int dst = action.dst;
    if (pos == dst) {

      Heap heap = Dungeon.level.heaps.get(pos);
      if (heap != null) {
        Item item = heap.pickUp();
        if (item.doPickUp(this)) {

          if (item instanceof Dewdrop) {
            // Do nothing
          } else {
            boolean important =
                ((item instanceof ScrollOfUpgrade || item instanceof ScrollOfEnchantment)
                        && ((Scroll) item).isKnown())
                    || ((item instanceof PotionOfStrength || item instanceof PotionOfMight)
                        && ((Potion) item).isKnown());
            if (important) {
              GLog.p(TXT_YOU_NOW_HAVE, item.name());
            } else {
              GLog.i(TXT_YOU_NOW_HAVE, item.name());
            }
            if (Dungeon.isChallenged(Challenges.INSID)) {
              if (!item.isIdentified()) {
                item.identify();
              }
            }
          }

          if (!heap.isEmpty()) {
            GLog.i(TXT_SOMETHING_ELSE);
          }
          curAction = null;
        } else {
          Dungeon.level.drop(item, pos).sprite.drop();
          ready();
        }
      } else {
        ready();
      }

      return false;

    } else if (getCloser(dst)) {

      return true;

    } else {
      ready();
      return false;
    }
  }

  private boolean actOpenChest(HeroAction.OpenChest action) {
    int dst = action.dst;
    if (Level.adjacent(pos, dst) || pos == dst) {

      Heap heap = Dungeon.level.heaps.get(dst);
      if (heap != null && (heap.type != Type.HEAP && heap.type != Type.FOR_SALE)) {

        theKey = null;

        if (heap.type == Type.LOCKED_CHEST || heap.type == Type.CRYSTAL_CHEST) {

          theKey = belongings.getKey(GoldenKey.class, Dungeon.depth);

          if (theKey == null) {
            GLog.w(TXT_LOCKED_CHEST);
            ready();
            return false;
          }
        }

        switch (heap.type) {
          case TOMB:
            Sample.INSTANCE.play(Assets.SND_TOMB);
            Camera.main.shake(1, 0.5f);
            break;
          case SKELETON:
            break;
          default:
            Sample.INSTANCE.play(Assets.SND_UNLOCK);
        }

        spend(Key.TIME_TO_UNLOCK);
        sprite.operate(dst);

      } else {
        ready();
      }

      return false;

    } else if (getCloser(dst)) {

      return true;

    } else {
      ready();
      return false;
    }
  }

  private boolean actUnlock(HeroAction.Unlock action) {
    int doorCell = action.dst;
    if (Level.adjacent(pos, doorCell)) {

      theKey = null;
      int door = Dungeon.level.map[doorCell];

      if (door == Terrain.LOCKED_DOOR) {

        theKey = belongings.getKey(IronKey.class, Dungeon.depth);

      } else if (door == Terrain.LOCKED_EXIT) {

        theKey = belongings.getKey(SkeletonKey.class, Dungeon.depth);
      }

      if (theKey != null) {

        spend(Key.TIME_TO_UNLOCK);
        sprite.operate(doorCell);

        Sample.INSTANCE.play(Assets.SND_UNLOCK);

      } else {
        GLog.w(TXT_LOCKED_DOOR);
        ready();
      }

      return false;

    } else if (getCloser(doorCell)) {

      return true;

    } else {
      ready();
      return false;
    }
  }

  private boolean actDescend(HeroAction.Descend action) {
    int stairs = action.dst;
    if (pos == stairs && pos == Dungeon.level.exit) {

      curAction = null;

      Hunger hunger = buff(Hunger.class);
      if (hunger != null && !hunger.isStarving()) {
        hunger.satisfy(-Hunger.STARVING / 10);
      }

      InterlevelScene.mode = InterlevelScene.Mode.DESCEND;
      Game.switchScene(InterlevelScene.class);

      return false;

    } else if (getCloser(stairs)) {

      return true;

    } else {
      ready();
      return false;
    }
  }

  private boolean actAscend(HeroAction.Ascend action) {
    int stairs = action.dst;
    if (pos == stairs && pos == Dungeon.level.entrance) {

      if (Dungeon.depth == 1) {

        if (belongings.getItem(Amulet.class) == null) {
          GameScene.show(new WndMessage(TXT_LEAVE));
          ready();
        } else {
          Dungeon.win(ResultDescriptions.WIN);
          Dungeon.deleteGame(Dungeon.hero.heroClass, true);
          Game.switchScene(SurfaceScene.class);
        }

      } else {

        curAction = null;

        Hunger hunger = buff(Hunger.class);
        if (hunger != null && !hunger.isStarving()) {
          hunger.satisfy(-Hunger.STARVING / 10);
        }

        InterlevelScene.mode = InterlevelScene.Mode.ASCEND;
        Game.switchScene(InterlevelScene.class);
      }

      return false;

    } else if (getCloser(stairs)) {

      return true;

    } else {
      ready();
      return false;
    }
  }

  private boolean actAttack(HeroAction.Attack action) {

    enemy = action.target;

    if (Level.adjacent(pos, enemy.pos) && enemy.isAlive() && !isCharmedBy(enemy)) {

      spend(attackDelay());
      sprite.attack(enemy.pos);

      return false;

    } else {

      if (Level.fieldOfView[enemy.pos] && getCloser(enemy.pos)) {

        return true;

      } else {
        ready();
        return false;
      }
    }
  }

  public void rest(boolean tillHealthy) {
    spendAndNext(TIME_TO_REST);
    if (!tillHealthy) {
      sprite.showStatus(CharSprite.DEFAULT, TXT_WAIT);
    }
    restoreHealth = tillHealthy;
  }

  @Override
  public int attackProc(Char enemy, int damage) {
    KindOfWeapon wep = rangedWeapon != null ? rangedWeapon : belongings.weapon;
    if (wep != null) {

      wep.proc(this, enemy, damage);

      switch (subClass) {
        case GLADIATOR:
          if (wep instanceof MeleeWeapon) {
            damage += Buff.affect(this, Combo.class).hit(enemy, damage);
          }
          break;
        case BATTLEMAGE:
          if (wep instanceof Wand) {
            Wand wand = (Wand) wep;
            if (wand.curCharges >= wand.maxCharges) {

              wand.use();

            } else if (damage > 0) {

              wand.curCharges++;
              wand.updateQuickslot();

              ScrollOfRecharging.charge(this);
            }
            damage += wand.curCharges;
          }
        case SNIPER:
          if (rangedWeapon != null) {
            Buff.prolong(this, SnipersMark.class, attackDelay() * 1.1f).object = enemy.id();
          }
          break;
        default:
      }
    }

    return damage;
  }

  @Override
  public int defenseProc(Char enemy, int damage) {

    RingOfThorns.Thorns thorns = buff(RingOfThorns.Thorns.class);
    if (thorns != null) {
      int dmg = Random.IntRange(0, damage);
      if (dmg > 0) {
        enemy.damage(dmg, thorns);
      }
    }

    Earthroot.Armor armor = buff(Earthroot.Armor.class);
    if (armor != null) {
      damage = armor.absorb(damage);
    }

    if (belongings.armor != null) {
      damage = belongings.armor.proc(enemy, this, damage);
    }

    return damage;
  }

  @Override
  public void damage(int dmg, Object src) {
    restoreHealth = false;
    super.damage(dmg, src);

    if (subClass == HeroSubClass.BERSERKER && 0 < HP && HP <= HT * Fury.LEVEL) {
      Buff.affect(this, Fury.class);
    }
  }

  private void checkVisibleMobs() {
    ArrayList<Mob> visible = new ArrayList<Mob>();

    boolean newMob = false;

    for (Mob m : Dungeon.level.mobs) {
      if (Level.fieldOfView[m.pos] && m.hostile) {
        visible.add(m);
        if (!visibleEnemies.contains(m)) {
          newMob = true;
        }
      }
    }

    if (newMob) {
      interrupt();
      restoreHealth = false;
    }

    visibleEnemies = visible;
  }

  public int visibleEnemies() {
    return visibleEnemies.size();
  }

  public Mob visibleEnemy(int index) {
    return visibleEnemies.get(index % visibleEnemies.size());
  }

  private boolean getCloser(final int target) {

    if (rooted) {
      Camera.main.shake(1, 1f);
      return false;
    }

    int step = -1;

    if (Level.adjacent(pos, target)) {

      if (Actor.findChar(target) == null) {
        if (Level.pit[target] && !flying && !Chasm.jumpConfirmed) {
          Chasm.heroJump(this);
          interrupt();
          return false;
        }
        if (Level.passable[target] || Level.avoid[target]) {
          step = target;
        }
      }

    } else {

      int len = Level.LENGTH;
      boolean[] p = Level.passable;
      boolean[] v = Dungeon.level.visited;
      boolean[] m = Dungeon.level.mapped;
      boolean[] passable = new boolean[len];
      for (int i = 0; i < len; i++) {
        passable[i] = p[i] && (v[i] || m[i]);
      }

      step = Dungeon.findPath(this, pos, target, passable, Level.fieldOfView);
    }

    if (step != -1) {

      int oldPos = pos;
      move(step);
      sprite.move(oldPos, pos);
      spend(1 / speed());

      return true;

    } else {

      return false;
    }
  }

  public boolean handle(int cell) {

    if (cell == -1) {
      return false;
    }

    Char ch;
    Heap heap;

    if (Dungeon.level.map[cell] == Terrain.ALCHEMY && cell != pos) {

      curAction = new HeroAction.Cook(cell);

    } else if (Level.fieldOfView[cell] && (ch = Actor.findChar(cell)) instanceof Mob) {

      if (ch instanceof NPC) {
        curAction = new HeroAction.Interact((NPC) ch);
      } else {
        curAction = new HeroAction.Attack(ch);
      }

    } else if (Level.fieldOfView[cell]
        && (heap = Dungeon.level.heaps.get(cell)) != null
        && heap.type != Heap.Type.HIDDEN) {

      switch (heap.type) {
        case HEAP:
          curAction = new HeroAction.PickUp(cell);
          break;
        case FOR_SALE:
          curAction =
              heap.size() == 1 && heap.peek().price() > 0
                  ? new HeroAction.Buy(cell)
                  : new HeroAction.PickUp(cell);
          break;
        default:
          curAction = new HeroAction.OpenChest(cell);
      }

    } else if (Dungeon.level.map[cell] == Terrain.LOCKED_DOOR
        || Dungeon.level.map[cell] == Terrain.LOCKED_EXIT) {

      curAction = new HeroAction.Unlock(cell);

    } else if (cell == Dungeon.level.exit) {

      curAction = new HeroAction.Descend(cell);

    } else if (cell == Dungeon.level.entrance) {

      curAction = new HeroAction.Ascend(cell);

    } else {

      curAction = new HeroAction.Move(cell);
      lastAction = null;
    }

    return act();
  }

  public void earnExp(int exp) {

    this.exp += exp;

    boolean levelUp = false;
    while (this.exp >= maxExp()) {
      this.exp -= maxExp();
      lvl++;

      HT += 5;
      HP += 5;
      attackSkill++;
      defenseSkill++;

      if (lvl < 10) {
        updateAwareness();
      }

      levelUp = true;
    }

    if (levelUp) {

      GLog.p(TXT_NEW_LEVEL, lvl);
      sprite.showStatus(CharSprite.POSITIVE, TXT_LEVEL_UP);
      Sample.INSTANCE.play(Assets.SND_LEVELUP);

      Badges.validateLevelReached();
    }

    if (subClass == HeroSubClass.WARLOCK) {

      int value = Math.min(HT - HP, 1 + (Dungeon.depth - 1) / 5);
      if (value > 0) {
        HP += value;
        sprite.emitter().burst(Speck.factory(Speck.HEALING), 1);
      }

      ((Hunger) buff(Hunger.class)).satisfy(10);
    }
  }

  public int maxExp() {
    return 5 + lvl * 5;
  }

  void updateAwareness() {
    awareness =
        (float)
            (1
                - Math.pow(
                    (heroClass == HeroClass.ROGUE ? 0.85 : 0.90), (1 + Math.min(lvl, 9)) * 0.5));
  }

  public boolean isStarving() {
    return ((Hunger) buff(Hunger.class)).isStarving();
  }

  @Override
  public void add(Buff buff) {
    super.add(buff);

    if (sprite != null) {
      if (buff instanceof Burning) {
        GLog.w("You catch fire!");
        interrupt();
      } else if (buff instanceof Paralysis) {
        GLog.w("You are paralysed!");
        interrupt();
      } else if (buff instanceof Poison) {
        GLog.w("You are poisoned!");
        interrupt();
      } else if (buff instanceof Ooze) {
        GLog.w("Caustic ooze eats your flesh. Wash away it!");
      } else if (buff instanceof Roots) {
        GLog.w("You can't move!");
      } else if (buff instanceof Weakness) {
        GLog.w("You feel weakened!");
      } else if (buff instanceof Blindness) {
        GLog.w("You are blinded!");
      } else if (buff instanceof Fury) {
        GLog.w("You become furious!");
        sprite.showStatus(CharSprite.POSITIVE, "furious");
      } else if (buff instanceof Charm) {
        GLog.w("You are charmed!");
      } else if (buff instanceof Cripple) {
        GLog.w("You are crippled!");
      } else if (buff instanceof Bleeding) {
        GLog.w("You are bleeding!");
      } else if (buff instanceof Vertigo) {
        GLog.w("Everything is spinning around you!");
        interrupt();
      } else if (buff instanceof Light) {
        sprite.add(CharSprite.State.ILLUMINATED);
      }
    }

    BuffIndicator.refreshHero();
  }

  @Override
  public void remove(Buff buff) {
    super.remove(buff);

    if (buff instanceof Light) {
      sprite.remove(CharSprite.State.ILLUMINATED);
    }

    BuffIndicator.refreshHero();
  }

  @Override
  public int stealth() {
    int stealth = super.stealth();
    for (Buff buff : buffs(RingOfShadows.Shadows.class)) {
      stealth += ((RingOfShadows.Shadows) buff).level;
    }
    return stealth;
  }

  @Override
  public void die(Object cause) {

    curAction = null;

    DewVial.autoDrink(this);
    if (isAlive()) {
      new Flare(8, 32).color(0xFFFF66, true).show(sprite, 2f);
      return;
    }

    Actor.fixTime();
    super.die(cause);

    Ankh ankh = (Ankh) belongings.getItem(Ankh.class);
    if (ankh == null) {

      reallyDie(cause);

    } else {

      Dungeon.deleteGame(Dungeon.hero.heroClass, false);
      GameScene.show(new WndResurrect(ankh, cause));
    }
  }

  public static void reallyDie(Object cause) {

    int length = Level.LENGTH;
    int[] map = Dungeon.level.map;
    boolean[] visited = Dungeon.level.visited;
    boolean[] discoverable = Level.discoverable;

    for (int i = 0; i < length; i++) {

      int terr = map[i];

      if (discoverable[i]) {

        visited[i] = true;
        if ((Terrain.flags[terr] & Terrain.SECRET) != 0) {
          Level.set(i, Terrain.discover(terr));
          GameScene.updateMap(i);
        }
      }
    }

    Bones.leave();

    Dungeon.observe();

    Dungeon.hero.belongings.identify();

    int pos = Dungeon.hero.pos;

    ArrayList<Integer> passable = new ArrayList<Integer>();
    for (Integer ofs : Level.NEIGHBOURS8) {
      int cell = pos + ofs;
      if ((Level.passable[cell] || Level.avoid[cell]) && Dungeon.level.heaps.get(cell) == null) {
        passable.add(cell);
      }
    }
    Collections.shuffle(passable);

    ArrayList<Item> items = new ArrayList<Item>(Dungeon.hero.belongings.backpack.items);
    for (Integer cell : passable) {
      if (items.isEmpty()) {
        break;
      }

      Item item = Random.element(items);
      Dungeon.level.drop(item, cell).sprite.drop(pos);
      items.remove(item);
    }

    GameScene.gameOver();

    if (cause instanceof Hero.Doom) {
      ((Hero.Doom) cause).onDeath();
    }

    Dungeon.deleteGame(Dungeon.hero.heroClass, true);
  }

  @Override
  public void move(int step) {
    super.move(step);

    if (!flying) {

      if (Level.water[pos]) {
        Sample.INSTANCE.play(Assets.SND_WATER, 1, 1, Random.Float(0.8f, 1.25f));
      } else {
        Sample.INSTANCE.play(Assets.SND_STEP);
      }
      Dungeon.level.press(pos, this);
    }
  }

  @Override
  public void onMotionComplete() {
    Dungeon.observe();
    search(false);

    super.onMotionComplete();
  }

  @Override
  public void onAttackComplete() {

    AttackIndicator.target(enemy);

    attack(enemy);
    curAction = null;

    Invisibility.dispel();

    super.onAttackComplete();
  }

  @Override
  public void onOperateComplete() {

    if (curAction instanceof HeroAction.Unlock) {

      if (theKey != null) {
        theKey.detach(belongings.backpack);
        theKey = null;
      }

      int doorCell = ((HeroAction.Unlock) curAction).dst;
      int door = Dungeon.level.map[doorCell];

      Level.set(doorCell, door == Terrain.LOCKED_DOOR ? Terrain.DOOR : Terrain.UNLOCKED_EXIT);
      GameScene.updateMap(doorCell);

    } else if (curAction instanceof HeroAction.OpenChest) {

      if (theKey != null) {
        theKey.detach(belongings.backpack);
        theKey = null;
      }

      Heap heap = Dungeon.level.heaps.get(((HeroAction.OpenChest) curAction).dst);
      if (heap.type == Type.SKELETON) {
        Sample.INSTANCE.play(Assets.SND_BONES);
      }
      heap.open(this);
    }
    curAction = null;

    super.onOperateComplete();
  }

  public boolean search(boolean intentional) {

    boolean smthFound = false;

    int positive = 0;
    int negative = 0;
    for (Buff buff : buffs(RingOfDetection.Detection.class)) {
      int bonus = ((RingOfDetection.Detection) buff).level;
      if (bonus > positive) {
        positive = bonus;
      } else if (bonus < 0) {
        negative += bonus;
      }
    }
    int distance = 1 + positive + negative;

    float level = intentional ? (2 * awareness - awareness * awareness) : awareness;
    if (distance <= 0) {
      level /= 2 - distance;
      distance = 1;
    }

    int cx = pos % Level.WIDTH;
    int cy = pos / Level.WIDTH;
    int ax = cx - distance;
    if (ax < 0) {
      ax = 0;
    }
    int bx = cx + distance;
    if (bx >= Level.WIDTH) {
      bx = Level.WIDTH - 1;
    }
    int ay = cy - distance;
    if (ay < 0) {
      ay = 0;
    }
    int by = cy + distance;
    if (by >= Level.HEIGHT) {
      by = Level.HEIGHT - 1;
    }

    for (int y = ay; y <= by; y++) {
      for (int x = ax, p = ax + y * Level.WIDTH; x <= bx; x++, p++) {

        if (Dungeon.visible[p]) {

          if (intentional) {
            sprite.parent.addToBack(new CheckedCell(p));
          }

          if (Level.secret[p] && (intentional || Random.Float() < level)) {

            int oldValue = Dungeon.level.map[p];

            GameScene.discoverTile(p, oldValue);

            Level.set(p, Terrain.discover(oldValue));

            GameScene.updateMap(p);

            ScrollOfMagicMapping.discover(p);

            smthFound = true;
          }

          if (intentional) {
            Heap heap = Dungeon.level.heaps.get(p);
            if (heap != null && heap.type == Type.HIDDEN) {
              heap.open(this);
              smthFound = true;
            }
          }
        }
      }
    }

    if (intentional) {
      sprite.showStatus(CharSprite.DEFAULT, TXT_SEARCH);
      sprite.operate(pos);
      if (smthFound) {
        spendAndNext(Random.Float() < level ? TIME_TO_SEARCH : TIME_TO_SEARCH * 2);
      } else {
        spendAndNext(TIME_TO_SEARCH);
      }
    }

    if (smthFound) {
      GLog.w(TXT_NOTICED_SMTH);
      Sample.INSTANCE.play(Assets.SND_SECRET);
      interrupt();
    }

    return smthFound;
  }

  public void resurrect(int resetLevel) {

    HP = HT;
    Dungeon.gold = 0;
    exp = 0;

    belongings.resurrect(resetLevel);

    live();
  }

  @Override
  public HashSet<Class<?>> resistances() {
    RingOfElements.Resistance r = buff(RingOfElements.Resistance.class);
    return r == null ? super.resistances() : r.resistances();
  }

  @Override
  public HashSet<Class<?>> immunities() {
    GasesImmunity buff = buff(GasesImmunity.class);
    return buff == null ? super.immunities() : GasesImmunity.IMMUNITIES;
  }

  @Override
  public void next() {
    super.next();
  }

  public static interface Doom {
    public void onDeath();
  }
}