""",
unsafe_allow_html=True,
)
if geometry_ready:
st.success("La geometría real ya está disponible para pintar el mapa.")
else:
st.markdown(
"""
Tablero territorial
La lógica ya está lista. Falta enchufar polígonos reales para pintar el mapa municipal.
""",
unsafe_allow_html=True,
)
c1, c2, c3 = st.columns(3)
with c1:
st.metric("Territorios jugables", territories_count)
with c2:
st.metric("Features geo", len(geo.get("features", [])))
with c3:
st.metric("Mapa pintable", "No")
st.dataframe(turn_summary_df.head(12), width="stretch", hide_index=True)
st.markdown("
{event["label"]}
Tipo {event["event_type"]} | Alcance {event["scope"]} | Severidad inicial {sev_pct}%
Territorios afectados {affected_count}
Partidos más expuestos {blame}
Partidos con oportunidad {opp}
Duración base {event["remaining_rounds"]} rondas
""",
unsafe_allow_html=True,
)
def render_active_shocks():
st.markdown("### Shocks activos")
if not st.session_state.sim_active_events:
st.info("No hay shocks activos acumulados.")
return
rows = []
for event in st.session_state.sim_active_events:
rows.append(
{
"Evento": event["label"],
"Tipo": event["event_type"],
"Severidad vigente": round(event["severity"], 3),
"Rondas restantes": event["remaining_rounds"],
"Territorios": len(event["affected_territories"]),
}
)
st.dataframe(pd.DataFrame(rows), width="stretch", hide_index=True)
def render_event_history():
st.markdown("### Historial de rondas")
if not st.session_state.sim_event_history:
st.info("Todavía no hay rondas cerradas en esta partida.")
return
rows = []
for item in st.session_state.sim_event_history:
event = item["event"]
rows.append(
{
"Ronda": item["round"],
"Evento": event["label"] if event else "Sin evento nuevo",
"Tipo": event["event_type"] if event else "-",
"Severidad": round(event["base_severity"], 3) if event else 0.0,
"Territorios afectados": len(event["affected_territories"]) if event else 0,
}
)
st.dataframe(pd.DataFrame(rows), width="stretch", hide_index=True)
def render_round_summary():
st.markdown("### Resumen de gasto por ronda")
if not st.session_state.sim_round_summary:
st.info("Todavía no hay gasto registrado en rondas cerradas.")
return
rows = []
for item in st.session_state.sim_round_summary:
for party_id, spent in item["spent"].items():
rows.append(
{
"Ronda": item["round"],
"Partido": party_id,
"Gastado": round(spent, 2),
}
)
st.dataframe(pd.DataFrame(rows), width="stretch", hide_index=True)
def ensure_session_defaults():
defaults = {
"sim_initialized": False,
"sim_round": 1,
"sim_state": None,
"sim_orders": [],
"player_party": None,
"sim_cumulative_spend": None,
"sim_last_key": None,
"sim_finished": False,
"sim_seed": 1234,
"sim_event_history": [],
"sim_active_events": [],
"master_territories": None,
"diagnostics": None,
"current_config": None,
"sim_party_cash": None,
"sim_round_summary": [],
"sim_tuning": DEFAULT_TUNING.copy(),
"sim_previous_national_df": None,
"sim_previous_snapshot": None,
"sim_last_territory_changes": None,
"sim_last_national_delta": None,
"sim_profile_name": "Balanceado",
}
for key, value in defaults.items():
if key not in st.session_state:
st.session_state[key] = value.copy() if isinstance(value, dict) else value
def reset_simulation_session(config_key):
st.session_state.sim_initialized = False
st.session_state.sim_round = 1
st.session_state.sim_state = None
st.session_state.sim_orders = []
st.session_state.player_party = None
st.session_state.sim_cumulative_spend = None
st.session_state.sim_finished = False
st.session_state.sim_last_key = config_key
st.session_state.sim_seed = 1234
st.session_state.sim_event_history = []
st.session_state.sim_active_events = []
st.session_state.master_territories = None
st.session_state.diagnostics = None
st.session_state.current_config = None
st.session_state.sim_party_cash = None
st.session_state.sim_round_summary = []
st.session_state.sim_tuning = DEFAULT_TUNING.copy()
st.session_state.sim_previous_national_df = None
st.session_state.sim_previous_snapshot = None
st.session_state.sim_last_territory_changes = None
st.session_state.sim_last_national_delta = None
st.session_state.sim_profile_name = "Balanceado"
def load_profile_into_tuning(profile_name: str):
st.session_state.sim_tuning = PRESET_PROFILES[profile_name].copy()
st.session_state.sim_profile_name = profile_name
def render_tuning_panel():
st.markdown("#### Ajustes tácticos del motor")
profile_name = st.selectbox(
"Perfil táctico",
options=list(PRESET_PROFILES.keys()),
index=list(PRESET_PROFILES.keys()).index(st.session_state.sim_profile_name),
)
if profile_name != st.session_state.sim_profile_name:
load_profile_into_tuning(profile_name)
st.rerun()
t1, t2 = st.columns(2)
with t1:
st.session_state.sim_tuning["channel_effect_multiplier"] = st.slider(
"Potencia del gasto",
min_value=0.50,
max_value=2.50,
value=float(st.session_state.sim_tuning["channel_effect_multiplier"]),
step=0.05,
)
st.session_state.sim_tuning["vote_update_multiplier"] = st.slider(
"Elasticidad del voto",
min_value=0.20,
max_value=1.60,
value=float(st.session_state.sim_tuning["vote_update_multiplier"]),
step=0.05,
)
st.session_state.sim_tuning["event_effect_multiplier"] = st.slider(
"Impacto de eventos",
min_value=0.25,
max_value=2.50,
value=float(st.session_state.sim_tuning["event_effect_multiplier"]),
step=0.05,
)
st.session_state.sim_tuning["npc_budget_aggression"] = st.slider(
"Agresividad presupuestaria NPC",
min_value=0.40,
max_value=1.50,
value=float(st.session_state.sim_tuning["npc_budget_aggression"]),
step=0.05,
)
st.session_state.sim_tuning["event_probability"] = st.slider(
"Probabilidad de evento nuevo",
min_value=0.10,
max_value=1.00,
value=float(st.session_state.sim_tuning["event_probability"]),
step=0.02,
)
with t2:
st.session_state.sim_tuning["player_focus_multiplier"] = st.slider(
"Ventaja por concentración del jugador",
min_value=0.50,
max_value=2.50,
value=float(st.session_state.sim_tuning["player_focus_multiplier"]),
step=0.05,
)
st.session_state.sim_tuning["saturation_factor"] = st.slider(
"Fatiga por saturación",
min_value=0.0000002,
max_value=0.0000030,
value=float(st.session_state.sim_tuning["saturation_factor"]),
step=0.0000001,
format="%.7f",
)
st.session_state.sim_tuning["turnout_spend_scale"] = st.slider(
"Efecto del gasto sobre turnout",
min_value=0.005,
max_value=0.050,
value=float(st.session_state.sim_tuning["turnout_spend_scale"]),
step=0.001,
)
st.session_state.sim_tuning["turnout_competition_scale"] = st.slider(
"Efecto de competencia sobre turnout",
min_value=0.005,
max_value=0.060,
value=float(st.session_state.sim_tuning["turnout_competition_scale"]),
step=0.001,
)
st.session_state.sim_tuning["event_memory_decay"] = st.slider(
"Persistencia de shocks",
min_value=0.40,
max_value=0.95,
value=float(st.session_state.sim_tuning["event_memory_decay"]),
step=0.01,
)
st.session_state.sim_tuning["manual_order_override_mode"] = st.selectbox(
"Modo de órdenes manuales",
options=["additive", "override"],
index=0 if st.session_state.sim_tuning["manual_order_override_mode"] == "additive" else 1,
help="additive suma tus órdenes a la estrategia base del partido. override reemplaza completamente la asignación automática del partido que controlas.",
)
if st.button("Restablecer ajustes tácticos"):
st.session_state.sim_tuning = DEFAULT_TUNING.copy()
st.session_state.sim_profile_name = "Balanceado"
st.rerun()
def apply_manual_orders_to_allocations(
base_allocations: dict,
manual_orders: list[dict],
player_party: str,
state: list[dict],
tuning: dict,
):
if player_party not in base_allocations:
return base_allocations
mode = tuning["manual_order_override_mode"]
if mode == "override":
for territory in state:
t_id = territory["territory_id"]
base_allocations[player_party][t_id] = {
"digital": 0.0,
"territorial": 0.0,
"media": 0.0,
}
for order in manual_orders:
if order["Partido"] != player_party:
continue
t_id = order["territory_id"]
ch = order["channel"]
amount = float(order["Monto"])
if t_id in base_allocations[player_party]:
base_allocations[player_party][t_id][ch] += amount
return base_allocations
def render_control_panel(
state: list[dict],
parties_df: pd.DataFrame,
selected_party_ids: list[str],
total_rounds: int,
):
st.markdown("### Centro de mando")
if st.session_state.player_party not in selected_party_ids:
st.session_state.player_party = selected_party_ids[0]
player_party = st.selectbox(
"Partido controlado por el jugador",
options=selected_party_ids,
index=selected_party_ids.index(st.session_state.player_party),
format_func=lambda x: parties_df.loc[parties_df["party_id"] == x, "sigla"].iloc[0]
if not parties_df.loc[parties_df["party_id"] == x].empty
else x,
key="player_party_selector",
)
st.session_state.player_party = player_party
round_budget_cap = float(get_party_strategy(player_party)["budget"])
total_cash_left = float(st.session_state.sim_party_cash.get(player_party, 0.0))
effective_round_cap = min(round_budget_cap, total_cash_left)
spent_this_round = sum_orders_for_party(st.session_state.sim_orders, player_party)
remaining_this_round = max(0.0, effective_round_cap - spent_this_round)
m1, m2, m3, m4 = st.columns(4)
with m1:
st.metric("Ronda actual", f"{st.session_state.sim_round} / {total_rounds}")
with m2:
st.metric("Tope por ronda", f"${round_budget_cap:,.0f}")
with m3:
st.metric("Caja restante", f"${total_cash_left:,.0f}")
with m4:
st.metric("Disponible esta ronda", f"${remaining_this_round:,.0f}")
control_tab, tuning_tab = st.tabs(["Órdenes", "Ajustes tácticos"])
territory_options = [t["territory_id"] for t in state if t["territory_id"] != "exterior"]
territory_names = {t["territory_id"]: t["name"] for t in state}
with control_tab:
c1, c2 = st.columns([1.35, 1.0])
with c1:
with st.form("manual_order_form", clear_on_submit=True):
territory_selected = st.selectbox(
"Territorio objetivo",
options=territory_options,
format_func=lambda x: territory_names.get(x, x),
)
channel_selected = st.selectbox(
"Canal",
options=list(CHANNELS.keys()),
format_func=lambda x: CHANNELS[x]["label"],
)
amount_selected = st.number_input(
"Monto a asignar",
min_value=0.0,
max_value=float(remaining_this_round),
value=min(10000.0, float(remaining_this_round)),
step=1000.0,
)
submitted = st.form_submit_button("Agregar jugada")
if submitted:
if remaining_this_round <= 0:
st.warning("Ese partido ya no tiene presupuesto utilizable en esta ronda.")
elif amount_selected <= 0:
st.warning("Ingresa un monto mayor que cero.")
else:
st.session_state.sim_orders.append(
{
"Partido": player_party,
"Territorio": territory_names[territory_selected],
"territory_id": territory_selected,
"Canal": CHANNELS[channel_selected]["label"],
"channel": channel_selected,
"Monto": float(amount_selected),
}
)
st.success("Jugada agregada a la ronda actual.")
with c2:
st.markdown("#### Estado del partido controlado")
st.write(f"**Partido** {player_party}")
st.write(f"**Caja total restante** ${total_cash_left:,.0f}")
st.write(f"**Gasto ya ordenado esta ronda** ${spent_this_round:,.0f}")
st.write(f"**Modo manual** {st.session_state.sim_tuning['manual_order_override_mode']}")
st.write(f"**Perfil táctico** {st.session_state.sim_profile_name}")
st.markdown("#### Órdenes cargadas")
st.dataframe(build_orders_dataframe(st.session_state.sim_orders), width="stretch", hide_index=True)
clear_col, close_col = st.columns(2)
with clear_col:
if st.button("Limpiar órdenes de la ronda"):
st.session_state.sim_orders = []
st.rerun()
with close_col:
if st.button("Cerrar ronda y resolver turno"):
if st.session_state.sim_finished:
st.warning("La simulación ya terminó.")
else:
pre_national_df = compute_national_shares(
state=st.session_state.sim_state,
selected_parties=selected_party_ids,
base=st.session_state.current_config["base"],
)
pre_snapshot = snapshot_territory_state(
st.session_state.sim_state,
selected_party_ids,
)
heuristic_allocations = build_campaign_allocations(
state=st.session_state.sim_state,
selected_party_ids=selected_party_ids,
master_territories=st.session_state.master_territories,
diagnostics=st.session_state.diagnostics,
available_cash=st.session_state.sim_party_cash,
tuning=st.session_state.sim_tuning,
)
final_allocations = apply_manual_orders_to_allocations(
heuristic_allocations,
st.session_state.sim_orders,
player_party,
st.session_state.sim_state,
st.session_state.sim_tuning,
)
spent_map = {}
for p in selected_party_ids:
party_total_spent = 0.0
for t_id in final_allocations[p]:
party_total_spent += sum(final_allocations[p][t_id].values())
spent_map[p] = round(party_total_spent, 2)
st.session_state.sim_party_cash[p] = max(
0.0,
float(st.session_state.sim_party_cash.get(p, 0.0)) - party_total_spent
)
new_state, new_cumulative, round_event, new_active_events = apply_one_round(
state=st.session_state.sim_state,
allocations=final_allocations,
selected_party_ids=selected_party_ids,
master_territories=st.session_state.master_territories,
diagnostics=st.session_state.diagnostics,
tuning=st.session_state.sim_tuning,
noise_scale=st.session_state.current_config["noise"],
round_number=st.session_state.sim_round,
cumulative_spend=st.session_state.sim_cumulative_spend,
seed=st.session_state.sim_seed,
player_party=player_party,
active_events=st.session_state.sim_active_events,
)
post_national_df = compute_national_shares(
state=new_state,
selected_parties=selected_party_ids,
base=st.session_state.current_config["base"],
)
post_snapshot = snapshot_territory_state(
new_state,
selected_party_ids,
)
st.session_state.sim_last_national_delta = build_national_delta_df(
current_df=post_national_df,
previous_df=pre_national_df,
selected_parties_df=parties_df[parties_df["party_id"].isin(selected_party_ids)].copy(),
)
st.session_state.sim_last_territory_changes = build_territory_change_df(
current_snapshot=post_snapshot,
previous_snapshot=pre_snapshot,
selected_parties_df=parties_df[parties_df["party_id"].isin(selected_party_ids)].copy(),
)
st.session_state.sim_previous_national_df = pre_national_df
st.session_state.sim_previous_snapshot = pre_snapshot
st.session_state.sim_event_history.append(
{
"round": st.session_state.sim_round,
"event": round_event,
}
)
st.session_state.sim_active_events = new_active_events
st.session_state.sim_round_summary.append(
{
"round": st.session_state.sim_round,
"spent": spent_map,
}
)
st.session_state.sim_state = new_state
st.session_state.sim_cumulative_spend = new_cumulative
st.session_state.sim_orders = []
if st.session_state.sim_round >= total_rounds:
st.session_state.sim_finished = True
else:
st.session_state.sim_round += 1
st.rerun()
with tuning_tab:
render_tuning_panel()
def render_game_state(
selected_parties_df: pd.DataFrame,
state: list[dict],
geo: dict,
base: str,
):
national_df = compute_national_shares(
state=state,
selected_parties=list(selected_parties_df["party_id"]),
base=base,
)
delta_df = build_national_delta_df(
current_df=national_df,
previous_df=st.session_state.sim_previous_national_df,
selected_parties_df=selected_parties_df,
)
turn_summary_df = build_turn_summary(
state=state,
selected_parties_df=selected_parties_df,
base=base,
)
st.subheader("Resumen nacional")
render_candidate_cards(delta_df)
st.subheader("Tablero principal")
c_map, c_side = st.columns([1.7, 1.0], gap="large")
with c_map:
render_map_placeholder(turn_summary_df, geo)
with c_side:
latest_event = st.session_state.sim_event_history[-1]["event"] if st.session_state.sim_event_history else None
render_event_card(latest_event)
st.markdown("### Panel de turno")
st.dataframe(build_state_preview(state), width="stretch", hide_index=True)
st.markdown("### Estrategia por partido")
strategy_rows = []
for p in selected_parties_df["party_id"]:
strat = get_party_strategy(p)
cash_left = float(st.session_state.sim_party_cash.get(p, 0.0))
strategy_rows.append(
{
"party_id": p,
"budget_round": strat["budget"],
"cash_left": round(cash_left, 2),
"digital_share": strat["digital_share"],
"territorial_share": strat["territorial_share"],
"media_share": strat["media_share"],
}
)
st.dataframe(pd.DataFrame(strategy_rows), width="stretch", hide_index=True)
st.subheader("Marcador nacional")
st.dataframe(
delta_df[["sigla", "national_share_pct", "delta_pct"]].rename(
columns={
"sigla": "Partido",
"national_share_pct": "% nacional estimado",
"delta_pct": "Δ ronda",
}
),
width="stretch",
hide_index=True,
)
render_active_shocks()
render_event_history()
render_round_summary()
st.subheader("Movimiento territorial")
if st.session_state.sim_last_territory_changes is None:
st.info("Todavía no hay cambios territoriales comparables. Cierra al menos una ronda.")
else:
st.dataframe(
st.session_state.sim_last_territory_changes.sort_values(
["Cambio de líder", "Δ % líder", "% líder"],
ascending=[False, False, False],
),
width="stretch",
hide_index=True,
)
def run_game_tab():
ensure_session_defaults()
territories = load_territories()
parties = load_parties()
indicators = load_indicators()
geo = load_geo_44()
validation = validate_territories(territories, geo)
master_territories, diagnostics = build_master_territories(territories, indicators)
config = config_panel(parties)
config_key = (
config["mode"],
tuple(config["parties"]),
config["exterior"],
config["base"],
config["rounds"],
config["noise"],
)
if st.session_state.sim_last_key != config_key:
reset_simulation_session(config_key)
st.subheader("Validación territorial")
c1, c2, c3 = st.columns(3)
with c1:
st.metric("Geo municipios", validation["geo_count"])
with c2:
st.metric("CSV territorios", validation["csv_count"])
with c3:
st.metric("Duplicados", validation["duplicates"])
if validation["missing_in_csv"]:
st.error(f"Faltan en CSV {list(validation['missing_in_csv'])}")
if validation["missing_in_geo"]:
st.warning(f"No están en GEO {list(validation['missing_in_geo'])}")
if validation["csv_count"] != EXPECTED_MUNICIPALITIES:
st.warning(f"Territorios esperados {EXPECTED_MUNICIPALITIES}")
st.divider()
st.subheader("Configuración seleccionada")
st.json(config)
st.subheader("Diagnóstico de pesos")
d1, d2 = st.columns(2)
with d1:
st.write("**Columna detectada para población**")
st.code(str(diagnostics["population_col"]))
st.write(f"Valores no nulos {diagnostics['population_non_null']}")
st.write(f"Modo {diagnostics['population_mode']}")
with d2:
st.write("**Columna detectada para registro electoral**")
st.code(str(diagnostics["registry_col"]))
st.write(f"Valores no nulos {diagnostics['registry_non_null']}")
st.write(f"Modo {diagnostics['registry_mode']}")
if diagnostics["population_mode"] == "uniform_fallback":
st.warning("No hay datos numéricos de población utilizables en indicators.csv. Se está usando ponderación uniforme.")
if config["base"] == "Registro electoral" and diagnostics["registry_mode"] == "uniform_fallback":
st.warning("No hay datos numéricos de registro electoral utilizables en indicators.csv. Se está usando ponderación uniforme.")
if diagnostics["registry_mode"] == "estimated_from_indicators":
st.info("El registro electoral está siendo estimado a partir de población, ruralidad, educación y pobreza.")
if not config["parties"]:
st.warning("Selecciona al menos un partido para continuar.")
return
selected_parties_df = parties[parties["party_id"].isin(config["parties"])].copy()
if not st.session_state.sim_initialized:
if st.button("Iniciar simulación"):
st.session_state.master_territories = master_territories
st.session_state.diagnostics = diagnostics
st.session_state.current_config = config
st.session_state.sim_seed = 1234
st.session_state.sim_state = initialize_simulation(
master_territories=master_territories,
parties=selected_parties_df,
use_exterior=config["exterior"],
diagnostics=diagnostics,
)
st.session_state.sim_cumulative_spend = {
p: {t["territory_id"]: 0.0 for t in st.session_state.sim_state}
for p in list(selected_parties_df["party_id"])
}
st.session_state.sim_party_cash = {
p: get_total_campaign_budget(p, config["rounds"])
for p in list(selected_parties_df["party_id"])
}
st.session_state.sim_initialized = True
st.session_state.sim_round = 1
st.session_state.sim_orders = []
st.session_state.player_party = list(selected_parties_df["party_id"])[0]
st.session_state.sim_event_history = []
st.session_state.sim_active_events = []
st.session_state.sim_round_summary = []
st.session_state.sim_previous_national_df = None
st.session_state.sim_previous_snapshot = None
st.session_state.sim_last_territory_changes = None
st.session_state.sim_last_national_delta = None
st.success("Simulación inicializada.")
st.rerun()
return
st.success("Simulación activa.")
if st.session_state.sim_finished:
st.info("La simulación terminó. Puedes cambiar configuración para reiniciar una nueva partida.")
render_game_state(
selected_parties_df=selected_parties_df,
state=st.session_state.sim_state,
geo=geo,
base=config["base"],
)
st.divider()
render_control_panel(
state=st.session_state.sim_state,
parties_df=selected_parties_df,
selected_party_ids=list(selected_parties_df["party_id"]),
total_rounds=config["rounds"],
)
st.info(
"La siguiente iteración buena ya es NPC reactivo, tablero territorial clickeable y resolución visual de antes y después por ronda."
)
def run_app():
st.title("Pulso Electoral SV")
st.caption(
f"Simulador-juego político-electoral en desarrollo. Versión {APP_VERSION}. "
f"Esta versión corresponde a una base jugable experimental y no representa una proyección oficial."
)
tab_game, tab_about, tab_roadmap, tab_versions = st.tabs(
[
"Simulador",
"Acerca del juego",
"Hoja de ruta",
"Versiones",
]
)
with tab_game:
run_game_tab()
with tab_about:
render_about_tab()
with tab_roadmap:
render_roadmap_tab()
with tab_versions:
render_versions_tab()