Save File API

This document describes the public shape of a Pound for Pound save file. It is intended for tools that inspect save data and for players who want to understand what is stored in a career.

Save editing is unsupported. Back up the original file and close the game before inspecting or changing a save. The schema can change between game versions, and an invalid or inconsistent value may prevent a save from loading.

Compatibility

This page describes save format version 63. It will be updated as the public save shape changes. Tools should preserve properties they do not recognize and should never change version to bypass migration.

File Location

The game stores saves in Godot's user data directory under Pound for Pound/saves.

The primary file for a slot is <slot>.sav. The game may also create numbered backup files beside it. Operating-system settings and portable installations can change the exact base directory.

File Encoding

Current .sav files contain Brotli-compressed UTF-8 JSON. The data is not encrypted and has no checksum or signature. Older saves may use gzip compression.

Unknown properties are generally ignored by the game. Unknown enum values, missing references, and invalid nested objects may not be recoverable, so consumers should treat the document as a shape reference rather than a validation guarantee.

Top-Level Shape

interface SaveFile {
  version: number;
  savedAt: string;
  summary: SaveSlotSummary;
  gameState: GameState;
}

interface SaveSlotSummary {
  promotionName: string;
  week: number;
  year: number;
  nextEventName?: string;
  nextEventDate?: string;
}

The summary is display metadata. Career data lives under gameState.

SaveSlotSummary

GameState

interface GameState {
  currentDate: GameDate;
  promotions: Promotion[];
  allFighters: Fighter[];
  gyms: Gym[];
  coaches: Coach[];
  fightCamps: FightCamp[];
  contracts: Record<string, Contract>;
  freeAgentIds: string[];
  scheduledEvents: Event[];
  eventHistory: Event[];
  hallOfFame: HallOfFameInductee[];
  news: NewsRepository;
  narratives: NarrativeRepository;
  tokenLedger: TokenLedger;
  wireFeed: WireFeed;
  imagePackId: string;
  womensDivisionsEnabled: boolean;
  tutorialsEnabled: boolean;
  enabledWeightClassIds: string[];
}

GameState contains additional state used by current game systems. The properties below are the main entry points for tools reading a career.

GameDate

interface GameDate {
  week: number;
  year: number;
  totalWeeks: number;
}

Fighter

interface Fighter {
  id: string;
  firstName: string;
  lastName: string;
  nickname?: string;
  nationality: string;
  dateOfBirth: string;
  gender: string;
  stats: FighterStats;
  record: FighterRecord;
  status: string;
  currentPromotionId?: string;
  currentContractId?: string;
  currentWeightClass?: WeightClass;
  imagePath?: string;
}

FighterStats

All stored fighter stats are numbers. Current saves include the following properties:

interface FighterStats {
  punching: number;
  kicking: number;
  kneeElbow: number;
  clinchStriking: number;
  wrestling: number;
  takedownDefense: number;
  clinchControl: number;
  topControl: number;
  bottomGame: number;
  submissions: number;
  submissionDefense: number;
  wrestlingIntent: number;
  speed: number;
  strength: number;
  cardio: number;
  durability: number;
  recovery: number;
  heart: number;
  composure: number;
  killerInstinct: number;
  fightIQ: number;
  ceiling: number;
  growthRate: number;
}

FighterRecord

interface FighterRecord {
  wins: number;
  losses: number;
  draws: number;
  noContests: number;
  koWins: number;
  submissionWins: number;
  decisionWins: number;
  koLosses: number;
  submissionLosses: number;
  decisionLosses: number;
  fightHistory: FightHistoryEntry[];
}

Record totals and fightHistory are both stored in the save.

Promotion

interface Promotion {
  id: string;
  name: string;
  abbreviation: string;
  isPlayerControlled: boolean;
  prestige: number;
  tokens: number;
  roster: string[];
  titles: Title[];
  supportedWeightClasses: WeightClass[];
  ownedUnlocks: string[];
  completedMilestones: string[];
  tvDeal?: TvDeal;
  sponsorContracts: SponsorContract[];
}

Contract

Contracts are stored in gameState.contracts, keyed by fighter ID.

interface Contract {
  id: string;
  fighterId: string;
  promotionId: string;
  fightsRemaining: number;
  totalFights: number;
  startDate: string;
  endDate?: string;
  exclusive: boolean;
  status: string;
  signingCost: number;
  signedWeek: number;
  signedYear: number;
}

Event

Upcoming events are stored in scheduledEvents; completed events are stored in eventHistory.

interface Event {
  id: string;
  promotionId: string;
  name: string;
  date: string;
  status: string;
  venueId?: string;
  cityId?: string;
  card: Bout[];
  sponsorSelections: EventSponsorSelection[];
}

Bout

interface Bout {
  id: string;
  eventId: string;
  fighter1Id: string;
  fighter2Id: string;
  weightClass: WeightClass;
  scheduledRounds: number;
  isTitleFight: boolean;
  titleId?: string;
  status: string;
  result?: FightResult;
}

FightResult

interface FightResult {
  winnerId?: string;
  loserId?: string;
  method: string;
  endingRound: number;
  endingTime: string;
  submissionType?: string;
  stats?: FightStats;
  scorecards?: ScorePair[];
}

interface ScorePair {
  f1: number;
  f2: number;
}

WeightClass

interface WeightClass {
  id: string;
  name: string;
  minWeight: number;
  maxWeight: number;
  gender: string;
  isActive: boolean;
}

Entity References

Large entities are stored once and connected by GUID. Consumers should preserve those references and unknown properties when reading and writing data.

Changing or removing an ID without updating its references can make the save inconsistent.