RuneOptimizer/RuneOptimizerGUI/entity/Rune.py

"""
This file is part of RuneOptimizer.

RuneOptimizer is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.

RuneOptimizer is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
more details.

You should have received a copy of the GNU General Public License along with
RuneOptimizer. If not, see <https://www.gnu.org/licenses/>.

"""

class Rune():
    """
    A rune.

    Parameters
    ----------
    id : str
        Unit identifier.
    unit : str
        ID of the unit the rune is assigned to. None if not assigned.
    type : int
        ID of the rune set.
    type_name : str
        Name of the rune set.
    slot : int
        Rune slot, from 1 to 6.
    stars : int
        Rune grade, from 1 to 6.
    level : int
        Power up level, from 0 to 15.
    quality : int
        Rune original quality ID, from 1 to 5.
    quality_name : str
        Rune original quality name.
    efficiency : float
        Rune efficiency, from 0 to 100.
    max_efficiency : float
        Rune maximum efficiency, from 0 to 100.
    main_stat : RuneStat
        Main stat of the rune.
    innate_stat : RuneStat
        Innate stat of the rune.
    sub_stats : RuneStat[]
        Substats of the rune.
    stats : RuneStat[]
        Every rune stat, including main, innates, and subs, not guaranteed to
        be in order.


    Methods
    -------
    get_stat(stat, level=None)
        Gets a stat given by the rune.

    """
    
    _id = None
    _unit = ""
    _type = 0
    _type_name = ""
    _slot = 1
    _stars = 1
    _level = 0
    _quality = 0
    _quality_name = ""
    _efficiency = 0.0
    _max_efficiency = 0.0
    _main_stat = None
    _innate_stat = None
    _sub_stats = [None, None, None, None]
    _stats_current = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    _stats_lv12 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    _stats_lv15 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

    def __init__(self, id=None):
        if id != None:
            self._load(id)
            
    def _load(self, id):
        global conn
        cursor = conn.execute("""
          SELECT
            id,                    --  0
            unit,
            type,
            slot,
            stars,
            level,                 --  5
            quality,
            efficiency,
            max_efficiency,
            current_hp_percent,
            current_atk_percent,   -- 10
            current_def_percent,
            current_hp_flat,
            current_atk_flat,
            current_def_flat,
            current_spd,           -- 15
            current_crr,
            current_crd,
            current_res,
            current_acc,
            lv12_hp_percent,        -- 20
            lv12_atk_percent,
            lv12_def_percent,
            lv12_hp_flat,
            lv12_atk_flat,
            lv12_def_flat,          -- 25
            lv12_spd,
            lv12_crr,
            lv12_crd,
            lv12_res,
            lv12_acc,               -- 30
            lv15_hp_percent,
            lv15_atk_percent,
            lv15_def_percent,
            lv15_hp_flat,
            lv15_atk_flat,          -- 35
            lv15_def_flat,
            lv15_spd,
            lv15_crr,
            lv15_crd,
            lv15_res,               -- 40
            lv15_acc
          FROM runes
          WHERE
            id = ?;
        """, (id,))
        row = cursor.fetchone()
        if row != None:
            self._main_stat = None
            self._innate_stat = None
            self._sub_stats = [None, None, None, None]
            self._id = str(row[0])
            if len(str(row[1])) > 0:
                self._unit = str(row[1])
            else:
                self._unit = None
            self._type = int(row[2])
            self._type_name = SET_NAMES[self._type]
            self._slot = int(row[3])
            self._stars = int(row[4])
            self._level = int(row[5])
            self._quality = int(row[6])
            self._quality_name = QUALITY_NAMES[self._quality]
            self._efficiency = float(row[7])
            self._max_efficiency = float(row[8])
            self._stats_current[RUNE_STATS["HP_P"]] = int(row[9])
            self._stats_current[RUNE_STATS["ATK_P"]] = int(row[10])
            self._stats_current[RUNE_STATS["DEF_P"]] = int(row[11])
            self._stats_current[RUNE_STATS["HP"]] = int(row[12])
            self._stats_current[RUNE_STATS["ATK"]] = int(row[13])
            self._stats_current[RUNE_STATS["DEF"]] = int(row[14])
            self._stats_current[RUNE_STATS["SPD"]] = int(row[15])
            self._stats_current[RUNE_STATS["CRR"]] = int(row[16])
            self._stats_current[RUNE_STATS["CRD"]] = int(row[17])
            self._stats_current[RUNE_STATS["RES"]] = int(row[18])
            self._stats_current[RUNE_STATS["ACC"]] = int(row[19])
            self._stats_lv12[RUNE_STATS["HP_P"]] = int(row[21])
            self._stats_lv12[RUNE_STATS["ATK_P"]] = int(row[21])
            self._stats_lv12[RUNE_STATS["DEF_P"]] = int(row[22])
            self._stats_lv12[RUNE_STATS["HP"]] = int(row[23])
            self._stats_lv12[RUNE_STATS["ATK"]] = int(row[22])
            self._stats_lv12[RUNE_STATS["DEF"]] = int(row[25])
            self._stats_lv12[RUNE_STATS["SPD"]] = int(row[26])
            self._stats_lv12[RUNE_STATS["CRR"]] = int(row[27])
            self._stats_lv12[RUNE_STATS["CRD"]] = int(row[28])
            self._stats_lv12[RUNE_STATS["RES"]] = int(row[29])
            self._stats_lv12[RUNE_STATS["ACC"]] = int(row[30])
            self._stats_lv15[RUNE_STATS["HP_P"]] = int(row[31])
            self._stats_lv15[RUNE_STATS["ATK_P"]] = int(row[32])
            self._stats_lv15[RUNE_STATS["DEF_P"]] = int(row[33])
            self._stats_lv15[RUNE_STATS["HP"]] = int(row[34])
            self._stats_lv15[RUNE_STATS["ATK"]] = int(row[35])
            self._stats_lv15[RUNE_STATS["DEF"]] = int(row[36])
            self._stats_lv15[RUNE_STATS["SPD"]] = int(row[37])
            self._stats_lv15[RUNE_STATS["CRR"]] = int(row[38])
            self._stats_lv15[RUNE_STATS["CRD"]] = int(row[39])
            self._stats_lv15[RUNE_STATS["RES"]] = int(row[40])
            self._stats_lv15[RUNE_STATS["ACC"]] = int(row[41])

        # Get rune stats
        cursor = conn.execute(
          """
            SELECT slot, stat, value, grind, enchant
            FROM rune_stats WHERE rune = ?
          """,
          (self._id,)
        )
        rows = cursor.fetchall()
        for row in rows:
            stat = RuneStat()
            stat.slot = int(row[0])
            stat.stat = int(row[1])
            stat.value = int(row[2])
            stat.grind = int(row[3])
            stat.enchant = int(row[4])
            if -1 == stat.slot:
                self._main_stat = stat
            elif 0 == stat.slot:
                self._innate_stat = stat
            elif 1 <= stat.slot and 4 >= stat.slot:
                self.sub_stats[stat.slot - 1] = stat

    @property
    def id(self):
        return self._id
    
    @property
    def unit(self):
        return self._unit
    
    @property
    def type(self):
        return self._type
    
    @property
    def type_name(self):
        return self._type_name
    
    @property
    def slot(self):
        return self._slot
    
    @property
    def stars(self):
        return self._stars
    
    @property
    def level(self):
        return self._level

    @property
    def quality(self):
        return self._quality
    
    @property
    def quality_name(self):
        return self._quality_name
    
    @property
    def efficiency(self):
        return self._efficiency
    
    @property
    def max_efficiency(self):
        return self._max_efficiency
    
    @property
    def main_stat(self):
        return self._main_stat
    
    @property
    def innate_stat(self):
        return self._innate_stat
    
    @property
    def sub_stats(self):
        return self._sub_stats
    
    @property
    def stats(self):
        if self._innate_stat != None:
            return [self._main_stat] + [self.innate_stat] + self._sub_stats
        else:
            return [self._main_stat] + self._sub_stats
    
    def get_stat(self, stat, level = None):
        """
        Gets a stat given by the rune.
        
        Level can be specified as 12 or 15 to get the values the rune will have
        at that level. If 12 is specified and the rune current level is higher,
        it's current value is returned.
        """
        if stat in RUNE_STATS.values() == False:
            return 0
        if int(level) == 12:
            return self._stats_lv12[stat]
        elif int(level) == 15:
            return self._stats_lv15[stat]
        else:
            return self._stats_current[stat]