initial commit

data/10000_Snipe_R_BGC_Spark_1.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ecb5ede663e063e3fd5ce514c25eeae89344946bc6e6f355b9932088c3c503b
+size 23102677

fehsim.py

@@ -0,0 +1,472 @@
+import pandas as pd
+import streamlit as st
+from stqdm import stqdm
+from tqdm import tqdm
+
+
+class Simulator:
+    def __init__(self, settings: dict, streamlit=False):
+        self.streamlit = streamlit
+        target_rarity_map = {
+            'Any Rarity': [
+                'sh_special_4', 'special_4', 'non_focus_3', 'focus_5', 'non_focus_4', 'non_focus_5', 'focus_4'
+            ],
+            'Any 5★ Unit or 4★ Special Rate Unit': [
+                'sh_special_4', 'special_4', 'focus_5', 'non_focus_5'
+            ],
+            'Any 5★ Unit': [
+                'focus_5', 'non_focus_5'
+            ],
+            'Specific 5★ Focus Unit': [
+                'focus_5'
+            ],
+            'Specific 5★ Non-Focus Unit': [
+                'non_focus_5'
+            ],
+            'Any 4★ Unit or 4★ Special Rate Unit or 4★ SHSR Unit': [
+                'sh_special_4', 'special_4', 'non_focus_4', 'focus_4'
+            ],
+            'Any 4★ Unit': [
+                'non_focus_4', 'focus_4'
+            ],
+            'Specific 4★ Focus Unit': [
+                'focus_4'
+            ],
+            'Specific 4★ Non-Focus Unit': [
+                'non_focus_4'
+            ],
+            'Any 4★ Special Rate Unit or 4★ SHSR Unit': [
+                'sh_special_4', 'special_4'
+            ],
+            'Specific 4★ Special Rate Unit': [
+                'special_4'
+            ],
+            'Specific 4★ SHSR Unit': [
+                'sh_special_4'
+            ],
+        }
+        target_color_map = {
+            'Any Color': ['red', 'blue', 'green', 'colorless'],
+            'Red': ['red'],
+            'Blue': ['blue'],
+            'Green': ['green'],
+            'Colorless': ['colorless'],
+        }
+        banner_selection_map = {
+            "(3%/3%) Normal": ['normal', 'normal_4'],
+            "(4%/2%) Weekly Revival": ['weekly_revival'],
+            "(4%/2%) Weekly Revival 4★ SHSR": ['weekly_revival_shsr'],
+            "(5%/3%) Hero Fest": ['hero_fest'],
+            "(4%/2%) Double Special Heroes": ['double_special', 'double_special_4'],
+            "(8%/0%) Legendary / Mythic": ['legendary/mythic']
+        }
+        banner_rates = pd.DataFrame(
+            [
+                ['normal', 'focus_5', 0.03],
+                ['normal', 'non_focus_5', 0.03],
+                ['normal', 'special_4', 0.03],
+                ['normal', 'non_focus_4', 0.55],
+                ['normal', 'non_focus_3', 0.36],
+
+                ['normal_4', 'focus_5', 0.03],
+                ['normal_4', 'non_focus_5', 0.03],
+                ['normal_4', 'focus_4', 0.03],
+
+                ['normal_4', 'special_4', 0.03],
+                ['normal_4', 'non_focus_4', 0.52],
+                ['normal_4', 'non_focus_3', 0.36],
+
+                ['weekly_revival', 'focus_5', 0.04],
+                ['weekly_revival', 'non_focus_5', 0.02],
+                ['weekly_revival', 'special_4', 0.03],
+                ['weekly_revival', 'non_focus_4', 0.55],
+                ['weekly_revival', 'non_focus_3', 0.36],
+
+                ['weekly_revival_shsr', 'focus_5', 0.04],
+                ['weekly_revival_shsr', 'non_focus_5', 0.02],
+                ['weekly_revival_shsr', 'sh_special_4', 0.03],
+                ['weekly_revival_shsr', 'special_4', 0.03],
+                ['weekly_revival_shsr', 'non_focus_4', 0.55],
+                ['weekly_revival_shsr', 'non_focus_3', 0.33],
+
+                ['hero_fest', 'focus_5', 0.05],
+                ['hero_fest', 'non_focus_5', 0.03],
+                ['hero_fest', 'special_4', 0.03],
+                ['hero_fest', 'non_focus_4', 0.55],
+                ['hero_fest', 'non_focus_3', 0.34],
+
+                ['double_special', 'focus_5', 0.06],
+                ['double_special', 'special_4', 0.03],
+                ['double_special', 'non_focus_4', 0.57],
+                ['double_special', 'non_focus_3', 0.34],
+
+                ['double_special_4', 'focus_5', 0.06],
+                ['double_special_4', 'focus_4', 0.03],
+                ['double_special_4', 'special_4', 0.03],
+                ['double_special_4', 'non_focus_4', 0.54],
+                ['double_special_4', 'non_focus_3', 0.34],
+
+                ['legendary/mythic', 'focus_5', 0.08],
+                ['legendary/mythic', 'special_4', 0.03],
+                ['legendary/mythic', 'non_focus_4', 0.55],
+                ['legendary/mythic', 'non_focus_3', 0.34],
+            ],
+            columns=['banner_type', 'rarity_pool', 'rate']
+        )
+        self.pools = settings.get('Pools')
+        self.goals = settings.get('Goals')
+        self.banner_rates = settings.get('Banner Rates')
+
+        self.goals_required = settings.get('Goals Required')
+        self.orb_limit = settings.get('Orb Limit')
+        self.summon_limit = settings.get('Summon Limit')
+        self.banner_type = settings.get('Banner Type', '(3%/3%) Normal')
+        self.n_simulations = settings.get('Simulations', 1000)
+        self.tickets = settings.get('Tickets', 0)
+        self.sparks = settings.get('Sparks', 0)
+        self.focus_charges_enabled = settings.get('Focus Charges', False)
+        self.color_priority = settings.get('Color Priority', ['red', 'blue', 'green', 'colorless'])
+
+        if not any([self.goals_required, self.orb_limit, self.summon_limit]):
+            raise ValueError('No End Criteria (Goals Required, Orb Limit, Summon Limit) provided.')
+
+        self.pools = pd.DataFrame(self.pools)
+        self.goals = pd.DataFrame(self.goals)
+
+        if self.banner_rates is None:
+            if self.pools.loc['focus_4'].sum() > 0:
+                mapped_banner_type = banner_selection_map[self.banner_type][-1]
+            else:
+                mapped_banner_type = banner_selection_map[self.banner_type][0]
+            self.banner_rates = banner_rates[banner_rates['banner_type'] == mapped_banner_type]
+        else:
+            self.banner_rates = pd.DataFrame(self.banner_rates).reset_index()
+            self.banner_rates.columns = ['rarity_pool', 'rate']
+
+        bool_rate_5 = self.banner_rates.rarity_pool.str.contains('5')
+        bool_rate_non_5 = ~bool_rate_5
+        sum_rate_5 = self.banner_rates.loc[bool_rate_5, 'rate'].sum()
+        sum_rate_non_5 = self.banner_rates.loc[bool_rate_non_5, 'rate'].sum()
+
+        self.banner_rates['step'] = 0
+        pre_calc_rates = [self.banner_rates]
+
+        # feh calculates rate up (rate down for non 5 stars) from base, not from previous step!
+        for i in range(1, 24):
+            inc_rates_df = self.banner_rates.copy(deep=True)
+            inc_rates_df.loc[bool_rate_5, 'rate'] *= 1 + (1 / sum_rate_5) * (0.005 * i)
+            inc_rates_df.loc[bool_rate_non_5, 'rate'] *= 1 - (1 / sum_rate_non_5) * (0.005 * i)
+            inc_rates_df['rate'] = round(inc_rates_df['rate'], 4)
+            inc_rates_df['step'] = i
+            pre_calc_rates.append(inc_rates_df)
+
+        # max pity rate
+        inc_rates_df = self.banner_rates.copy(deep=True)
+        inc_rates_df.loc[bool_rate_5, 'rate'] /= sum_rate_5
+        inc_rates_df.loc[bool_rate_non_5, 'rate'] = 0
+        inc_rates_df['rate'] = round(inc_rates_df['rate'], 4)
+        inc_rates_df['step'] = 24
+        pre_calc_rates.append(inc_rates_df)
+
+        self.banner_rates_pro_df = pd.concat(pre_calc_rates)
+        self.pity_step = 0
+        self.curr_banner_rates_df = self.banner_rates_pro_df[self.banner_rates_pro_df['step'] == self.pity_step]
+
+        pools_to_use = [rp for rp in self.pools.index if rp in self.banner_rates.rarity_pool.values]
+        self.pools = pd.DataFrame(self.pools.loc[pools_to_use])
+        self.pools.reset_index(inplace=True, names='rarity_pool')
+        unpivot_unit_pool = pd.melt(self.pools, id_vars=['rarity_pool'], var_name='color', value_name='size')
+
+        unit_list = []
+        for row in unpivot_unit_pool.itertuples():
+            for _ in range(row.size):
+                unit_list_row = [row.color, row.rarity_pool]
+                unit_list.append(unit_list_row)
+        units_df = pd.DataFrame(unit_list, columns=['color', 'rarity_pool'])
+
+        # joining color priority col to df
+        priority_df = pd.DataFrame(enumerate(self.color_priority, start=1), columns=['color_priority', 'color'])
+        units_df = units_df.join(priority_df.set_index('color'), on='color', validate='m:1')
+
+        # Goals Setup
+        goals_df = self.goals.copy(deep=True)
+        max_goal_group = goals_df.groupby('goal_group')['target_count'].max().reset_index()
+        goals_df = goals_df.join(
+            max_goal_group.set_index('goal_group'), on='goal_group', rsuffix='_max', validate='m:1'
+        )
+        goals_df['target_count'] = goals_df['target_count_max']
+        goals_df = goals_df.drop('target_count_max', axis=1)
+        goals_df['target_color'] = goals_df['target_color']
+        goals_df['current_count'] = 0
+
+        # Adding goal_row bool columns to unit_df
+        reserved_unit_index = []
+
+        for goal in goals_df.itertuples():
+            accepted_pools = target_rarity_map[goal.target_rarity]
+            accepted_colors = target_color_map[goal.target_color]
+            gr_col_name = 'goal_row_' + str(goal.Index)
+            goal_is_specific = 'specific' in goal.target_rarity.lower()
+
+            if goal_is_specific:
+                allowed_units = ~units_df.index.isin(reserved_unit_index)
+            else:
+                allowed_units = True
+
+            units_df[gr_col_name] = units_df['rarity_pool'].isin(accepted_pools) & units_df['color'].isin(
+                accepted_colors) & allowed_units
+
+            if units_df[gr_col_name].any() and goal_is_specific:
+                first_true_index = units_df.index[units_df[gr_col_name]].min()
+                reserved_unit_index.append(first_true_index)
+                units_df[gr_col_name] = units_df.index == first_true_index
+            else:
+                if self.streamlit:
+                    st.warning(f'{gr_col_name} does not have any available units to target.')
+                    st.warning('Target unit may already be reserved by previous goal.')
+                else:
+                    print(f'{gr_col_name} does not have any available units to target.')
+                    print('Target unit may already be reserved by previous goal.')
+
+        # Adding goal_group bool columns to unit_df
+        goal_groups_dict = {}
+        for group in set(goals_df['goal_group']):
+            goals_in_group = ['goal_row_' + str(x) for x in list(goals_df[goals_df['goal_group'] == group].index)]
+            goal_groups_dict['goal_group_' + str(group)] = goals_in_group
+
+        for goal_group in goal_groups_dict:
+            cols = goal_groups_dict[goal_group]
+            units_df[goal_group] = units_df[cols].apply(lambda row: pd.Series(row).any(), axis=1)
+
+        self.gg_cols = list(goal_groups_dict.keys())
+        self.gg_cols.sort()
+        slice_cols = [col for col in list(units_df.columns) if 'goal' not in col] + self.gg_cols
+        units_df = units_df[slice_cols]
+
+        self.base_summon_goals_df = goals_df.copy(deep=True)
+        self.curr_summon_goals_df = self.base_summon_goals_df.copy(deep=True)
+        self.banner_units_df = units_df.copy(deep=True)
+
+        self.goal_cols = list(self.base_summon_goals_df.columns[5:])
+        self.colors_to_target = list(set(self.curr_summon_goals_df.target_color))
+
+        # small adjustments
+        self.spark_thresholds = [_ * 40 for _ in range(1, self.sparks + 1)]
+        self.sparks_redeemed = 0
+        self.sparked_indexes = []
+
+        self.active_focus_charges = 0
+        self.apply_focus_charges = False
+
+        # refs
+        self.circle_df = None
+        self.session_type = 'normal'
+        self.summon_cost = 0
+        self.n_stones_in_circle = 5
+
+        # tracking
+        self.total_orbs_spent = 0
+        self.total_summons = 0
+        self.session_count = 0
+        self.summons_without_any_5 = 0
+        self.halt_pity_increase = False
+        self.end_criteria_met = False
+
+        self.summon_log = []
+        self.prev_summon_log_len = 0
+        self.orbs_spent_log = []
+        self.session_count_log = []
+        self.session_type_log = []
+        self.session_pity_step_log = []
+        self.run_num_log = []
+
+        self.simulation_log_df = None
+
+        self.run_simulations()
+
+    def reset_run(self):
+        self.total_orbs_spent = 0
+        self.total_summons = 0
+        self.session_count = 0
+        self.summons_without_any_5 = 0
+        self.end_criteria_met = False
+
+        self.curr_summon_goals_df = self.base_summon_goals_df.copy(deep=True)
+        self.sparks_redeemed = 0
+        self.sparked_indexes = []
+        self.active_focus_charges = 0
+        self.apply_focus_charges = False
+
+    def run_simulations(self):
+
+        if self.streamlit:
+            progress_bar = stqdm(range(self.n_simulations))
+        else:
+            progress_bar = tqdm(range(self.n_simulations))
+
+        for n in progress_bar:
+            self.simulate_run()
+            self.log_run(n + 1)
+            self.reset_run()
+
+        self.simulation_log_df = pd.DataFrame(self.summon_log)
+        self.simulation_log_df.rename(columns={'Index': 'unit_id'}, inplace=True)
+        self.simulation_log_df['unit_id'] += 1
+        self.simulation_log_df['orbs_spent'] = self.orbs_spent_log
+        self.simulation_log_df['session_count'] = self.session_count_log
+        self.simulation_log_df['session_type'] = self.session_type_log
+        self.simulation_log_df['session_pity_step'] = self.session_pity_step_log
+        self.simulation_log_df['run_num'] = self.run_num_log
+
+        message = f'{self.n_simulations} Simulations Completed'
+        if self.streamlit:
+            st.success(message)
+        else:
+            print(message)
+
+    def simulate_run(self):
+
+        while not self.end_criteria_met:
+            self.setup_session()
+            self.create_circle()
+            self.filter_circle()
+            self.summon_from_circle()
+
+    def log_run(self, run_num):
+        curr_log_len = len(self.summon_log) - self.prev_summon_log_len
+        self.run_num_log = self.run_num_log + [run_num for _ in range(curr_log_len)]
+        self.prev_summon_log_len = len(self.summon_log)
+
+    def setup_session(self):
+        self.session_type = 'normal'
+        self.apply_focus_charges = False
+
+        sparks_remain = self.sparks_redeemed != len(self.spark_thresholds)
+        if sparks_remain and self.total_summons >= self.spark_thresholds[self.sparks_redeemed]:
+            self.sparks_redeemed += 1
+            self.session_type = 'spark'
+            return
+
+        if self.focus_charges_enabled and self.active_focus_charges >= 3:
+            self.apply_focus_charges = True
+
+        self.pity_step = int(self.summons_without_any_5 / 5)
+        self.curr_banner_rates_df = self.banner_rates_pro_df[self.banner_rates_pro_df.step == self.pity_step].copy()
+
+    def create_circle(self):
+        circle = []
+        if self.session_type == 'spark':
+            bool_rarity = self.banner_units_df['rarity_pool'] == 'focus_5'
+            spark_circle = self.banner_units_df.loc[bool_rarity]
+            spark_circle = spark_circle[
+                ~spark_circle.index.isin(self.sparked_indexes)]  # removes previously sparked units
+            self.circle_df = spark_circle
+            return
+
+        for i in range(self.n_stones_in_circle):
+            # draws unit rarities
+            drawn_rarity = self.curr_banner_rates_df.sample(weights='rate')['rarity_pool'].iloc[0]
+            if self.apply_focus_charges and drawn_rarity == 'non_focus_5':
+                drawn_rarity = 'focus_5'
+            units_in_rarity = self.banner_units_df[self.banner_units_df['rarity_pool'] == drawn_rarity]
+            # draws unit from drawn rarities
+            drawn_unit = units_in_rarity.sample()
+            circle.append(drawn_unit)
+
+        self.circle_df = pd.concat(circle)
+
+    def filter_circle(self):
+
+        if self.session_type == 'spark':
+            circle = self.circle_df[self.circle_df[self.gg_cols].any(axis=1)].head(1)
+        elif self.goals_required == 'Any Goal Met' or len(self.colors_to_target) == 1:
+            self.colors_to_target = list(self.curr_summon_goals_df['target_color'].str.lower())
+            circle = self.circle_df[self.circle_df['color'].isin(self.colors_to_target)].sort_values('color_priority')
+        elif self.goals_required == 'All Goals Met':
+            unmet_goals = self.curr_summon_goals_df['current_count'] < self.curr_summon_goals_df['target_count']
+            self.colors_to_target = list(self.curr_summon_goals_df[unmet_goals]['target_color'].str.lower())
+            circle = self.circle_df[self.circle_df['color'].isin(self.colors_to_target)].sort_values('color_priority')
+        else:
+            circle = self.circle_df
+
+        if len(circle) != 0:
+            self.circle_df = circle
+        else:  # if nothing returns after filtering, filter for first stone
+            self.circle_df = self.circle_df.sort_values('color_priority').head(1)
+
+    def summon_from_circle(self):
+        price_index = 0
+        self.session_count += 1
+        self.halt_pity_increase = False
+
+        if self.session_count <= self.tickets + 1:
+            prices = (0, 4, 4, 4, 3)
+        else:
+            prices = (5, 4, 4, 4, 3)
+
+        for row in self.circle_df.itertuples(index=True):  # keep index as true
+            if self.session_type == 'spark':
+                self.sparked_indexes.append(row.Index)
+                self.summon_cost = 0
+            else:
+                self.summon_cost = prices[price_index]
+                self.eval_end_criteria_limits()
+                if self.end_criteria_met:
+                    break
+                self.total_summons += 1
+
+            self.orbs_spent_log.append(self.summon_cost)
+            self.total_orbs_spent += self.summon_cost
+            self.summon_log.append(row)
+            self.session_count_log.append(self.session_count)
+            self.session_type_log.append(self.session_type)
+            self.session_pity_step_log.append(self.pity_step)
+
+            self.update_flags(row)
+            self.update_goals(row)
+            self.eval_end_criteria_goals()
+
+            if self.end_criteria_met:
+                break
+            price_index += 1
+
+        if self.end_criteria_met:
+            return
+
+    def update_flags(self, row):
+        if row.rarity_pool == 'focus_5':
+            self.halt_pity_increase = True
+            self.summons_without_any_5 = 0
+            if self.active_focus_charges >= 3:
+                self.active_focus_charges = 0
+        elif row.rarity_pool == 'non_focus_5':
+            self.summons_without_any_5 = max(0, self.summons_without_any_5 - 20)
+            self.active_focus_charges += 1
+        else:
+            if not self.halt_pity_increase:
+                self.summons_without_any_5 += 1
+
+    def update_goals(self, row):  # takes named tuple from circle_df, updates summon goals based on goal group columns
+        # noinspection PyProtectedMember
+        row_dict = row._asdict()
+        for gg in self.gg_cols:
+            if row_dict[gg]:
+                gg_num = gg.split('_')[-1]
+                self.curr_summon_goals_df.loc[self.curr_summon_goals_df['goal_group'] == gg_num, 'current_count'] += 1
+
+    def eval_end_criteria_goals(self):
+        if self.goals_required is not None:
+            met_goals = self.curr_summon_goals_df['current_count'] >= self.curr_summon_goals_df['target_count']
+            if self.goals_required == 'Any Goal Group Met' and any(met_goals):
+                self.end_criteria_met = True
+            elif self.goals_required == 'All Goal Groups Met' and all(met_goals):
+                self.end_criteria_met = True
+
+    def eval_end_criteria_limits(self):
+        if self.orb_limit != 0:
+            if self.total_orbs_spent + self.summon_cost > self.orb_limit:
+                self.end_criteria_met = True
+        elif self.summon_limit != 0:
+            if self.total_summons + 1 > self.summon_limit:
+                self.end_criteria_met = True
+

settings.py

@@ -0,0 +1,609 @@
+import streamlit as st
+import pandas as pd
+import fehsim
+import json
+from io import BytesIO
+
+RARITY_OPTIONS = [
+    'Any Rarity',
+    'Any 5★ Unit or 4★ Special Rate Unit',
+    'Any 5★ Unit',
+    'Specific 5★ Focus Unit',
+    'Specific 5★ Non-Focus Unit',
+    'Any 4★ Unit or 4★ Special Rate Unit or 4★ SHSR Unit',
+    'Any 4★ Unit',
+    'Specific 4★ Focus Unit',
+    'Specific 4★ Non-Focus Unit',
+    'Any 4★ Special Rate Unit or 4★ SHSR Unit',
+    'Specific 4★ Special Rate Unit',
+    'Specific 4★ SHSR Unit'
+]
+COLOR_OPTIONS = [
+    'Any Color',
+    'Red',
+    'Blue',
+    'Green',
+    'Colorless'
+]
+BANNER_OPTIONS = [
+    '(3%/3%) Normal',
+    '(4%/2%) Weekly Revival',
+    '(4%/2%) Weekly Revival 4★ SHSR',
+    '(5%/3%) Hero Fest',
+    '(4%/2%) Double Special Heroes',
+    '(8%/0%) Legendary / Mythic'
+]
+END_CRITERIA_OPTIONS = [
+    'Any Goal Group Met',
+    'All Goal Groups Met',
+]
+BANNER_RATES_MAPPING = {
+    "(3%/3%) Normal": ['normal', 'normal_4'],
+    "(4%/2%) Weekly Revival": ['weekly_revival'],
+    "(4%/2%) Weekly Revival 4★ SHSR": ['weekly_revival_shsr'],
+    "(5%/3%) Hero Fest": ['hero_fest'],
+    "(4%/2%) Double Special Heroes": ['double_special', 'double_special_4'],
+    "(8%/0%) Legendary / Mythic": ['legendary/mythic']
+}
+
+POOL_ORDER = [
+    'focus_5',
+    'non_focus_5',
+    'focus_4',
+    'special_4',
+    'sh_special_4',
+    'non_focus_4',
+    'non_focus_3'
+]
+
+BANNER_RATES = [
+    ['normal', 'focus_5', 0.03],
+    ['normal', 'non_focus_5', 0.03],
+    ['normal', 'special_4', 0.03],
+    ['normal', 'non_focus_4', 0.55],
+    ['normal', 'non_focus_3', 0.36],
+
+    ['normal_4', 'focus_5', 0.03],
+    ['normal_4', 'non_focus_5', 0.03],
+    ['normal_4', 'focus_4', 0.03],
+    ['normal_4', 'special_4', 0.03],
+    ['normal_4', 'non_focus_4', 0.52],
+    ['normal_4', 'non_focus_3', 0.36],
+
+    ['weekly_revival', 'focus_5', 0.04],
+    ['weekly_revival', 'non_focus_5', 0.02],
+    ['weekly_revival', 'special_4', 0.03],
+    ['weekly_revival', 'non_focus_4', 0.55],
+    ['weekly_revival', 'non_focus_3', 0.36],
+
+    ['weekly_revival_shsr', 'focus_5', 0.04],
+    ['weekly_revival_shsr', 'non_focus_5', 0.02],
+    ['weekly_revival_shsr', 'sh_special_4', 0.03],
+    ['weekly_revival_shsr', 'special_4', 0.03],
+    ['weekly_revival_shsr', 'non_focus_4', 0.55],
+    ['weekly_revival_shsr', 'non_focus_3', 0.33],
+
+    ['hero_fest', 'focus_5', 0.05],
+    ['hero_fest', 'non_focus_5', 0.03],
+    ['hero_fest', 'special_4', 0.03],
+    ['hero_fest', 'non_focus_4', 0.55],
+    ['hero_fest', 'non_focus_3', 0.34],
+
+    ['double_special', 'focus_5', 0.06],
+    ['double_special', 'special_4', 0.03],
+    ['double_special', 'non_focus_4', 0.57],
+    ['double_special', 'non_focus_3', 0.34],
+
+    ['double_special_4', 'focus_5', 0.06],
+    ['double_special_4', 'focus_4', 0.03],
+    ['double_special_4', 'special_4', 0.03],
+    ['double_special_4', 'non_focus_4', 0.54],
+    ['double_special_4', 'non_focus_3', 0.34],
+
+    ['legendary/mythic', 'focus_5', 0.08],
+    ['legendary/mythic', 'special_4', 0.03],
+    ['legendary/mythic', 'non_focus_4', 0.55],
+    ['legendary/mythic', 'non_focus_3', 0.34],
+]
+BANNER_RATES_DF = pd.DataFrame(BANNER_RATES, columns=['banner_type', 'rarity_pool', 'rate'])
+BANNER_RATES_DF['rate'] *= 100
+
+pool_to_alias = {
+    'focus_5': '5★ Focus',
+    'focus_4': '4★ Focus',
+    'non_focus_5': '5★',
+    'special_4': '4★ SR',
+    'sh_special_4': '4★ SHSR',
+    'non_focus_4': '4★',
+    'non_focus_3': '3★',
+}
+alias_to_pool = {v: k for k, v in pool_to_alias.items()}
+BANNER_RATES_DF['rarity_pool'] = BANNER_RATES_DF['rarity_pool'].map(pool_to_alias)
+
+
+def core_settings(settings):
+    st.subheader('Simulation Settings', anchor=False)
+
+    st.write('End Criteria:')
+    tt = 'End a run when goal conditions are met.'
+    if st.toggle('Goals Met', help=tt, key='toggle_goals_met'):
+        goals_required = st.selectbox(
+            'GR',
+            options=END_CRITERIA_OPTIONS,
+            label_visibility='collapsed',
+            key='select_goals_required'
+        )
+    else:
+        goals_required = None
+
+    tt = 'End a run when Orb Limit is reached or not enough orbs to summon.'
+    if st.toggle('Orb Limit', help=tt, value=True, key='toggle_orb_limit'):
+        orb_limit = st.number_input(
+            'OL',
+            value=3000,
+            step=1,
+            min_value=0,
+            label_visibility='collapsed',
+            key='input_orb_limit'
+        )
+    else:
+        orb_limit = None
+
+    tt = 'End a run when Summon Limit is reached.'
+    if st.toggle('Summon Limit', help=tt, key='toggle_summon_limit'):
+        summon_limit = st.number_input(
+            'SL',
+            value=15_000,
+            step=1,
+            min_value=0,
+            label_visibility='collapsed',
+            key='input_summon_limit'
+        )
+    else:
+        summon_limit = None
+
+    if not any([goals_required, orb_limit, summon_limit]):
+        st.warning('Please select at least one End Criteria.')
+
+    col1, col2 = st.columns([3, 2])
+
+    with col2:
+        st.write("")
+        st.write("")
+        focus_charges = st.checkbox('Enable Focus Charges?', key='toggle_focus_charges')
+    with col1:
+        tt = 'Highest Priority -> Lowest Priority'
+        color_priority = st.multiselect(
+            'Color Priority',
+            COLOR_OPTIONS[1:],
+            default=COLOR_OPTIONS[1:],
+            help=tt,
+            key='select_color_priority'
+        )
+    if len(color_priority) != 4:
+        st.warning('Please sort all the colors.')
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        tt = 'Select the banner rates to simulate. Will also determine which pools are used.'
+        banner_type = st.selectbox(
+            'Banner Type:',
+            options=BANNER_OPTIONS,
+            help=tt,
+            key='select_banner_type',
+        )
+        tt = 'Number of simulations to run.'
+        simulations = st.number_input(
+            'Simulations',
+            value=100,
+            step=1,
+            min_value=0,
+            help=tt,
+            key='input_simulations'
+        )
+        tt = 'Number of summoning sessions (i.e. circles) where the first summon is free.'
+
+    with col2:
+        tickets = st.number_input(
+            'Tickets',
+            value=0,
+            step=1,
+            min_value=0,
+            help=tt,
+            key='input_tickets'
+        )
+        tt = 'Guaranteed 5★ Focus Unit (i.e. spark) session after 40 summons.'
+        sparks = st.number_input(
+            'Sparks',
+            value=0,
+            step=1,
+            min_value=0,
+            help=tt,
+            key='input_sparks'
+        )
+
+    summon_pools = settings['Pools']
+    focus_5_pool_size = summon_pools.loc['focus_5'][1:].sum()
+    if sparks > focus_5_pool_size:
+        st.warning(f'Sparks exceeding the number of 5★ Focus Units.')
+
+    updated_core_settings = {
+        # End Criteria
+        'Goals Required': goals_required,
+        'Orb Limit': orb_limit,
+        'Summon Limit': summon_limit,
+        # Main Settings
+        'Banner Type': banner_type,
+        'Simulations': simulations,
+        'Tickets': tickets,
+        'Sparks': sparks,
+        'Focus Charges': focus_charges,
+        'Color Priority': color_priority,
+    }
+
+    return updated_core_settings
+
+
+def goal_settings(settings):
+    st.subheader('Summoning Goals', anchor=False, help='Edit the table below to set your summoning goals')
+    st.caption(f"{bo('Goals')} of the same {bo('Goal Group')} will contribute to a {bo('Shared Target Count')}.")
+    st.caption(f"{bo('Shared Target Count')} will be the max {bo('Target Count')} within the {bo('Goal Group')}.")
+    column_config = {
+        "target_rarity": st.column_config.SelectboxColumn(
+            "Rarity", options=RARITY_OPTIONS, required=True, width='large'
+        ),
+        "target_color": st.column_config.SelectboxColumn(
+            "Color", options=COLOR_OPTIONS, required=True, width='small'
+        ),
+        "target_count": st.column_config.NumberColumn(
+            "Target Count", min_value=1, step=1, required=True, width='small'
+        ),
+        "goal_group": st.column_config.NumberColumn(
+            "Goal Group", min_value=1, step=1, required=True, width='small'
+        ),
+    }
+    df = settings['Goals']
+    return st.data_editor(
+        df,
+        num_rows='dynamic',
+        column_config=column_config,
+        use_container_width=True,
+        hide_index=True,
+        key='data_editor_goals'
+    ), df
+
+
+def pool_settings(settings):
+    st.subheader('Summoning Pool', anchor=False, help='Edit the table below to set your summoning pools')
+    column_config = {
+        "red": st.column_config.NumberColumn("Red", min_value=0, step=1, required=True),
+        "blue": st.column_config.NumberColumn("Blue", min_value=0, step=1, required=True),
+        "green": st.column_config.NumberColumn("Green", min_value=0, step=1, required=True),
+        "colorless": st.column_config.NumberColumn("Colorless", min_value=0, step=1, required=True),
+        "rarity_pool": st.column_config.TextColumn("Rarity Pool", disabled=True),
+    }
+    df = settings['Pools']
+    return st.data_editor(
+        df,
+        column_config=column_config,
+        hide_index=True,
+        key='data_editor_pools'
+    ), df
+
+
+def rate_settings(settings):
+    st.subheader('Summoning Rates', anchor=False, help='Edit the table below to set your summoning rates')
+    st.caption(f"Changes to {bo('4★ Focus pool')} or {bo('Banner Type')} will reset this table.")
+    column_config = {
+        "rarity_pool": st.column_config.SelectboxColumn(
+            "Rarity Pool", disabled=True
+        ),
+        "rate": st.column_config.NumberColumn(
+            "Rate (%)", min_value=0, step=0.01, max_value=100, required=True, format="%.2f"
+        ),
+    }
+    summon_pools = settings['Pools']
+    focus_4_pool_size = summon_pools.loc['focus_4'][1:].sum()
+    if focus_4_pool_size > 0:
+        mapped_banner_type = BANNER_RATES_MAPPING[settings['Banner Type']][-1]
+        if len(BANNER_RATES_MAPPING[settings['Banner Type']]) == 1:
+            st.warning(f'4★ Focus Units do not appear in this Banner Type.')
+    else:
+        mapped_banner_type = BANNER_RATES_MAPPING[settings['Banner Type']][0]
+
+    if mapped_banner_type not in settings['Banner Rates']['banner_type'].values:
+        df = BANNER_RATES_DF[BANNER_RATES_DF.banner_type == mapped_banner_type]
+    else:
+        df = settings['Banner Rates']
+
+    return st.data_editor(
+        df,
+        column_config=column_config,
+        hide_index=True,
+        column_order=['rarity_pool', 'rate'],
+        key='data_editor_rates'
+    ), df
+
+
+def goal_setting_example():
+    with st.expander("Goal Group Examples"):
+        st.caption("You want (11) copies of a Red unit present in both the 5★ Focus pool and 4★ Non-Focus pool.")
+        st.caption("Goal Group 1 will be met once a shared total of (11) units are summoned.")
+        ex_data = [
+            ['Specific 5★ Focus Unit', 'Red', 11, 1],
+            ['Specific 4★ Non-Focus Unit', 'Red', 11, 1]
+        ]
+        ex_df = pd.DataFrame(ex_data, columns=['Rarity', 'Color', 'Target Count', 'Goal Group'])
+        st.dataframe(ex_df, hide_index=True)
+        st.divider()
+        st.caption("You want (8) units with a specific skill.")
+        st.caption("(2) Blue units with this skill are present in the 5★ Non-Focus pool.")
+        st.caption("(1) Green unit with this skill is present in the 4★ Non-Focus pool.")
+        st.caption("Goal Group 2 will be met once a shared total of (8) units are summoned.")
+        ex_data = [
+            ['Specific 5★ Non-Focus  Unit', 'Blue', 8, 2],
+            ['Specific 5★ Non-Focus  Unit', 'Blue', 8, 2],
+            ['Specific 4★ Non-Focus Unit', 'Green', 8, 2],
+        ]
+        ex_df = pd.DataFrame(ex_data, columns=['Rarity', 'Color', 'Target Count', 'Goal Group'])
+        st.dataframe(ex_df, hide_index=True)
+
+
+def bo(text):  # streamlit bold orange markdown
+    return f":orange[__{text}__]"
+
+
+def user_to_sys(settings):
+    sys_settings = {}
+
+    for k, v in settings.items():
+        if isinstance(v, pd.DataFrame):
+            val = v.copy(deep=True)
+        else:
+            val = v
+        sys_settings[k] = val
+
+    sys_goals = sys_settings['Goals']
+    sys_settings['Goals'] = sys_goals.to_dict()
+
+    sys_pools = sys_settings['Pools']
+    sys_pools = sys_pools.drop('rarity_pool', axis=1)
+    sys_settings['Pools'] = sys_pools.to_dict()
+
+    sys_rates = sys_settings['Banner Rates']
+    sys_rates = sys_rates.drop('banner_type', axis=1)
+    sys_rates['rarity_pool'] = sys_rates['rarity_pool'].map(alias_to_pool)
+    sys_rates['rate'] = round(sys_rates['rate'] / 100, 4)
+    sys_rates.index = sys_rates['rarity_pool']
+    sys_rates = sys_rates.drop('rarity_pool', axis=1)
+    sys_settings['Banner Rates'] = sys_rates.to_dict()
+
+    sys_settings['Color Priority'] = [c.lower() for c in sys_settings['Color Priority']]
+
+    return sys_settings
+
+
+def sys_to_user(settings):
+    user_settings = {}
+
+    for k, v in settings.items():
+        if isinstance(v, dict):
+            val = pd.DataFrame(v)
+        else:
+            val = v
+        user_settings[k] = val
+
+    user_pools = user_settings['Pools']
+    user_pools['rarity_pool'] = user_pools.index
+    user_pools['rarity_pool'] = user_pools['rarity_pool'].map(pool_to_alias)
+    col_order = ['rarity_pool', 'red', 'blue', 'green', 'colorless']
+    user_settings['Pools'] = user_pools[col_order]
+
+    user_rates = user_settings['Banner Rates']
+    user_rates = user_rates.reset_index(names='rarity_pool')
+    must_only_have = user_rates.rarity_pool.values
+    df = BANNER_RATES_DF.copy(deep=True)
+    df['rarity_pool'] = df['rarity_pool'].map(alias_to_pool)
+    grouped_df = df.groupby('banner_type')['rarity_pool']
+    filtered_banner_types = grouped_df.apply(lambda x: set(must_only_have) == set(x)).reset_index()
+    filtered_banner_types = filtered_banner_types[filtered_banner_types['rarity_pool']]
+    compatible_banners = df[df['banner_type'].isin(filtered_banner_types['banner_type'])]
+    user_rates['banner_type'] = compatible_banners.banner_type.values[0]
+    user_rates['rate'] = user_rates['rate'] * 100
+    col_order = ['banner_type', 'rarity_pool', 'rate']
+    sorting_order = {v: i for i, v in enumerate(POOL_ORDER)}
+    user_rates['order'] = user_rates['rarity_pool'].map(sorting_order)
+    user_rates = user_rates.sort_values(by='order').drop(columns='order').reset_index(drop=True)
+    user_rates['rarity_pool'] = user_rates['rarity_pool'].map(pool_to_alias)
+
+    user_settings['Banner Rates'] = user_rates[col_order]
+    user_settings['Color Priority'] = [c.capitalize() for c in user_settings['Color Priority']]
+
+    return user_settings
+
+
+def debug_compare(setting_1, setting_2):
+    comparison = {}
+    for k, v in setting_1.items():
+        if isinstance(v, pd.DataFrame):
+            compare = v.equals(setting_2[k])
+        else:
+            compare = v == setting_2[k]
+        comparison[k] = compare
+    return comparison
+
+
+def settings_app():
+    st.set_page_config(layout="centered")
+    css = '''
+    <style>
+        section.main > div {max-width:55rem}
+    </style>
+    '''
+    st.markdown(css, unsafe_allow_html=True)
+    st.subheader("FEH Detailed Summoning Simulator", anchor=False)
+
+    # initialize session state
+    if 'user_settings' not in st.session_state:
+        default_goals = [['Specific 5★ Focus Unit', 'Red', 11, 1]]
+        default_pools = {
+            'focus_5': ['5★ Focus', 1, 1, 1, 1],
+            'focus_4': ['4★ Focus', 0, 0, 0, 0],
+            'non_focus_5': ['5★', 26, 27, 19, 19],
+            'special_4': ['4★ SR', 62, 42, 36, 28],
+            'sh_special_4': ['4★ SHSR', 22, 28, 32, 27],
+            'non_focus_4': ['4★', 41, 45, 37, 45],
+            'non_focus_3': ['3★', 41, 45, 37, 45],
+        }
+        pool_cols = ['rarity_pool', 'red', 'blue', 'green', 'colorless']
+        goal_cols = ['target_rarity', 'target_color', 'target_count', 'goal_group']
+        mapped_banner_type = BANNER_RATES_MAPPING[BANNER_OPTIONS[0]][0]
+        default_settings = {
+            # Dataframes
+            'Pools': pd.DataFrame.from_dict(default_pools, orient='index', columns=pool_cols),
+            'Goals': pd.DataFrame(default_goals, columns=goal_cols),
+            'Banner Rates': BANNER_RATES_DF[BANNER_RATES_DF.banner_type == mapped_banner_type].copy(deep=True),
+            # End Criteria
+            'Goals Required': 'All Goal Groups Met',
+            'Orb Limit': 3000,
+            'Summon Limit': None,
+            # Main Settings
+            'Banner Type': BANNER_OPTIONS[0],
+            'Simulations': 100,
+            'Tickets': 0,
+            'Sparks': 0,
+            'Focus Charges': False,
+            'Color Priority': ['Red', 'Blue', 'Green', 'Colorless'],
+        }
+        st.session_state.user_settings = default_settings
+
+    # upload settings from json
+    uploaded_file = st.file_uploader("Upload gui_simulator_settings.json file", type=['json'])
+    if uploaded_file is not None:
+        if st.button("Submit", use_container_width=True):
+            data = json.load(uploaded_file)
+            if 'gui_settings' not in data or 'simulator_settings' not in data:
+                st.error("Invalid gui_simulator_settings.json file")
+            else:
+                st.session_state.user_settings = sys_to_user(data['simulator_settings'])
+                for k, v in data['gui_settings'].items():
+                    st.session_state[k] = v
+
+    st.divider()
+
+    current_settings = st.session_state.user_settings
+    prev_banner_type = current_settings['Banner Type']
+
+    updated_data = core_settings(current_settings)
+    for k, v in updated_data.items():
+        st.session_state.user_settings[k] = v
+
+    if prev_banner_type != current_settings['Banner Type']:
+        st.session_state.flag_update_rates = True
+    else:
+        st.session_state.flag_update_rates = False
+
+    current_settings = st.session_state.user_settings
+    new_goals, prev_goals = goal_settings(current_settings)
+
+    goal_setting_example()
+
+    if st.button("Update Summoning Goals", use_container_width=True):
+        st.session_state.user_settings['Goals'] = new_goals
+        st.experimental_rerun()
+
+    if not prev_goals.equals(new_goals):
+        st.warning("Unsaved changes")
+
+    sub_col1, sub_col2 = st.columns([1, 1])
+
+    with sub_col1:
+        current_settings = st.session_state.user_settings
+        new_pools, prev_pools = pool_settings(current_settings)
+
+        if st.button("Update Summoning Pools", use_container_width=True):
+            st.session_state.user_settings['Pools'] = new_pools
+            st.experimental_rerun()
+
+        if not prev_pools.equals(new_pools):
+            st.warning("Unsaved changes")
+
+    with sub_col2:
+        current_settings = st.session_state.user_settings
+        new_rates, prev_rates = rate_settings(current_settings)
+
+        if st.button("Update Summoning Rates", use_container_width=True) or st.session_state.flag_update_rates:
+            st.session_state.user_settings['Banner Rates'] = new_rates
+            st.session_state.flag_update_rates = False
+            st.experimental_rerun()
+
+        if not prev_rates.equals(new_rates):
+            st.warning("Unsaved changes")
+
+        sum_rates = sum(new_rates['rate'])
+        if sum_rates != 100:
+            st.warning(f"Rates should sum to 100% | Currently: {sum_rates:.2f}%")
+
+    st.divider()
+    widget_keys = [
+        'input_sparks',
+        'select_color_priority',
+        'select_goals_required',
+        'input_summon_limit',
+        'toggle_summon_limit',
+        'toggle_goals_met',
+        'toggle_orb_limit',
+        'input_simulations',
+        'select_banner_type',
+        'input_tickets',
+        'flag_update_rates'
+    ]
+    gui_settings = {k: st.session_state.get(k, False) for k in widget_keys}
+    st.session_state.sys_settings = user_to_sys(st.session_state.user_settings)
+
+    col1, col2 = st.columns([2, 1])
+    with col1:
+        st.download_button(
+            label=":blue[Download GUI + Simulator Settings]",
+            data=json.dumps({'gui_settings': gui_settings, 'simulator_settings': st.session_state.sys_settings}),
+            file_name="gui_simulator_settings.json",
+            use_container_width=True,
+            help='Settings compatible with the GUI and the simulator.'
+        )
+
+    with col2:
+        st.download_button(
+            label=":blue[Download Simulator Settings]",
+            data=json.dumps(st.session_state.sys_settings),
+            file_name="simulator_settings.json",
+            use_container_width=True,
+            help='Settings compatible with the simulator.'
+        )
+
+    if st.button(':orange[Run Simulation]', use_container_width=True):
+        results = fehsim.Simulator(st.session_state.sys_settings, streamlit=True).simulation_log_df
+        st.session_state.simulation_log_df = results
+        buffer = BytesIO()
+        results.to_parquet(buffer, index=False)
+        st.download_button(
+            label=":orange[Download Simulation Data]",
+            data=buffer,
+            file_name='data.parquet',
+            use_container_width=True
+        )
+
+    with st.expander('debug_compare', expanded=True):
+        st.divider()
+        st.json(debug_compare(sys_to_user(st.session_state.sys_settings), st.session_state.user_settings))
+
+    # with st.expander('debug'):
+    #     st.json(st.session_state.user_settings)
+    #     st.json(sys_to_user(st.session_state.sys_settings))
+    #     st.divider()
+    #     st.json(st.session_state.sys_settings)
+
+
+if __name__ == "__main__":
+    settings_app()
+