Decode JSON Double to CGFloat in Swift - json

Question

EDIT: The Code works, the issue was with the imported data set, which did not classify empty fields as number, but as string instead.
My app needs to import values from a JSON file in a similar construct as shown below
[
{
"id": 1,
"string": "Text String",
"int": 6,
"cgfloat": 1.1,
}
]
Import:
id = try container.decode(Int.self, forKey: .id)
string = try container.decode(String.self, forKey: .string)
int = try container.decode(Int.self, forKey: .int)
I have no clue how I can read the value 1.1, neither Double nor Float, CGFloat, Int, nor String works here.
Do I need to change my data structure or is there a way to interpret this value properly in Swift?
this crashes the app:
let cgfloat = try container.decode(CGFloat.self, forKey: . cgfloat)
As requested the full code:
struct Monster: Codable, Comparable {
enum MonsterStatus: String, Identifiable, Codable, Hashable {
var id: Self {
return self
}
case Normal = "Normal"
case Attack = "Attack"
case Hit = "Hit"
case Defend = "Defend"
case Dead = "Dead"
}
enum MonsterType: String, Identifiable, Codable, Hashable {
var id: Self {
return self
}
case Undead = "Undead"
case Human = "Human"
case Dinosaur = "Dinosaur"
case Dwarf = "Dwarf"
case Elf = "Elf"
case Wisp = "Wisp"
case Ghost = "Ghost"
case Beast = "Beast"
case Snake = "Snake"
case Giant = "Giant"
case Demon = "Demon"
case Dragon = "Dragon"
case Error = "Error"
}
struct ImagesCatalog: Equatable, Codable {
var Normal: String
var Attack: String
var Defend: String
var Hit: String
var Dead: String
}
static func < (lhs: Monster, rhs: Monster) -> Bool {
return lhs.id < rhs.id
}
static func == (lhs: Monster, rhs: Monster) -> Bool {
return lhs.id == rhs.id
}
var id: Int
let name: String
let image: String = ""
var imagePrefix:String = ""
var strength: Int = 4
var life: Int = 1
var fleeChance: Int = 0
var isBoss: Bool = false
var flying: Bool = false
var mage: Bool = false
var venomous: Bool = false
var giant: Bool = false
var carnivore: Bool = false
var herbivore: Bool = false
var type: MonsterType
var location: HordeGameData.Location
var isFaceUp: Bool = false
var soundAppear: String = "skeletonWalk4.mp3"
var soundHit: String = "skeletonHit1.mp3"
var soundDefend: String = "skeletonEmerge1.mp3"
var soundAttack: String = "skeletonHit4.mp3"
var soundDead: String = "skeletonShatter1.mp3"
var playSound: Bool = true
let images: ImagesCatalog
var imagePic: String
var scaleFactor: CGFloat = 0.5
var active: Bool = false
var slash: Bool = false
var description: String = ""
var status: MonsterStatus = .Normal
func returnColor() -> Color {
if isFaceUp && isBoss {
return .red
} else {
return .red
}
}
func provideID() -> String {
return String(self.id)
}
mutating func playSoundToggle() {
self.playSound.toggle()
}
mutating func reduceStrengthBy(_ amount: Int) {
if strength > amount {
self.strength -= amount
}
}
mutating func defineImage(status: MonsterStatus, slash: Bool) {
self.status = status
switch status {
case .Normal: imagePic = images.Normal
if playSound {
Sound.play(file: self.soundAppear)
}
case .Attack: imagePic = images.Attack
if playSound {
Sound.play(file: self.soundAttack)
}
case .Defend: imagePic = images.Defend
if playSound {
Sound.play(file: self.soundDefend)
}
case .Hit : imagePic = images.Hit
if playSound {
Sound.play(file: self.soundHit)
}
case .Dead : imagePic = images.Dead
if playSound {
Sound.play(file: self.soundDead)
}
}
self.slash = slash
}
mutating func nextImage() {
switch self.status {
case .Normal: defineImage(status: .Attack, slash: false)
case .Attack: defineImage(status: .Defend, slash: false)
case .Defend: defineImage(status: .Hit, slash: false)
case .Hit : defineImage(status: .Dead, slash: false)
case .Dead : defineImage(status: .Normal, slash: false)
}
}
mutating func setID(_ id: Int) {
self.id = id
}
mutating func reduceLife() {
life -= 1
}
mutating func addLife() {
life += 1
}
func provideLife() -> String {
var lifeString = ""
for _ in 0..<life {
lifeString.append("💜")
}
return lifeString
}
///
private enum CodingKeys: String, CodingKey {
case id
case name
case imagePrefix
case strength
case life
case fleeChance
case isBoss
case flying
case mage
case venomous
case giant
case carnivore
case herbivore
case type
case location
case soundAppear
case soundHit
case soundDefend
case soundAttack
case soundDead
case images
case scaleFactor
case description
}
init(from decoder: Decoder) throws {
let container = try decoder.container(keyedBy: CodingKeys.self)
id = try container.decode(Int.self, forKey: .id)
name = try container.decode(String.self, forKey: .name)
imagePrefix = try container.decode(String.self, forKey: .imagePrefix)
strength = try container.decode(Int.self, forKey: .strength)
life = try container.decode(Int.self, forKey: .life)
fleeChance = try container.decode(Int.self, forKey: .fleeChance)
isBoss = try container.decode(Bool.self, forKey: .isBoss)
flying = try container.decode(Bool.self, forKey: .flying)
mage = try container.decode(Bool.self, forKey: .mage)
venomous = try container.decode(Bool.self, forKey: .venomous)
giant = try container.decode(Bool.self, forKey: .giant)
carnivore = try container.decode(Bool.self, forKey: .carnivore)
herbivore = try container.decode(Bool.self, forKey: .herbivore)
let monsterTypeValue = try container.decode(String.self, forKey: .type)
type = MonsterType(rawValue: monsterTypeValue) ?? .Error
let locationValue = try container.decode(String.self, forKey: .location)
location = HordeGameData.Location(rawValue: locationValue) ?? .Error
soundAppear = try container.decode(String.self, forKey: .soundAppear)
soundHit = try container.decode(String.self, forKey: .soundHit)
soundDefend = try container.decode(String.self, forKey: .soundDefend)
soundAttack = try container.decode(String.self, forKey: .soundAttack)
soundDead = try container.decode(String.self, forKey: .soundDead)
images = .init(Normal: imagePrefix + "Normal",
Attack: imagePrefix + "Attack",
Defend: imagePrefix + "Defend",
Hit: imagePrefix + "Hit",
Dead: imagePrefix + "Dead")
imagePic = imagePrefix + "Normal"
// let stringScale = try container.decode(CGFloat.self, forKey: .scaleFactor)
// print(stringScale)
// scaleFactor = stringScale.CGFloatValue() ?? 0.5
description = try container.decode(String.self, forKey: .description)
print("Monster \(id): \(name) imported")
}
}
Decode funtion
class MonsterInventory {
static let shared = MonsterInventory()
var staticItems: [Monster] = []
private init() {
self.parseMonsterJson()
}
private func parseMonsterJson() {
guard let monsterJsonFileUrl = Bundle.main.url(forResource: "Monsters", withExtension: "json") else {
fatalError("Unable to find file")
}
do {
let content = try Data(contentsOf: monsterJsonFileUrl)
let jsonDecoder = JSONDecoder()
staticItems = try jsonDecoder.decode([Monster].self, from: content)
} catch let error {
print(error.localizedDescription)
staticItems = []
}
}
func fetchMonsterWithID(_ id: Int) -> Monster {
return staticItems.filter{$0.id == id}.first ?? staticItems.filter{$0.id == 10}.first!
}
func fetchMonsterWithName(_ name: String) -> Monster {
return staticItems.filter{$0.name == name}.first ?? staticItems.filter{$0.id == 10}.first!
}
}
here is an excerpt of the JSON:
[
{
"id": 1,
"name": "Skeleton Warrior",
"strength": 6,
"life": 1,
"fleeChance": 0,
"isBoss": false,
"flying": false,
"mage": false,
"venomous": false,
"giant": false,
"carnivore": false,
"herbivore": false,
"type": "Undead",
"location": "Plains",
"soundAppear": "skeletonWalk4.mp4",
"soundHit": "skeletonHit1.mp3",
"soundDefend": "swordSwoosh2.m4a",
"soundAttack": "swordSwoosh1.m4a",
"soundDead": "skeletonShatter2.mp3",
"imagePrefix": "SkeletonWarrior",
"imageNormal": "SkeletonWarriorNormal",
"imageAttack": "SkeletonWarriorAttack",
"imageDefend": "SkeletonWarriorDefend",
"imageHit": "SkeletonWarriorHit",
"imageDead": "SkeletonWarriorDead",
"scaleFactor": 1.1,
"description": "A weak skeleton fighter."
},
...
]

Answer 1

I'm unsure why are you decoding key by key... I think you should create a struct unless you really need to decode key by key (like
flanker mentioned in a comment to this answer).
If you do need to go key by key you need to provide more details on how are you decoding the JSON
This is the struct that fits your JSON
struct Elm: Codable {
var id: Int
var string: String
var int: Int
var cgfloat: CGFloat // also can be Double and Float
}
You can also change the variables names to follow the camelCase naming.
struct Elm: Codable {
var id: Int
var string: String
var int: Int
var cgFloat: Double
private enum CodingKeys : String, CodingKey {
case id, string, int, cgFloat = "cgfloat"
}
}
This is how you can decode the object.
let decoder = JSONDecoder()
let obj = try! decoder.decode([Elm].self, from: json.data(using: .utf8)!)
In this case the root of your JSON is an array so for that case instead of using Elm.self we use [Elm].self to decode to the array
This way Swift maps the JSON Key to the matching variable name (or using the Coding Keys like I demonstrated in the second struct)
This was tested in Playgrounds
UPDATE 1
Based on your updated question I now see why the individual decodings, but assuming that the key that you are having problems with is the scaleFactor which is the only Float number in the sample the code you provided works with no issues at all.
// [...]
// uncommented your code
scaleFactor = try container.decode(CGFloat.self, forKey: .scaleFactor)
let _scaleFactor = try container.decode(CGFloat.self, forKey: .scaleFactor) // both work
description = try container.decode(String.self, forKey: .description)
print("Monster \(id): \(name) imported")
Now you can double check if the reading of the file is being done correctly (if you can read the rest of the file it probably is)