Add Battle of Yavin content

[pakirby1]

https://github.com/guidokessels/xwing-data2

The schema of the xws has been updated to reflect the BoY pilots without upgrades

/pilots/galactic-empire/tie-advanced-x1.json

{
      "name": "Darth Vader",
      "caption": "Battle of Yavin",
      "initiative": 6,
      "limited": 1,
      "cost": 6,
      "xws": "darthvader-battleofyavin",
      "ability": "While you perform an attack, you may spend 1 [Force] to change 1 blank result to a [Hit] result.",
      "image": "https://infinitearenas.com/xw2/images/quickbuilds/darthvader-battleofyavin.png",
      "force": { "value": 3, "recovers": 1, "side": ["dark"] },
      "shipAbility": {
        "name": "Advanced Targeting Computer",
        "text": "While you perform a primary attack against a defender you have locked, roll 1 additional attack die and change 1 [Hit] result to a [Critical Hit] result."
      },
      "shipStats": [
        { "arc": "Front Arc", "type": "attack", "value": 2 },
        { "type": "agility", "value": 3 },
        { "type": "hull", "value": 3 },
        { "type": "shields", "value": 3 }
      ],
      "standardLoadout": ["marksmanship", "hate", "afterburners"],
      "artwork": "https://infinitearenas.com/xw2/images/artwork/pilots/darthvader.png",
      "standard": true,
      "extended": true,
      "keywords": ["Dark Side", "Sith", "TIE"],
      "epic": true
    }

Some of the pilots have battle of Yavin specific upgrades

"standardLoadout": ["elusive", "vengeful-battleofyavin"]

The upgrades JSON has been updated for the new abilities
/data/upgrades/talent.json

{
    "name": "Vengeful",
    "limited": 0,
    "xws": "vengeful-battleofyavin",
    "sides" : [
      {
        "title": "Vengeful",
        "type": "Talent",
        "ability": "After a friendly ship at range 0-3 is destroyed, if that ship is limited, you may remove 1 of your red tokens or recover 1 recurring charge on your ship card.",
        "slots": ["Talent"]
      }
    ],
    "standard": true,
    "extended": true,
    "epic": true,
    "standardLoadoutOnly": true
  }

{
    "name": "Precise Astromech",
    "limited": 0,
    "xws": "preciseastromech-battleofyavin",
    "sides": [
      {
        "ability": "After you perform an action, you may spend 1 [Charge] to perform a red [Lock] action.",
        "title": "Precise Astromech",
        "type": "Astromech",
        "slots": ["Astromech"],
        "charges": { "value": 2, "recovers": 0 }
      }
    ],
    "standard": true,
    "extended": true,
    "epic": true,
    "standardLoadoutOnly": true
  }

[pakirby1]

Change the UI to handle the landscape orientation of the ship card images

[pakirby1]

Figure out how to add buttons for the upgrades. Use Adobe Xd

[pakirby1]

Update Redux_ShipView to handle new cards
bodyContent

[pakirby1]

Update xws handling

shouldn’t it be standardLoadout: Bool? not [String]?

Models/pilot.swift

• Pilot
  • Add standardLoadout: [String]? to Pilot
• PilotDTO
  • var standardLoadout: [String]? { return _standardLoadout ?? [] }
  • private var _standardLoadout: [String]?
  • enum CodingKeys { case _standardLoadout = "standardLoadout" }

Models/upgrade.swift

• Upgrade
  • Add standardLoadout: [String]? to Upgrade

[pakirby1]

Update Ship View

• Move charges from a vertical stack to a horizontal stack
• Move charges below ship image
• Move Set and Ion buttons

Card Dimensions

Ship
W: 503, H: 700

Upgrade
W: 700, H: 503

Battle of Yavin Ship
W: 853, H: 497

• Create a generic view (UpgradeTextView) for quick build upgrades
  • Upgrade Name
  • Charges

Update Redux_ShipView to

var upgradeCardImage: AnyView {
            let emptyView = AnyView(EmptyView())
  // If the imageOverlaUrl is empty, return an UpgradeTextView 
}

[pakirby1]

We should check for standardLoadout == true and if so, display an image the same size as an upgrade card with the upgrade name as a title followed by a description.

Fonts

Symbols: x-wing-miniatures
Title: Eurostile Regular 77 pt
Body: Eurostile Regular 48 pt

Upgrade Text

for upgrades where standardLoadout == true you’ll see this

"sides": [
      {
        "title": "R2-A3",
        "type": "Astromech",
        "ability": "After you reveal your dial, you may spend 1 [Charge] and gain 1 disarm token to recover 1 shield.",
        "slots": ["Astromech"],
        "charges": { "value": 2, "recovers": 0 }
      }

The text in the ability field needs to be translated into a view object that will contain two different fonts; Eurostile and x-wing miniatures. Use the symbol map to translate the upgrade text into a series of SwiftUI Text views.

Text(“after you fully execute a (3 
Text(Symbol.Straight)
                .font(.custom("xwing-miniatures", size: self.symbolSize))
Text(“)

To make things easier define a dedicated view for a symbol

struct SymbolView : View {
  let symbol: Symbol
  let symbolSize: CGFloat = 48.0

  var body: some View {
    Text(symbol).font(.custom("xwing-miniatures", size: self.symbolSize))

Now. just do:

Text(“after you fully execute a (3 
SymbolView(Symbol.Straight)
Text(“) maneuver…”)

struct UpgradeTextView : View {
  let upgradeText: String
  
  var body: some View {
    createUpgradeTextView(upgradeText)
  }

  func createUpgradeTextView(upgradeText : String) -> some View {
    // translate from upgradeText to a view
  }    

Symbol Map

Upgrade Text	Symbol Character
Straight	8
Focus	f
Evade	e
Lock	l
Boost	b
Calculate	a
Hit	d
Critical Hit	c
Charge	g
Force	h
Reinforce	i
Jam	j
Cloak	k
Coordinate	o
Reload	=
Rotate Arc	R
Front Arc	Brace Left
Rear Arc	Bar
Bullseye Arc	Brace Right
Front Arc	Brace Left
Right Arc	cent
Left Arc	sterling
Full Front Arc	aciitilde
Full Rear Arc	exclamdown
Left Sloop	1
Right Sloop	3
Koigran Turn	2
Left Turn	4
Right Turn	6
Bank Left	7
Bank Right	9
Left Talon	:
Right Talon	;
Barrel Roll	r
Slam	s

Upgrade Text View

Sourced from Upgrades

{
    "name": "Attack Speed",
    "limited": 0,
    "xws": "attackspeed-battleofyavin",
    "sides" : [
      {
        "title": "Attack Speed",
        "type": "Talent",
        "ability": "After you fully execute a [3 [Straight]] or [4 [Straight]] maneuver, you may perform a boost using the [1 [Straight]] template. (This is not an action).",
        "slots": ["Talent"]
      }
    ],
    "standard": true,
    "extended": true,
    "epic": true,
    "standardLoadoutOnly": true
  }

• Icon
  • : from type Talent ('E')
• Title
  • : from title "Attack Speed", Eurostile Regular 77 pt
• Upgrade Text
  • : from ability
  • UpgradeTextUtility.testMergeTypes()

https://xwing-miniatures-second-edition.fandom.com/wiki/Upgrades

Upgrade Text	Symbol Character
Astromech	A
Cannon	C
Cargo	G
Command	?
Configuration	n
Force	F
Crew	T
Payload	B
Gunner	Y
Hardpoint	H
Illicit	I
Modification	m
Missile	M
Sensor	S
Tactical Relay	Z
Talent	E
Team	T
Tech	X
Title	t
Torpedo	P
Turret	U

[pakirby1]

extension SwiftSection {
    struct MultiLayout : View {
        @State var standardLoadout = false
        
        var body: some View {
            Text("MultiLayout")
            Button(action: { standardLoadout.toggle() }) {
                Text("Change Layout")
            }
            
            if (standardLoadout == true) {
                StandardLoadoutLayout()
            } else {
                DefaultLayout()
            }
        }
    }

    struct StandardLoadoutLayout : View {
        var body: some View {
            VStack {
                HStack {
                    ShipCardImage(standardLoadout: true)
                    DialView()
                }
                Charges(verticalLayout: false)
            }
        }
    }
    
    struct DefaultLayout : View {
        var body : some View {
            HStack {
                ShipCardImage(standardLoadout: false)
                Charges(verticalLayout: true)
                DialView()
            }
        }
    }
    
    struct Charges : View {
        let verticalLayout: Bool
        
        var body : some View {
            if (verticalLayout) {
                VStack {
                    ChargeView(color: .yellow)
                    ChargeView(color: .blue)
                    ChargeView(color: .purple)
                }
            } else {
                HStack {
                    ChargeView(color: .yellow)
                    ChargeView(color: .blue)
                    ChargeView(color: .purple)
                }
            }
        }
    }
    
    struct ChargeView : View {
        let color: Color
        
        var body : some View {
            HStack {
                Rectangle().frame(width: 50, height: 50).foregroundColor(color)
                Rectangle().frame(width: 50, height: 50).foregroundColor(color)
            }
        }
    }
    
    struct DialView : View {
        var body: some View {
            Circle()
                .frame(width: 250, height: 250)
                .foregroundColor(.red)
        }
    }
    
    struct ShipCardImage : View {
        let standardLoadout : Bool
        
        var body: some View {
            if (standardLoadout == true) {
                Image("WedgeAntilles").resizable().aspectRatio(contentMode: .fit)
            } else {
                Image("Hound").resizable().aspectRatio(contentMode: .fit)
            }
        }
    }
}

[pakirby1]

Can we useAnyLayout?

struct ConditionalLayoutExample2: View {
    @Environment(\.horizontalSizeClass) private var size
    
    var body: some View {
        let layout = (size == .regular) ?
        AnyLayout(HStackLayout()) :
        AnyLayout(VStackLayout())
        
        layout {
            View1()
            View2()
        }
        .animation(.default, value: size)
    }
}

https://www.appcoda.com/swiftui-anylayout/

https://swiftwithmajid.com/2022/08/16/conditional-layouts-in-swiftui/

https://swiftwithmajid.com/2022/11/16/building-custom-layout-in-swiftui-basics/

https://www.swiftbysundell.com/articles/switching-between-swiftui-hstack-vstack/

[pakirby1]

{
      "name": "Sigma 7",
      "caption": "Battle of Yavin",
      "xws": "sigma7-battleofyavin",
      "initiative": 4,
      "limited": 1,
      "shipAbility": {
        "name": "Sensitive Controls",
        "text": "During the System Phase, you may perform a red [Barrel Roll] or red [Boost] action."
      },
      "standard": true,
      "extended": true,
      "cost": 4,
      "charges": { "value": 2, "recovers": 0 },
      "shipStats": [
        { "arc": "Front Arc", "type": "attack", "value": 3 },
        { "type": "agility", "value": 3 },
        { "type": "hull", "value": 4 }
      ],
      "shipActions": [
        { "difficulty": "White", "type": "Focus" },
        { "difficulty": "White", "type": "Evade" },
        { "difficulty": "White", "type": "Barrel Roll" },
        { "difficulty": "White", "type": "Boost" },
        { "difficulty": "White", "type": "Lock" }
      ],
      "standardLoadout": ["marksmanship", "firecontrolsystem"],
      "ability": "During the System Phase, you may spend 1 [Charge] to acquire a lock on an enemy ship at range 0-1.",
      "keywords": ["TIE"],
      "image": "https://infinitearenas.com/xw2/images/quickbuilds/sigma7-battleofyavin.png",
      "artwork": "https://infinitearenas.com/xw2/images/artwork/pilots/sigma7.png",
      "epic": true
    },

struct PilotDTO: Codable {
    let name: String
    let initiative: Int
    let limited: Int
    let cost: Int
    let xws: String
    var text: String { return _text ?? "" }
    var shipAbility: ShipAbility? { return _shipAbility ?? nil }
    var slots: [Slot]? { return _slots ?? [] }
    var artwork: String { return _artwork ?? "" }
    var force: Force? { return _force ?? nil }
    var charges: Charges? { return _charges ?? nil }
    
    private var _text: String?
    private var _force: Force?
    private var _charges: Charges?
    private var _shipAbility: ShipAbility?
    private var _slots: [Slot]?
    private var _artwork: String?
    
    enum CodingKeys: String, CodingKey {
        case _text = "text"
        case name
        case initiative
        case limited
        case cost
        case xws
        case _shipAbility = "shipAbility"
        case _slots = "slots"
        case _artwork = "artwork"
        case _force = "force"
        case _charges = "charges"
    }
}

• Add standardLoadout array of String to PilotDTO

var standardLoadout : [String]? { return _standardLoadout ?? nil }
private var _standardLoadout : [String]?

enum CodingKeys {
  case _standardLoadout = “standardLoadout”
}

[pakirby1]

How are upgrades determined?

Normally, upgrades are loaded from the squad xws:

{"description":"","faction":"galacticempire","name":"BoyCrew","pilots":[{"id":"darthvader-battleofyavin","name":"darthvader-battleofyavin","points":6,"ship":"tieadvancedx1"},{"id":"maulermithel-battleofyavin","name":"maulermithel-battleofyavin","points":3,"ship":"tielnfighter"},{"id":"sigma7-battleofyavin","name":"sigma7-battleofyavin","points":4,"ship":"tieininterceptor"},{"id":"idenversio","name":"idenversio","points":3,"ship":"tielnfighter","upgrades":{"talent":["elusive"],"cannon":["ioncannon"]}},{"id":"backstabber-battleofyavin","name":"backstabber-battleofyavin","points":4,"ship":"tielnfighter"}],"points":20,"vendor":{"yasb":{"builder":"YASB - X-Wing 2.5","builder_url":"https://yasb.app/","link":"https://yasb.app/?f=Galactic%20Empire&d=v9ZhZ20Z564X125W204W105Y566X127W105Y573X125W113Y218X119WW11WWY565X116W381W105&sn=BoyCrew&obs="}},"version":"10/28/2022"}

The upgrades are stored in a dictionary in the squad xws

"upgrades":{"talent":["elusive"],"cannon":["ioncannon"]}

For quick builds the xws contains no upgrades

{"id":"sigma7-battleofyavin","name":"sigma7-battleofyavin","points":4,"ship":"tieininterceptor"}

The upgrades for these pilots are stored with the ship JSON. We need to use the name field of the pilot from the squad JSON to get the upgrades from the ship JSON.

{
     . . .
      "xws": "sigma7-battleofyavin",
      "shipAbility": {
        "name": "Sensitive Controls",
        "text": "During the System Phase, you may perform a red [Barrel Roll] or red [Boost] action."
      },
      "charges": { "value": 2, "recovers": 0 },
      . . .
      "standardLoadout": ["marksmanship", "firecontrolsystem"],
      "ability": "During the System Phase, you may spend 1 [Charge] to acquire a lock on an enemy ship at range 0-1.",
      . . .
    },

So to get the upgrades for Sigma 7, first get the xws field of the pilot ("name":"sigma7-battleofyavin") and get the JSON for the ship by the xws (xws = "sigma7-battleofyavin"), and pull the (standardLoadout) field from the ship JSON, which will be an array of upgrade names.

"standardLoadout": ["marksmanship", "firecontrolsystem"]
"standardLoadout": ["predator", "fanatic-battleofyavin"]

which is different from how upgrades are normally stored

"upgrades":{"talent":["elusive"],"cannon":["ioncannon"]}

Since all upgrade names are unique you should be able to load them from the upgrade dictionary.

See CacheService.getShipV1()

func global_getShip() {
  if let upgrades = squadPilot.upgrades {
     allUpgrades = UpgradeUtility.buildAllUpgrades(upgrades)
  }
        
        return ShipPilot(ship: ship,
                         upgrades: allUpgrades,
                         points: squadPilot.points,
                         pilotState: pilotState)
  }
}

Similar logic exists within

func buildPilotStateData(squad: Squad,
                                 squadPilot: SquadPilot,
                                 pilotIndex: Int) -> String

Notes:

• Given that the squadPilot has upgrades defined in the squad xws, load the upgrades from the ShipPilot.upgrades.
• For quick builds, get the name of the pilot, find the ship by xws and get the upgrades from the standardLoadout field of the ship.
• We could also transform the xws and add the missing upgrades and process the transformed XWS

• A : Add upgrades to XWS before processing
  • Update the json to include the upgrades array
• B : Add upgrades to squad after saving
• C : Add upgrades when building the pilot state

{
		"id":"idenversio",
		"name":"idenversio",
		"points":3,
		"ship":"tielnfighter",
		"upgrades":{
			"talent":["elusive"],
			"cannon":["ioncannon"]
		}
},
{
	"id":"backstabber-battleofyavin",
	"name":"backstabber-battleofyavin",
	"points":4,
	"ship":"tielnfighter"
}

using the Ship json

{
      "name": "“Backstabber”",
      "caption": "Battle of Yavin",
      "initiative": 5,
      "limited": 1,
      "cost": 4,
      "xws": "backstabber-battleofyavin",
      "ability": "While you perform a primary attack, if a friendly Darth Vader or “Mauler” Mithel is in your [Left Arc] or [Right Arc] at range 0-1, roll 1 additional attack die.",
      "image": "https://infinitearenas.com/xw2/images/quickbuilds/backstabber-battleofyavin.png",
      "artwork": "https://infinitearenas.com/xw2/images/artwork/pilots/backstabber.png",
      "shipStats": [
        { "arc": "Front Arc", "type": "attack", "value": 2 },
        { "type": "agility", "value": 3 },
        { "type": "hull", "value": 4 }
      ],
      "standardLoadout": ["crackshot", "disciplined", "afterburners"],
      "standard": true,
      "extended": true,
      "keywords": ["TIE"],
      "epic": true
    }

it can be transformed into

{
	"id":"backstabber-battleofyavin",
	"name":"backstabber-battleofyavin",
	"points":4,
	"ship":"tielnfighter"
        "upgrades":{
			"talent":["crackshot", “disciplined”],
			"modification":["afterburners"]
		}
}

• For each pilot in the squad XWS
  • get the name (backstabber-battleofyavin)
  • Use the name to lookup the ship by the xws field ("xws": "backstabber-battleofyavin")
  • Create a new upgrades JSON part from the standardLoadout in the ship JSON

Transform the standardLoadout into an upgrades JSON part. From the ship JSON into an upgrades JSON part.

"standardLoadout": ["crackshot", "disciplined", "afterburners"]

into

"upgrades":{
   "talent":["crackshot", “disciplined”],
   "modification":["afterburners"]
}

func addStandardLoadoutUpgrades(pilotJSON: String) -> String {
	// pilotJSON
	// "standardLoadout": ["crackshot", "disciplined", "afterburners"]
	
	/*
		for upgrade in standardLoadout
			build the upgrades dictionary (String:[String])
				"talent" : ["crackshot", "disciplined"]
				"modification" : ["afterburners"]
	*/
	
	/*
		return 
		"upgrades":{
   		"talent":["crackshot", “disciplined”],
   		"modification":["afterburners"]
		}
	*/
}

Resources

• https://codewithchris.com/swiftyjson/
• https://github.com/johncodeos-blog/ParseJSONSwiftyJSONiOSExample
• https://blog.logrocket.com/easily-handle-json-swift-swiftyjson/
• https://www.appypie.com/swift-json-swiftyjson
• https://github.com/SwiftyJSON/SwiftyJSON
• https://betterprogramming.pub/how-to-convert-to-and-from-json-using-swift-codable-e78bf353fff5

func buildPilotStateData(squad: Squad,
												 squadPilot: SquadPilot,
												 pilotIndex: Int) throws -> String {
  // deserialize squad

	var allUpgrades : [Upgrade] = []

	// Add the upgrades from SquadPilot.upgrades by iterating over the
	// UpgradeCardEnum cases and calling getUpgrade
	if let upgrades = squadPilot.upgrades {
			allUpgrades = try UpgradeUtility.buildAllUpgrades(upgrades)
	}

	let pilotStateData = PilotStateData(
			pilot_index: pilotIndex,
			adjusted_attack: arc,
			adjusted_defense: agility,
			hull_active: calculateActive(type: .hull,ship: ship, squadPilot: squadPilot, allUpgrades: allUpgrades),
			hull_inactive: 0,
			shield_active: calculateActive(type: .shields, ship: ship, squadPilot: squadPilot, allUpgrades: allUpgrades),
			shield_inactive: 0,
			force_active: calculate_force_active(ship: ship, squadPilot: squadPilot, allUpgrades: allUpgrades),
			force_inactive: 0,
			charge_active: ship.pilotCharge(pilotId: squadPilot.id),
			charge_inactive: 0,
			selected_maneuver: "",
			shipID: "",
			upgradeStates: buildUpgradeStates(allUpgrades: allUpgrades),
			dial_status: DialStatus.hidden,
			hasSystemPhaseAction: false
	)
}

For regular ships, if the pilot has upgrades, then squadPilot.upgrades will not be nil or will be empty. Add the available upgrades to allUpgrades.

For standardLoadout ships squadPilot.upgrades will be nil. Get the upgrades from the ship json first, then UpgradeUtility.buildAllUpgrades()

We should probably have the squadPilot.upgrades already initialized before calling buildPilotStateData()

In createPilotState_throws() :

for pilot in squad.pilots {
            do {
                // Add any missing upgrades to pilot if they are standardLoadout
                let json = try buildPilotStateData(squad: squad,
                                               squadPilot: pilot,
                                               pilotIndex: pilotIndex)
                
                try savePilotState_throws(squadData: squadData,
                               state: json,
                               pilotIndex: pilotIndex)
                
                pilotIndex += 1
            } catch {
                throw error
            }
        }

[pakirby1]

[pakirby1]

Combine pipeline

// Final
/*
	Load Squad 
	Build SquadInfo
	Update Pilots
	Update squad
*/
func loadSquad() -> AnyPublisher<JSON, XWSInputError> {
	let squadJSON = "..."
	
	return Future {
		if squadJSON == "" {
			return promise(.failure(XWSInputError.emptySquad))
		} else {
			return promise(.success(squadJSON))
		}
	}
	.eraseToAnyPublisher()
}

func buildSquadInfo(_ squad: JSON) -> AnyPublisher<SquadInfo, XWSInputError> {
		let pilots: [JSON] = squad["pilots"].arrayValue
		let factionID: String = squad["factionID"].stringValue
		let squadInfo: SquadInfo = SquadInfo(pilots, factionID)
		
	return Future {
		if pilots.count == 0 {
			return promise(.failure(XWSInputError.noPilots))
		} else {
			return promise(.success(squadInfo))
		}
	}
	.eraseToAnyPublisher()
}

func createNewPilot(_ squadPilot: JSON) -> JSON {
	let result:XWSImport.LoadSquadResult = xwsImportService.buildResult(
			squadPilot: squadPilot,
			factionID: factionID)

	switch(result) {
			case .success(let newPilot):
					print(newPilot)
					return newPilot

			case .failure(let error):
					XCTFail("updatedPilots \(error)")
	}		
}

func updatePilots(_ info: SquadInfo) -> ([JSON), SquadInfo) {
	let updatedPilots = info.pilots.map{ pilot -> JSON in
			createNewPilot(pilot)
		}
	
	return Future {
		if upDatedPilots.count != info.pilots.count {
			return promise(.failure(XWSInputError.noUpdatedPilots))
		} else {
			return promise(.success((updatedPilots, info)))
		}
	}
	.eraseToAnyPublisher()
}

func updateSquad(_ tuple: ([JSON], SquadInfo)) -> AnyPublisher<JSON, Never> {
		let updatedPilots = tuple.0 // [JSON]
		var squad = tuple.1.squad // JSON
		squad["pilots"] = updatedPilots
		
		return Future {
			if upDatedPilots.count != info.pilots.count {
				return promise(.failure(XWSInputError.noUpdatedPilots))
			} else {
				return promise(.success((updatedPilots, info)))
			}
		}
		.eraseToAnyPublisher()
}

let squadInfoPublisher : AnyPublisher<SquadInfo, XWSInputError> = xwsImportService
	.loadSquad()	// AnyPublisher<JSON, XWSInputError>
	.flatMap(buildSquadInfo)	// AnyPublisher<SquadInfo, XWSInputError>
	.map(updatePilots)
	.flatMap(updateSquad)

Instead of using Future we could send data or an error to a dedicated subject

let mySubject = PassthroughSubject<JSON, XWSInputError>()
mySubject.send(squad)
mySubject.fail(XWSinputError.noSquad)

Or return Just

Just(squad)
    .setFailureType(to: XWSImportError.self)
    .eraseToAnyPublisher()

We can use some extensions on AnyPublisher

extension AnyPublisher {
    static func just(_ output: Output) -> Self {
        Just(output)
            .setFailureType(to: Failure.self)
            .eraseToAnyPublisher()
    }
    
    static func fail(with error: Failure) -> Self {
        Fail(error: error).eraseToAnyPublisher()
    }
}

extension Publisher {
  func asResult() -> AnyPublisher<Result<Output, Failure>, Never> {
    self
      .map(Result.success)
      .catch { error in
        Just(.failure(error))
      }
      .eraseToAnyPublisher()
  }
}

[pakirby1]

Update the Store

switch(action) {
        case .importXWS(var xws):
            return preprocess(xws: &xws)
                     .flatMap(importXWS(xws:))

[pakirby1]

to determine if the ship is a standard loadout, check the XWS

{
      "name": "Luke Skywalker",
      "caption": "Battle of Yavin",
      "initiative": 5,
      "limited": 1,
      "cost": 5,
      "xws": "lukeskywalker-battleofyavin",
      "ability": "After you are declared as the defender during an attack, you may recover 1 [Force].",
      "force": { "value": 2, "recovers": 1, "side": ["light"] },
      "shipAbility": {
        "name": "Hope",
        "text": "After another friendly ship at range 0-3 is destroyed, you may perform a [Focus] or [Boost] action."
      },
      "standardLoadout": ["attackspeed-battleofyavin", "instinctiveaim", "protontorpedoes", "r2d2-battleofyavin"],
      "image": "https://infinitearenas.com/xw2/images/quickbuilds/lukeskywalker-battleofyavin.png",
      "artwork": "https://infinitearenas.com/xw2/images/artwork/pilots/lukeskywalker.png",
      "standard": true,
      "extended": true,
      "keywords": ["X-wing"],
      "epic": true
    }

Then update the layout accordingly. MultiLayout?