added extra potions

src/potions/bezerk_brew.cc

@@ -0,0 +1,24 @@
+#include "bezerk_brew.h"
+
+#include <algorithm>
+#include "../constants.h"
+
+bezerk_brew::bezerk_brew(const position &pos):
+        potion{potion_type::bezerk_brew, DURATION, pos} {}
+
+void bezerk_brew::apply(const enum race &race, int &HP, int &ATK,
+                        int &DEF, fraction &base_hit_rate) {
+        if (remaining_duration != 0) {
+                ATK *= ATK_MUL * (race == rdrow ? DROW_POTION_MUL : 1);
+                DEF *= DEF_MUL * (race == rdrow ? DROW_POTION_MUL : 1);
+                --remaining_duration;
+        }
+}
+
+int bezerk_brew::get_priority() const {
+        return CALC_MID;
+}
+
+const char *bezerk_brew::get_name() const {
+        return "BB";
+}

src/potions/bezerk_brew.h

@@ -0,0 +1,18 @@
+#ifndef __BEZERK_BREW_H__
+#define __BEZERK_BREW_H__
+
+#include "../potion.h"
+
+class bezerk_brew final: public potion {
+        static const int ATK_MUL = 2;
+        inline static const float DEF_MUL = 0.5f;
+        static const int DURATION = 15;
+public:
+        bezerk_brew(const position &pos);
+        void apply(const enum race &race, int &HP, int &ATK, int &DEF,
+                   fraction &base_hit_rate) override;
+        int get_priority() const override;
+        const char *get_name() const override;
+};
+
+#endif

src/potions/borrow_life.cc

@@ -0,0 +1,27 @@
+#include "borrow_life.h"
+
+#include <algorithm>
+#include "../constants.h"
+
+borrow_life::borrow_life(const position &pos):
+        potion{potion_type::borrow_life, DURATION, pos} {}
+
+void borrow_life::apply(const enum race &race, int &HP, int &ATK,
+                        int &DEF, fraction &base_hit_rate) {
+        if (remaining_duration == DURATION)
+                HP += GIVE_HP * (race == rdrow ? DROW_POTION_MUL : 1);
+
+        if (remaining_duration != 0)
+                --remaining_duration;
+
+        if (remaining_duration == 0)
+                HP -= LOSE_HP * (race == rdrow ? DROW_POTION_MUL : 1);
+}
+
+int borrow_life::get_priority() const {
+        return CALC_LAST;
+}
+
+const char *borrow_life::get_name() const {
+        return "BL";
+}

src/potions/borrow_life.h

@@ -0,0 +1,18 @@
+#ifndef __BORROW_LIFE_H__
+#define __BORROW_LIFE_H__
+
+#include "../potion.h"
+
+class borrow_life final: public potion {
+        static const int GIVE_HP = 50;
+        static const int LOSE_HP = 55;
+        static const int DURATION = 25;
+public:
+        borrow_life(const position &pos);
+        void apply(const enum race &race, int &HP, int &ATK, int &DEF,
+                   fraction &base_hit_rate) override;
+        int get_priority() const override;
+        const char *get_name() const override;
+};
+
+#endif

src/potions/continuous_restoration.cc

@@ -0,0 +1,28 @@
+#include "continuous_restoration.h"
+
+#include <algorithm>
+#include "../constants.h"
+
+continuous_restoration::continuous_restoration(const position &pos):
+        potion{potion_type::continuous_restoration, DURATION, pos} {}
+
+void continuous_restoration::apply(const enum race &race, int &HP, int &ATK,
+                                   int &DEF, fraction &base_hit_rate) {
+        if (remaining_duration != 0) {
+                int tmp = GAIN_HEALTH;
+
+                if (race == rdrow)
+                        tmp *= DROW_POTION_MUL;
+
+                HP = std::min(HP + tmp, MAX_HP[race]);
+                --remaining_duration;
+        }
+}
+
+int continuous_restoration::get_priority() const {
+        return CALC_BASE;
+}
+
+const char *continuous_restoration::get_name() const {
+        return "CR";
+}

src/potions/continuous_restoration.h

@@ -0,0 +1,17 @@
+#ifndef __CONTINUOUS_RESTORATION_H__
+#define __CONTINUOUS_RESTORATION_H__
+
+#include "../potion.h"
+
+class continuous_restoration final: public potion {
+        static const int GAIN_HEALTH = 3;
+        static const int DURATION = 5;
+public:
+        continuous_restoration(const position &pos);
+        void apply(const enum race &race, int &HP, int &ATK, int &DEF,
+                   fraction &base_hit_rate) override;
+        int get_priority() const override;
+        const char *get_name() const override;
+};
+
+#endif

src/potions/echoing_resilience.cc

@@ -0,0 +1,28 @@
+#include "echoing_resilience.h"
+
+#include <algorithm>
+#include "../constants.h"
+
+echoing_resilience::echoing_resilience(const position &pos):
+        potion{potion_type::echoing_resilience, DURATION, pos} {}
+
+void echoing_resilience::apply(const enum race &race, int &HP, int &ATK,
+                               int &DEF, fraction &base_hit_rate) {
+        if (remaining_duration != 0) {
+                int tmp = GAIN_HEALTH * (race == rdrow ? DROW_POTION_MUL : 1);
+
+                HP = std::min(HP + tmp, MAX_HP[race]);
+                ATK -= LOSE_ATK * (race == rdrow ? DROW_POTION_MUL : 1);
+                DEF -= LOSE_DEF * (race == rdrow ? DROW_POTION_MUL : 1);
+
+                --remaining_duration;
+        }
+}
+
+int echoing_resilience::get_priority() const {
+        return CALC_LAST;
+}
+
+const char *echoing_resilience::get_name() const {
+        return "ER";
+}

src/potions/echoing_resilience.h

@@ -0,0 +1,19 @@
+#ifndef __ECHOING_RESILIENCE_H__
+#define __ECHOING_RESILIENCE_H__
+
+#include "../potion.h"
+
+class echoing_resilience final: public potion {
+        static const int GAIN_HEALTH = 7;
+        static const int LOSE_ATK    = 10;
+        static const int LOSE_DEF    = 10;
+        static const int DURATION    = 20;
+public:
+        echoing_resilience(const position &pos);
+        void apply(const enum race &race, int &HP, int &ATK, int &DEF,
+                   fraction &base_hit_rate) override;
+        int get_priority() const override;
+        const char *get_name() const override;
+};
+
+#endif

src/potions/fine_booze.cc

@@ -0,0 +1,34 @@
+#include "fine_booze.h"
+
+#include <algorithm>
+#include "../constants.h"
+
+fine_booze::fine_booze(const position &pos):
+        potion{potion_type::fine_booze, DURATION, pos} {}
+
+void fine_booze::apply(const enum race &race, int &HP, int &ATK,
+                       int &DEF, fraction &base_hit_rate) {
+        if (remaining_duration != 0) {
+                int tmp = GAIN_HP;
+
+                if (race == rdrow)
+                        tmp *= DROW_POTION_MUL;
+
+                HP = std::min(HP + tmp, MAX_HP[race]);
+
+                if (race == rbrawler)
+                        base_hit_rate = HR_TB;
+                else
+                        base_hit_rate *= HR_MUL;
+
+                --remaining_duration;
+        }
+}
+
+int fine_booze::get_priority() const {
+        return CALC_LAST;
+}
+
+const char *fine_booze::get_name() const {
+        return "FB";
+}

src/potions/fine_booze.h

@@ -0,0 +1,20 @@
+#ifndef __FINE_BOOZE_H__
+#define __FINE_BOOZE_H__
+
+#include "../potion.h"
+#include "../constants.h"
+
+class fine_booze final: public potion {
+        static const int GAIN_HP = 2;
+        inline static const fraction HR_MUL = {7, 10};
+        inline static const fraction HR_TB = {INF, 1};
+        static const int DURATION = 12;
+public:
+        fine_booze(const position &pos);
+        void apply(const enum race &race, int &HP, int &ATK, int &DEF,
+                   fraction &base_hit_rate) override;
+        int get_priority() const override;
+        const char *get_name() const override;
+};
+
+#endif

src/potions/ironclad_ward.cc

@@ -0,0 +1,25 @@
+#include "ironclad_ward.h"
+
+#include <algorithm>
+#include "../constants.h"
+
+ironclad_ward::ironclad_ward(const position &pos):
+        potion{potion_type::ironclad_ward, DURATION, pos} {}
+
+void ironclad_ward::apply(const enum race &race, int &HP, int &ATK,
+                          int &DEF, fraction &base_hit_rate) {
+        if (remaining_duration != 0) {
+                ATK *= ATK_MUL * (race == rdrow ? DROW_POTION_MUL : 1);
+                DEF *= DEF_MUL * (race == rdrow ? DROW_POTION_MUL : 1);
+                base_hit_rate *= HR_MUL;
+                --remaining_duration;
+        }
+}
+
+int ironclad_ward::get_priority() const {
+        return CALC_LAST;
+}
+
+const char *ironclad_ward::get_name() const {
+        return "IW";
+}

src/potions/ironclad_ward.h

@@ -0,0 +1,19 @@
+#ifndef __IRONCLAD_WARD_H__
+#define __IRONCLAD_WARD_H__
+
+#include "../potion.h"
+
+class ironclad_ward final: public potion {
+        inline static const float ATK_MUL = 0.5f;
+        static const int DEF_MUL = 3;
+        inline static const fraction HR_MUL = {3, 4};
+        static const int DURATION = 12;
+public:
+        ironclad_ward(const position &pos);
+        void apply(const enum race &race, int &HP, int &ATK, int &DEF,
+                   fraction &base_hit_rate) override;
+        int get_priority() const override;
+        const char *get_name() const override;
+};
+
+#endif

src/potions/savage_strike.cc

@@ -0,0 +1,24 @@
+#include "savage_strike.h"
+
+#include <algorithm>
+#include "../constants.h"
+
+savage_strike::savage_strike(const position &pos):
+        potion{potion_type::savage_strike, DURATION, pos} {}
+
+void savage_strike::apply(const enum race &race, int &HP, int &ATK, int &DEF,
+                          fraction &base_hit_rate) {
+        if (remaining_duration != 0) {
+                ATK *= ATK_MUL * (race == rdrow ? DROW_POTION_MUL : 1);
+                base_hit_rate *= HR_MUL;
+                --remaining_duration;
+        }
+}
+
+int savage_strike::get_priority() const {
+        return CALC_MID;
+}
+
+const char *savage_strike::get_name() const {
+        return "SS";
+}

src/potions/savage_strike.h

@@ -0,0 +1,18 @@
+#ifndef __SAVAGE_STRIKE_H__
+#define __SAVAGE_STRIKE_H__
+
+#include "../potion.h"
+
+class savage_strike final: public potion {
+        inline static const float ATK_MUL = 1.25f;
+        inline static const fraction HR_MUL  = {4, 5};
+        static const int DURATION = 20;
+public:
+        savage_strike(const position &pos);
+        void apply(const enum race &race, int &HP, int &ATK, int &DEF,
+                   fraction &base_hit_rate) override;
+        int get_priority() const override;
+        const char *get_name() const override;
+};
+
+#endif

src/potions/tempest_tantrum.cc

@@ -0,0 +1,28 @@
+#include "tempest_tantrum.h"
+
+#include <algorithm>
+#include "../constants.h"
+
+tempest_tantrum::tempest_tantrum(const position &pos):
+        potion{potion_type::tempest_tantrum, DURATION, pos} {}
+
+void tempest_tantrum::apply(const enum race &race, int &HP, int &ATK,
+                            int &DEF, fraction &base_hit_rate) {
+        if (remaining_duration == DURATION)
+                HP -= HP_RD_PERCENTAGE * HP *
+                      (race == rdrow ? DROW_POTION_MUL : 1);
+
+        if (remaining_duration != 0) {
+                ATK *= ATK_MUL * (race == rdrow ? DROW_POTION_MUL : 1);
+                DEF *= DEF_MUL * (race == rdrow ? DROW_POTION_MUL : 1);
+                --remaining_duration;
+        }
+}
+
+int tempest_tantrum::get_priority() const {
+        return CALC_LAST;
+}
+
+const char *tempest_tantrum::get_name() const {
+        return "TT";
+}

src/potions/tempest_tantrum.h

@@ -0,0 +1,19 @@
+#ifndef __TEMPEST_TANTRUM_H__
+#define __TEMPEST_TANTRUM_H__
+
+#include "../potion.h"
+
+class tempest_tantrum final: public potion {
+        static const int ATK_MUL = 3;
+        inline static const float DEF_MUL = 0.5f;
+        inline static const float HP_RD_PERCENTAGE = 0.25f;
+        static const int DURATION = 12;
+public:
+        tempest_tantrum(const position &pos);
+        void apply(const enum race &race, int &HP, int &ATK, int &DEF,
+                   fraction &base_hit_rate) override;
+        int get_priority() const override;
+        const char *get_name() const override;
+};
+
+#endif