lib

type AI struct {
	// contains filtered or unexported fields
}

type Cities []City

type City struct {
	// Owner signifies which player is owner of the given city. It may be either 0 or 1.
	Owner int
	// VictoryPoints tells how much points players gain by taking control of the city.
	VictoryPoints int
	// XY are coordinates of the city on the map.
	XY UnitCoords
	// Iff nth bit of the VariantBitmap is 0, the city should be used in nth variant
	// of the scenario.
	VariantBitmap byte
	// Name of the city
	Name string
}

type ColorSchemes struct {
	// contains filtered or unexported fields
}

type Commander struct {
	// contains filtered or unexported fields
}

type CommanderFlags struct {
	PlayerControlled      [2]bool
	PlayerCanSeeUnits     [2]bool
	PlayerHasIntelligence [2]bool
}

type DailyUpdate struct {
	DaysRemaining int
	SupplyLevels  [2]int
}

type Data struct {
	Data0Low    [16]int  // Data[0:16] per unit type (lower 4 bits)
	Data0High   [16]int  // Data[0:16] per unit type (higher 4 bits)
	Data16Low   [16]int  // Data[16:32] per unit type (lower 4 bits)
	Data16High  [16]int  // Data[16:32] per unit type (higher 4 bits)
	Data32      [16]int  // Data[32:48] per unit type
	Data32_8    [16]bool // Data32 & 8
	Data32_32   [16]bool // Data32 & 32
	Data32_64   [16]bool // Data32 & 64
	Data32_128  [16]bool // Data32 & 128
	AttackRange [16]int  // Data32 & 31 (attack range)
	// Score gained by destroying enemy unit of this type
	// Units with score >= 4 are high importance units which are priority targets.
	UnitScores   [16]int // Data[48:64]
	RecoveryRate [16]int // Data[64:80]
	// Various bits concerning unit types... not all clear yet
	UnitMask             [16]byte // Data[80:96] (per unit type)
	UnitMask0            [16]bool // bit 0
	UnitMask1            [16]bool // bit 1
	UnitMask2            [16]bool // bit 2
	UnitUsesSupplies     [16]bool // !bit 3(&8) of bytes Data[80:96]
	UnitMask4            [16]bool // bit4 (weather has no impact?)
	UnitMask5            [16]bool // bit5
	UnitCanMove          [16]bool // !bit 6(&64) of bytes Data[80:96]
	UnitMask7            [16]bool // bit7
	TerrainMenAttack     [8]int   // Data[96:104]
	TerrainTankAttack    [8]int   // Data[104:112]
	TerrainMenDefence    [8]int   // Data[112:120]
	TerrainTankDefence   [8]int   // Data[120:128]
	FormationMenAttack   [8]int   // Data[128:136]
	FormationTankAttack  [8]int   // Data[136:144]
	FormationMenDefence  [8]int   // Data[144:152]
	FormationTankDefence [8]int   // Data[152:160]
	// Units with type >=MinSupplyType can provide supply to other units.
	// Such units can receive supplies only from units with larger type numbers.
	MinSupplyType          int // Data[160]
	HexSizeInMiles         int // Data[161]
	Data162                int // Data[162] some generic supply use (while attacking?)
	Data163                int // Data[163] some generic supply use (while being attacked?)
	MaxResupplyAmount      int // Data[164]
	MaxSupplyTransportCost int // Data[165] in half-miles
	// On average that many supplies will be used by each unit every day.
	AvgDailySupplyUse              int        // Data[166]
	Data167                        int        // Data[167]
	MinutesPerTick                 int        // Data[168]
	UnitUpdatesPerTimeIncrement    int        // Data[169]
	MenMultiplier                  int        // Data[170] (one man stored in unit data correspond to that many actual men)
	TanksMultiplier                int        // Data[171] (same as above but for tanks)
	Data173                        int        // Data[173] (a fatigue increase)
	Data174                        int        // Data[174]
	Data175                        int        // Data[175]
	Data176                        [4][4]int  // Data[176:190] four bytes per order (numbers 0-5)
	Data192                        [8]int     // Data[192:200] move cost per formation
	Data200Low                     [16]int    // Data[200:216] lower three bits per type
	UnitResupplyPerType            [16]int    // Data[200:216] top four bits div 2
	FormationChangeSpeed           [2][8]int  // Data[216:232]
	ResupplyRate                   [2]int     // Data[232,233]
	MenReplacementRate             [2]int     // Data[234,235]
	TankReplacementRate            [2]int     // Data[236,237]
	SideColor                      [2]int     // Data[248,249] the value*16 is the hue corresponding to the given side
	Data252                        [2]int     // Data[252:254] per side
	MoveSpeedPerTerrainTypeAndUnit [8][16]int // Data[255:383]
	// Every chunk of four bytes list possible weather for a year's quarter.
	PossibleWeather [16]byte       // Data[384:400]
	DaytimePalette  [8]byte        // Data[400:408]
	NightPalette    [8]byte        // Data[408:416]
	MenCountLimit   [16]int        // Data[416:432]
	TankCountLimit  [16]int        // Data[432:448]
	DataUpdates     [21]DataUpdate // Data[448:511]
	UnitTypes       []string
	Strings1        []string
	Formations      []string
	Experience      []string
	Strings4        []string
	Equipments      []string
	UnitNames       [2][]string
	Strings7        []string
	Strings9        []string
	Months          []string
	Sides           []string
	Weather         []string
	Colors          []string
}

type DataUpdate struct {
	Day    int
	Offset int
	Value  byte
}

type FlashbackHistory []FlashbackUnits

type FlashbackUnit struct {
	XY           UnitCoords
	ColorPalette int
	Type         int
}

type FlashbackUnits []FlashbackUnit

type Font struct {
	// contains filtered or unexported fields
}

type Game int

type GameData struct {
	Game           Game
	Scenarios      []Scenario
	Sprites        *Sprites
	Icons          *Icons
	Map            *Map
	Generic        *Generic
	TerrainTypeMap *TerrainTypeMap
	Hexes          *Hexes
}

type GameOver struct{ Results string }

type GameState struct {
	// contains filtered or unexported fields
}

type General struct {
	// A bitmap of various flags of the general
	Data0    byte
	Data0_26 int // from bits 2 and 6
	Data0_15 int // from bits 1 and 5
	Data0_37 int // from bits 3 and 7
	Data0_04 int // from bits 0 and 4
	// Attack bonus for the units commanded by the general from 0 to 15
	Attack    int
	Data1High int
	// Defence bonus for the units commanded by the general from 0 to 15
	Defence   int
	Data2High int
	// Movement bonus for the units commanded by the general from 0 to 15
	Movement int
	Name     string
}

type Generals [2][]General

type Generic struct {
	// Terrain colors on the overview map.
	Data60 [4]int
	// Types of terrain 0-7 (0 is road, 7 is an impassable terrain, other vary from game to game).
	TerrainTypes []int
}

type Hexes struct {
	Arr0   [6][8]int // Data[0:48]
	Arr48  [6][8]int // Data[48:96]
	Arr96  [6][8]int // Data[96:144]
	Arr144 [6][8]int // Data[144:192]
}

type IconType int

type Icons struct {
	Sprites [24]*image.Paletted
}

type Initialized struct{}

type Intelligence struct {
	// contains filtered or unexported fields
}

type Map struct {
	Width, Height int
	// contains filtered or unexported fields
}

type MapCoords struct {
	X, Y int
}

type MessageFromUnit interface {
	Unit() Unit     // Unit that's sending the message
	Icon() IconType // Icon to be displyed on the map when the message is shown
	String() string // Text of message to show
}

type MessageSync struct {
	// contains filtered or unexported fields
}

type Options struct {
	AlliedCommander Commander // [0..1]
	GermanCommander Commander // [0..1]
	Intelligence    Intelligence
	UnitDisplay     UnitDisplay // [0..1]
	GameBalance     int         // [0..4]
	Speed           Speed       // [1..3]
}

type OrderType int

type Reinforcements struct{ Sides [2]bool }

type Scenario struct {
	Name                   string
	FilePrefix             string
	StartMinute            int
	StartHour              int
	StartDay               int
	StartMonth             int
	StartYear              int
	StartWeather           int
	StartSupplyLevels      [2]int
	MinX, MaxX, MinY, MaxY int
}

type ScenarioData struct {
	Variants []Variant
	Generals *Generals
	Terrain  *Terrain
	Data     *Data
	Units    *Units
}

type Score struct {
	MenLost                   [2]int // 29927 + side*2
	TanksLost                 [2]int // 29927 + 4 + side*2
	CitiesHeld                [2]int // 29927 + 13 + side*2
	CriticalLocationsCaptured [2]int // 29927 + 21 + side*2
	// contains filtered or unexported fields
}

type SignedNumber interface {
	constraints.Signed | constraints.Float
}

type Speed int

type Sprites struct {
	GameFont          *Font
	IntroFont         *Font
	IntroSprites      []*image.Paletted
	TerrainTiles      [48]*image.Paletted
	UnitSymbolSprites [16]*image.Paletted
	UnitIconSprites   [16]*image.Paletted
}

type SupplyDistributionEnd struct{}

type SupplyDistributionStart struct{}

type SupplyTruckMove struct {
	XY0, XY1 MapCoords
}

type Terrain struct {
	// Cities contains list of all the cities included in the scenario.
	Cities Cities
	// Coefficients for 4x4-tile squares on the map (a 16x16 map of coefficients).
	// n-th (0-based) coefficient, if a coefficient for square with top left corner:
	// (4*(n%16), 4*n/16).
	Coeffs [16][16]int // Bytes [768-1024]
}

type TerrainTypeMap struct {
	// contains filtered or unexported fields
}

type TimeChanged struct{}

type Unit struct {
	Side                int  // 0 or 1
	InContactWithEnemy  bool // &1 != 0
	IsUnderAttack       bool // &2 != 0
	State2              bool // &4 != 0
	HasSupplyLine       bool // &8 == 0
	State4              bool // &16 != 0, is neighbouring enemy
	HasLocalCommand     bool // &32 != 0
	SeenByEnemy         bool // &64 != 0
	IsInGame            bool // &128 != 0
	XY                  UnitCoords
	MenCount, TankCount int
	// Formation of the unit, a number from 0 to 7.
	// Names of formations are read from {scenario}.DTA file into Data.Formations.
	Formation       int
	SupplyUnit      int // Index of this unit's supply unit
	LongRangeAttack bool
	Type            int
	TypeName        string
	ColorPalette    int
	NameIndex       int
	Name            string
	// Formation the unit wants to have. It will gradually change the formation
	// from Formation to TargetFormation with speed defined by Data.FormationChangeSpeed.
	TargetFormation int
	OrderBit4       bool
	Order           OrderType

	// Commanding general of the unit.
	General     General
	SupplyLevel int
	Morale      int

	// Iff nth bit of the VariantBitmap is 0, the unit should be used in nth variant
	// of the scenario.
	VariantBitmap        byte
	HalfDaysUntilAppear  int
	InvAppearProbability int

	Fatigue   int // Value from 0 to 255
	Objective UnitCoords

	Index int
	// contains filtered or unexported fields
}

type UnitAttack struct {
	XY      UnitCoords
	Outcome int
}

type UnitCoords struct {
	X, Y int
}

type UnitDisplay int

type UnitMove struct {
	Unit     Unit
	XY0, XY1 MapCoords
}

type Units [2][]Unit

type Variant struct {
	Name              string
	LengthInDays      int
	CriticalLocations [2]int // per side. Number of critical locations that need to be captured by a side to win.
	Data3             int
	CitiesHeld        [2]int
}

type WeAreAttacking struct {
	// contains filtered or unexported fields
}

type WeAreInContactWithEnemy struct {
	// contains filtered or unexported fields
}

type WeAreRetreating struct {
	// contains filtered or unexported fields
}

type WeAreUnderFire struct {
	// contains filtered or unexported fields
}

type WeHaveBeenOverrun struct {
	// contains filtered or unexported fields
}

type WeHaveCaptured struct {
	// contains filtered or unexported fields
}

type WeHaveExhaustedSupplies struct {
	// contains filtered or unexported fields
}

type WeHaveMetStrongResistance struct {
	// contains filtered or unexported fields
}

type WeHaveReachedOurObjective struct {
	// contains filtered or unexported fields
}

type WeMustSurrender struct {
	// contains filtered or unexported fields
}

type WeatherForecast struct{ Weather int }