foothold-sitac 0.1.0__py3-none-any.whl

foothold_sitac/config.py

@@ -0,0 +1,67 @@
+import os
+from typing import Annotated, Any
+from functools import cache
+import yaml
+from pydantic import BaseModel, Field
+
+
+class WebConfig(BaseModel):
+    host: str = "0.0.0.0"
+    port: int = 8080
+    title: str = "Foothold Sitac Server"
+    reload: bool = False
+    refresh_interval: int = 60
+
+
+class DcsConfig(BaseModel):
+    saved_games: str = "var"  # "DCS Saved Games Path"
+
+
+class TileLayerConfig(BaseModel):
+    name: str
+    url: str
+
+
+class MapConfig(BaseModel):
+    url_tiles: str = "https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}"
+    alternative_tiles: Annotated[list[TileLayerConfig], Field(default_factory=list)]
+
+    min_zoom: int = 8
+    max_zoom: int = 11
+
+
+class AppConfig(BaseModel):
+    web: Annotated[WebConfig, Field(default_factory=WebConfig)]
+    dcs: Annotated[DcsConfig, Field(default_factory=DcsConfig)]
+    map: Annotated[MapConfig, Field(default_factory=MapConfig)]
+
+
+def _expand_env_vars(value: Any) -> Any:
+    """Recursively expand environment vars like "${VAR}" or "$VAR"."""
+    if isinstance(value, str):
+        return os.path.expandvars(value)
+    if isinstance(value, dict):
+        return {k: _expand_env_vars(v) for k, v in value.items()}
+    if isinstance(value, list):
+        return [_expand_env_vars(v) for v in value]
+    return value
+
+
+def load_config_str(raw_config: dict[Any, Any]) -> AppConfig:
+    expanded = _expand_env_vars(raw_config)
+    return AppConfig.model_validate(expanded)
+
+
+def load_config(path: str) -> AppConfig:
+    with open(path, "r") as f:
+        raw_config = yaml.safe_load(f)
+
+    return load_config_str(raw_config)
+
+
+@cache
+def get_config() -> AppConfig:
+    config_path = "config/config.yml"
+    if not os.path.exists(config_path):
+        return AppConfig(web=WebConfig(), dcs=DcsConfig(), map=MapConfig(alternative_tiles=[]))
+    return load_config(config_path)

foothold_sitac/dependencies.py

@@ -0,0 +1,38 @@
+from fastapi import HTTPException, status
+from foothold_sitac.foothold import (
+    Sitac,
+    detect_foothold_mission_path,
+    get_server_path_by_name,
+    load_sitac,
+)
+
+
+def get_sitac_or_none(server: str) -> Sitac | None:
+    """Load sitac for a server, return None if not available"""
+    server_path = get_server_path_by_name(server)
+
+    if not server_path.is_dir():
+        return None
+
+    mission_path = detect_foothold_mission_path(server)
+
+    if not mission_path:
+        return None
+
+    return load_sitac(mission_path)
+
+
+def get_active_sitac(server: str) -> Sitac:
+    """Dependency injection of sitac by server name"""
+
+    server_path = get_server_path_by_name(server)
+
+    if not server_path.is_dir():
+        raise HTTPException(status.HTTP_404_NOT_FOUND, f"server {server} not found")
+
+    mission_path = detect_foothold_mission_path(server)
+
+    if not mission_path:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, f"mission not found for server {server}")
+
+    return load_sitac(mission_path)

foothold_sitac/foothold.py

@@ -0,0 +1,254 @@
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from lupa import LuaRuntime  # type: ignore[import-untyped]
+from pydantic import BaseModel, Field, field_validator
+
+from foothold_sitac.config import get_config
+
+
+class ConfigError(Exception): ...
+
+
+class Position(BaseModel):
+    latitude: float
+    longitude: float
+    altitude: int | None = None  # not used anymore
+
+
+class Zone(BaseModel):
+    upgrades_used: int = Field(alias="upgradesUsed")
+    side: int
+    active: bool
+    destroyed: dict[int, str] | list[str] | dict[Any, Any]
+    extra_upgrade: dict[Any, Any] = Field(alias="extraUpgrade")
+    remaining_units: dict[int, dict[int, str]] | dict[Any, Any] = Field(alias="remainingUnits")
+    first_capture_by_red: bool = Field(alias="firstCaptureByRed")
+    level: int
+    wasBlue: bool
+    triggers: dict[str, int]
+    position: Position = Field(alias="lat_long")
+    hidden: bool = False
+    flavor_text: str | None = Field(alias="flavorText", default=None)
+
+    @property
+    def side_color(self) -> str:
+        if not self.active:
+            return "darkgray"
+        if self.side == 1:
+            return "red"
+        elif self.side == 2:
+            return "blue"
+        return "lightgray"
+
+    @property
+    def side_str(self) -> str:
+        if not self.active:
+            return "disabled"
+        if self.side == 1:
+            return "red"
+        elif self.side == 2:
+            return "blue"
+        return "neutral"
+
+    @property
+    def total_units(self) -> int:
+        return sum([len(group_units) for group_units in self.remaining_units.values()])
+
+
+class Mission(BaseModel):
+    is_escort_mission: bool = Field(alias="isEscortMission")
+    description: str
+    title: str
+    is_running: bool = Field(alias="isRunning")
+
+
+class Connection(BaseModel):
+    from_zone: str = Field(alias="from")
+    to_zone: str = Field(alias="to")
+
+
+class Player(BaseModel):
+    coalition: str
+    unit_type: str = Field(alias="unitType")
+    player_name: str = Field(alias="playerName")
+    latitude: float
+    longitude: float
+    altitude: float | None = None
+
+    @property
+    def side_color(self) -> str:
+        if self.coalition == "red":
+            return "red"
+        elif self.coalition == "blue":
+            return "blue"
+        return "gray"
+
+
+class EjectedPilot(BaseModel):
+    player_name: str = Field(alias="playerName")
+    latitude: float
+    longitude: float
+    altitude: float = 0
+    lost_credits: float = Field(alias="lostCredits", default=0)
+
+
+class PlayerStats(BaseModel):
+    air: int = Field(alias="Air", default=0)
+    SAM: int = Field(alias="SAM", default=0)
+    points: float = Field(alias="Points", default=0)
+    deaths: int = Field(alias="Deaths", default=0)
+    zone_capture: int = Field(alias="Zone capture", default=0)
+    zone_upgrade: int = Field(alias="Zone upgrade", default=0)
+    CAS_mission: int = Field(alias="CAS mission", default=0)
+    points_spent: int = Field(alias="Points spent", default=0)
+    infantry: int = Field(alias="Infantry", default=0)
+    ground_units: int = Field(alias="Ground Units", default=0)
+    helo: int = Field(alias="Helo", default=0)
+
+
+class Sitac(BaseModel):
+    updated_at: datetime
+    zones: dict[str, Zone]
+    player_stats: dict[str, PlayerStats] = Field(alias="playerStats")
+    missions: list[Mission] = Field(default_factory=list)
+    connections: list[Connection] = Field(default_factory=list)
+    players: list[Player] = Field(default_factory=list)
+    ejected_pilots: list[EjectedPilot] = Field(alias="ejectedPilots", default_factory=list)
+
+    @field_validator("missions", "connections", "players", "ejected_pilots", mode="before")
+    @classmethod
+    def convert_lua_table_to_list(cls, v: Any) -> list[Any]:
+        """Convert Lua table (dict with numeric keys) to list."""
+        if v is None:
+            return []
+        if isinstance(v, dict):
+            return list(v.values())
+        return list(v) if not isinstance(v, list) else v
+
+    @property
+    def campaign_progress(self) -> float:
+        """Return the campaign progress percentage (0-100).
+
+        Progress is calculated as:
+        (visible_zones - red_zones) / visible_zones * 100
+
+        Hidden zones (hidden=True) and inactive zones (active=False) are
+        excluded.
+        """
+        visible_zones = [z for z in self.zones.values() if not z.hidden and z.active]
+        if not visible_zones:
+            return 0.0
+        red_zones = sum(1 for z in visible_zones if z.side == 1)
+        return (len(visible_zones) - red_zones) / len(visible_zones) * 100
+
+
+def lua_to_dict(lua_table: Any) -> dict[Any, Any] | None:
+    if lua_table is None:
+        return None
+    result: dict[Any, Any] = {}
+    for k, v in lua_table.items():
+        if hasattr(v, "items"):
+            v = lua_to_dict(v)
+        result[k] = v
+    return result
+
+
+def load_sitac(file: Path) -> Sitac:
+    lua = LuaRuntime(unpack_returned_tuples=True)
+
+    with open(file.absolute(), "r", encoding="utf-8") as f:
+        lua_code = f.read()
+
+    lua.execute(lua_code)
+
+    zone_persistance = lua.globals().zonePersistance
+    zone_persistance_dict = lua_to_dict(zone_persistance)
+
+    # Merge zonesDetails into zones (new format support)
+    # In new format, flavorText is stored in zonesDetails instead of directly in zones
+    zones_details = zone_persistance_dict.get("zonesDetails", {})  # type: ignore[union-attr]
+    if zones_details and "zones" in zone_persistance_dict:  # type: ignore[operator]
+        for zone_name, details in zones_details.items():
+            if zone_name in zone_persistance_dict["zones"]:  # type: ignore[index]
+                zone_persistance_dict["zones"][zone_name].update(details)  # type: ignore[index]
+
+    return Sitac(
+        **zone_persistance_dict,  # type: ignore[arg-type]
+        updated_at=datetime.fromtimestamp(file.stat().st_mtime),
+    )
+
+
+def detect_foothold_mission_path(server_name: str) -> Path | None:
+    file_status = get_foothold_server_status_path(server_name)
+
+    if not file_status.is_file():
+        return None
+
+    with open(file_status) as f:
+        mission_file_path = Path(f.readline().strip())
+
+    print(mission_file_path)
+    return mission_file_path
+
+
+def get_server_path_by_name(server_name: str) -> Path:
+    return Path(get_config().dcs.saved_games) / server_name
+
+
+def get_foothold_server_saves_path(server_name: str) -> Path:
+    return get_server_path_by_name(server_name) / "Missions" / "Saves"
+
+
+def get_foothold_server_status_path(server_name: str) -> Path:
+    return get_foothold_server_saves_path(server_name) / "foothold.status"
+
+
+def is_foothold_path(server_name: str) -> bool:
+    """Check if server_name (directory in DCS Saved Games) is a Foothold server path"""
+
+    path = get_foothold_server_status_path(server_name)
+
+    return path.is_file()
+
+
+def list_servers() -> list[str]:
+    base_path = Path(get_config().dcs.saved_games)
+
+    if not base_path.is_dir():
+        raise ConfigError(f"config:dcs.saved_games '{get_config().dcs.saved_games}' is not a valid dir")
+
+    return sorted(
+        [file.name for file in base_path.iterdir() if not file.name.startswith(".") and is_foothold_path(file.name)]
+    )
+
+
+def get_sitac_range(sitac: Sitac) -> tuple[Position, Position]:
+    if not sitac.zones:
+        raise ValueError("sitac without zones")
+    first_zone = sitac.zones[next(iter(sitac.zones))]
+
+    min_lat, max_lat = first_zone.position.latitude, first_zone.position.latitude
+    min_long, max_long = first_zone.position.longitude, first_zone.position.longitude
+
+    for zone in sitac.zones.values():
+        min_lat, max_lat = (
+            min(min_lat, zone.position.latitude),
+            max(max_lat, zone.position.latitude),
+        )
+        min_long, max_long = (
+            min(min_long, zone.position.longitude),
+            max(max_long, zone.position.longitude),
+        )
+
+    return Position(latitude=min_lat, longitude=min_long), Position(latitude=max_lat, longitude=max_long)
+
+
+def get_sitac_center(sitac: Sitac) -> Position:
+    min_pos, max_pos = get_sitac_range(sitac)
+
+    return Position(
+        latitude=(max_pos.latitude + min_pos.latitude) / 2,
+        longitude=(max_pos.longitude + min_pos.longitude) / 2,
+    )

foothold_sitac/foothold_api_router.py

@@ -0,0 +1,106 @@
+from datetime import datetime
+from typing import Annotated, Any
+from fastapi import APIRouter, Depends
+from foothold_sitac.dependencies import get_active_sitac
+from foothold_sitac.foothold import Sitac, list_servers
+from foothold_sitac.schemas import MapConnection, MapData, MapEjectedPilot, MapPlayer, MapZone, Server
+
+router = APIRouter()
+
+
+@router.get("", response_model=list[Server], description="List foothold servers")
+async def foothold_list_servers() -> Any:
+    return [Server.model_validate({"name": server}) for server in list_servers()]
+
+
+@router.get("/{server}/sitac", response_model=Sitac)
+async def foothold_get_sitac(sitac: Annotated[Sitac, Depends(get_active_sitac)]) -> Any:
+    return sitac
+
+
+@router.get("/{server}/map.json", response_model=MapData)
+async def foothold_get_map_data(
+    sitac: Annotated[Sitac, Depends(get_active_sitac)],
+) -> Any:
+    zones = [
+        MapZone.model_validate(
+            {
+                "name": zone_name,
+                "lat": zone.position.latitude,
+                "lon": zone.position.longitude,
+                "side": zone.side_str,
+                "color": zone.side_color,
+                "units": zone.total_units,
+                "level": zone.level,
+                "flavor_text": zone.flavor_text,
+            }
+        )
+        for zone_name, zone in sitac.zones.items()
+        if zone.position and not zone.hidden
+    ]
+
+    # Build connections with resolved coordinates
+    connections = []
+    for conn in sitac.connections:
+        from_zone = sitac.zones.get(conn.from_zone)
+        to_zone = sitac.zones.get(conn.to_zone)
+        # Only include connection if both zones exist, have positions, and are not hidden
+        if (
+            from_zone
+            and to_zone
+            and from_zone.position
+            and to_zone.position
+            and not from_zone.hidden
+            and not to_zone.hidden
+        ):
+            connections.append(
+                MapConnection(
+                    from_zone=conn.from_zone,
+                    to_zone=conn.to_zone,
+                    from_lat=from_zone.position.latitude,
+                    from_lon=from_zone.position.longitude,
+                    to_lat=to_zone.position.latitude,
+                    to_lon=to_zone.position.longitude,
+                    color=from_zone.side_color,
+                )
+            )
+
+    age_seconds = (datetime.now() - sitac.updated_at).total_seconds()
+
+    # Build players list
+    players = [
+        MapPlayer(
+            player_name=player.player_name,
+            lat=player.latitude,
+            lon=player.longitude,
+            coalition=player.coalition,
+            unit_type=player.unit_type,
+            color=player.side_color,
+        )
+        for player in sitac.players
+    ]
+
+    # Build ejected pilots list (exclude "Unknown" pilots)
+    ejected_pilots = [
+        MapEjectedPilot(
+            player_name=pilot.player_name,
+            lat=pilot.latitude,
+            lon=pilot.longitude,
+            altitude=pilot.altitude,
+            lost_credits=pilot.lost_credits,
+        )
+        for pilot in sitac.ejected_pilots
+        # if pilot.player_name != "Unknown" # don't hide Unknown pilots, real pilots have this name
+    ]
+
+    return MapData(
+        updated_at=sitac.updated_at,
+        age_seconds=age_seconds,
+        zones=zones,
+        connections=connections,
+        players=players,
+        ejected_pilots=ejected_pilots,
+        progress=sitac.campaign_progress,
+        missions_count=len(sitac.missions),
+        ejected_pilots_count=len(ejected_pilots),
+    )

foothold_sitac/foothold_router.py

@@ -0,0 +1,91 @@
+from datetime import datetime
+from typing import Annotated
+from fastapi import APIRouter, Depends, Request
+from fastapi.responses import HTMLResponse
+from pydantic import BaseModel
+from foothold_sitac.foothold import Sitac, get_sitac_center, list_servers
+from foothold_sitac.templater import env
+from foothold_sitac.dependencies import get_active_sitac, get_sitac_or_none
+
+router = APIRouter()
+
+
+class ServerInfo(BaseModel):
+    name: str
+    updated_at: datetime | None
+
+
+@router.get("", response_class=HTMLResponse)
+async def foothold_servers(request: Request) -> str:
+    servers_data: list[ServerInfo] = []
+    for server_name in list_servers():
+        sitac = get_sitac_or_none(server_name)
+        servers_data.append(
+            ServerInfo(
+                name=server_name,
+                updated_at=sitac.updated_at if sitac else None,
+            )
+        )
+
+    template = env.get_template("foothold/servers.html")
+    return template.render(
+        {
+            "request": request,
+            "servers": servers_data,
+            "now": datetime.now(),
+        }
+    )
+
+
+@router.get("/sitac/{server}", response_class=HTMLResponse)
+async def foothold_sitac(request: Request, sitac: Annotated[Sitac, Depends(get_active_sitac)]) -> str:
+    template = env.get_template("foothold/sitac.html")
+    return template.render(
+        {
+            "request": request,
+            "sitac": sitac,
+        }
+    )
+
+
+@router.get("/map/{server}", response_class=HTMLResponse)
+async def foothold_map(request: Request, server: str, sitac: Annotated[Sitac, Depends(get_active_sitac)]) -> str:
+    template = env.get_template("foothold/map.html")
+    map_center = get_sitac_center(sitac)
+
+    return template.render(
+        {
+            "request": request,
+            "sitac": sitac,
+            "server": server,
+            "center": [map_center.latitude, map_center.longitude],
+            "progress": sitac.campaign_progress,
+        }
+    )
+
+
+@router.get("/map/{server}/players", response_class=HTMLResponse)
+async def foothold_players_modal(sitac: Annotated[Sitac, Depends(get_active_sitac)]) -> str:
+    template = env.get_template("foothold/partials/players.html")
+    return template.render({"sitac": sitac})
+
+
+@router.get("/map/{server}/zones", response_class=HTMLResponse)
+async def foothold_zones_modal(sitac: Annotated[Sitac, Depends(get_active_sitac)]) -> str:
+    template = env.get_template("foothold/partials/zones.html")
+    return template.render({"sitac": sitac, "progress": sitac.campaign_progress})
+
+
+@router.get("/map/{server}/missions", response_class=HTMLResponse)
+async def foothold_missions_modal(sitac: Annotated[Sitac, Depends(get_active_sitac)]) -> str:
+    template = env.get_template("foothold/partials/missions.html")
+    return template.render({"missions": sitac.missions})
+
+
+@router.get("/map/{server}/ejected", response_class=HTMLResponse)
+async def foothold_ejected_modal(sitac: Annotated[Sitac, Depends(get_active_sitac)]) -> str:
+    template = env.get_template("foothold/partials/ejected.html")
+    # Filter out "Unknown" pilots
+    # ejected_pilots = [p for p in sitac.ejected_pilots if p.player_name != "Unknown"]
+    # return template.render({"ejected_pilots": ejected_pilots})
+    return template.render({"ejected_pilots": sitac.ejected_pilots})

foothold_sitac/main.py

@@ -0,0 +1,31 @@
+from importlib.resources import files
+
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse, RedirectResponse
+from fastapi.staticfiles import StaticFiles
+
+from foothold_sitac.config import get_config
+from foothold_sitac.foothold_api_router import router as foothold_api_router
+from foothold_sitac.foothold_router import router as foothold_router
+from foothold_sitac.templater import env
+
+config = get_config()
+
+static_path = files("foothold_sitac") / "static"
+app = FastAPI(title=config.web.title, version="0.1.0", description="Foothold Web Sitac")
+app.mount("/static", StaticFiles(directory=str(static_path)), name="static")
+
+
+@app.get("/", response_class=HTMLResponse, include_in_schema=False)
+async def home(request: Request) -> str:
+    template = env.get_template("home.html")
+    return template.render(request=request)
+
+
+@app.get("/favicon.ico", include_in_schema=False)
+async def favicon() -> RedirectResponse:
+    return RedirectResponse(url="/static/favicon.ico")
+
+
+app.include_router(foothold_router, prefix="/foothold", include_in_schema=False)
+app.include_router(foothold_api_router, prefix="/api/foothold", tags=["foothold"])

foothold_sitac/schemas.py

@@ -0,0 +1,56 @@
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+
+class Server(BaseModel):
+    name: str
+
+
+class MapZone(BaseModel):
+    name: str
+    lat: float
+    lon: float
+    side: str
+    color: str
+    units: int
+    level: int
+    flavor_text: str | None = None
+
+
+class MapConnection(BaseModel):
+    from_zone: str
+    to_zone: str
+    from_lat: float
+    from_lon: float
+    to_lat: float
+    to_lon: float
+    color: str
+
+
+class MapPlayer(BaseModel):
+    player_name: str
+    lat: float
+    lon: float
+    coalition: str
+    unit_type: str
+    color: str
+
+
+class MapEjectedPilot(BaseModel):
+    player_name: str
+    lat: float
+    lon: float
+    altitude: float
+    lost_credits: float
+
+
+class MapData(BaseModel):
+    updated_at: datetime
+    age_seconds: float
+    zones: list[MapZone]
+    connections: list[MapConnection]
+    players: list[MapPlayer] = Field(default_factory=list)
+    ejected_pilots: list[MapEjectedPilot] = Field(default_factory=list)
+    progress: float
+    missions_count: int
+    ejected_pilots_count: int = 0