Brady Robshaw

Set Tracker

2023-08-01T00:00:00+00:00

WWDC 2023 came with a ton of interesting new functionality that I had been hoping for and I created this application to explore. Specifically, SwiftData and Swift Charts were extremely interesting. I had familiar working with the Core Data APIs in previous applications, but found it a less than ideal integration into MVVM and SwiftUI.

The application that I would explore these new features with is design to keep track of setting at a rock gym. So what dose it do? Saves all of the logistical information you need to track for commercial gym setting (SwiftData), and cleanly presents the data in a visual manner that is easily digestible (Swift Charts).

Swift data is amazing, and was simultaneously the easiest and hardest part of developing this application. On the easy side, creating your models is trivial:

@Model
final class Gym {
    let id: UUID
    var name: String
    @Relationship(deleteRule: .cascade) var zones: [Zone]
    var difficultyCurve: DifficultyCurve
    
    var climbs: [Climb] {
        get {
            zones.flatMap { $0.climbs }
        }
    }
    
    init(name: String, zones: [Zone], difficultyCurve: DifficultyCurve = DifficultyCurve()) {
        self.id = UUID()
        self.name = name
        self.zones = zones
        self.difficultyCurve = difficultyCurve
    }
}

You can see above I just created my top level object by simply marked it as @model final class and boom all the work is done, it’s now capable of being saved. You can see I’m even managing my relationships to other saved objects with the @Relationship macro.

On the hard side is the fact that it was a beta. This is my first true, deep dive, into a beta software release for Xcode, and the number of times functionality changed out from underneath me and broke my application was very annoying. However I learned a lot watching Apple and the community puzzling out the best way to handle certain features.

Die Master

2022-11-01T00:00:00+00:00

Application I wrote and published to the App Store, which helps DM’s track encounters in role-playing games. My goals with this application was twofold. One create a robust rolling system that tracked past roles and accounted for the variety of different events types that can occur while playing a role-playing game. Second, handle JSON in such a way that the app can ingest new monsters and characters easily.

The crux of making my roll system robust is my Event struct. This records any action that the user can take rolling a dice, making an attack, activating an ability, etc. What values are optional suddenly changes the way the application chooses to display the event.

All of the above views have the same exact Event struct providing the data, but SwiftUI treats them completely differently, providing unique displays depending on what the important information is. It’s a small thing, but I feel it shows a significant improvement from my first application, in terms of understanding and utilizing the power of SwiftUI combined with MVVM.

As for the backend, the application can except JSON (like what is shown below) and converted into monsters that the app maintains in storage. This would make it much easier for users to eventually be able to share content that they have created.

[
  {
    "abilaty": [
      {
        "id": "9ED8654D-3886-498C-B9F0-B30A92AB5247",
        "name": "Brute",
        "discription": " A melee weapon deals one extra die of its damage when the bugbear hits with it (included in the attack)."
      },
      {
        "discription": "If the bugbear surprises a creature and hits it with an attack during the first round of combat, the target takes an extra 7 (2d6) damage from the attack.",
        "id": "CCA91B9A-3061-4544-8654-22231C2163E9",
        "name": "Surprise Attack",
        "onHit": {
          "numberOfDice": 2,
          "numberOfSides": 6,
          "toAdd": 0
        }
      },
      {
        "id": "A776E7A0-90D2-4DAE-8A0B-99B585CB002F",
        "name": "Morningstar",
        "roll": {
          "numberOfDice": 1,
          "numberOfSides": 20,
          "toAdd": 2
        },
        "onHit": {
          "numberOfDice": 2,
          "numberOfSides": 8,
          "toAdd": 2
        }
      },
      {
        "discription": "range 30/120 ft.",
        "id": "7C459A49-9710-4CB7-9BDA-DD5071C25537",
        "name": "Javelin",
        "roll": {
          "numberOfDice": 1,
          "numberOfSides": 20,
          "toAdd": 4
        },
        "onHit": {
          "numberOfDice": 1,
          "numberOfSides": 6,
          "toAdd": 2
        }
      }
    ],
    "id": "966E5EB7-BA6B-4390-B48D-9E26BD1988E6",
    "isShowing": true,
    "OGLContent": true,
    "name": "Bugbear"
  }
]

Fiber Counter

2022-03-01T00:00:00+00:00

This is the first application I wrote and published to the App Store. It was purely a learning exercise to follow an idea through from start to navigating App Store review. Undoubtedly, the most interesting part of this early project was the fact that I had to dip into UIViewControllerRepresentable in order to support emailing functionality that I wanted.

struct MailView: UIViewControllerRepresentable {
  @Environment(\.presentationMode) var presentation
  @Binding var data: ComposeMailData
  let callback: MailViewCallback

  class Coordinator: NSObject, MFMailComposeViewControllerDelegate {
    @Binding var presentation: PresentationMode
    @Binding var data: ComposeMailData
    let callback: MailViewCallback

    init(presentation: Binding<PresentationMode>,
         data: Binding<ComposeMailData>,
         callback: MailViewCallback) {
      _presentation = presentation
      _data = data
      self.callback = callback
    }

    func mailComposeController(_ controller: MFMailComposeViewController,
                               didFinishWith result: MFMailComposeResult,
                               error: Error?) {
      if let error = error {
        callback?(.failure(error))
      } else {
        callback?(.success(result))
      }
      $presentation.wrappedValue.dismiss()
    }
  }

  func makeCoordinator() -> Coordinator {
    Coordinator(presentation: presentation, data: $data, callback: callback)
  }

  func makeUIViewController(context: UIViewControllerRepresentableContext<MailView>) -> MFMailComposeViewController {
    let vc = MFMailComposeViewController()
    vc.mailComposeDelegate = context.coordinator
    vc.setSubject(data.subject)
    vc.setToRecipients(data.recipients)
    vc.setMessageBody(data.message, isHTML: false)
    data.attachments?.forEach {
      vc.addAttachmentData($0.data, mimeType: $0.mimeType, fileName: $0.fileName)
    }
    vc.accessibilityElementDidLoseFocus()
    return vc
  }

  func updateUIViewController(_ uiViewController: MFMailComposeViewController,
                              context: UIViewControllerRepresentableContext<MailView>) {
  }

  static var canSendMail: Bool {
    MFMailComposeViewController.canSendMail()
  }
}

What is this a nice thing to do to myself as a new Swift and SwiftUI developer? No.
Did I get the emailing functionality working? Yes.