app.py

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
        )


if __name__ == "__main__":
    settings_app()