Je compare les valeurs dans un champ GKNoise, puis je mets des carreaux dans un tileMap en fonction du niveau de bruit

Cette instruction if compare les valeurs en les arrondissant au dixième le plus proche, y a-t-il une meilleure façon de l'écrire?

if round(MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows)))) == -1.0 {
    tileMap.setTileGroup(tileGroup4, forColumn: columns, row: rows)
}
if round(MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows)))) == -0.9 {
    tileMap.setTileGroup(tileGroup4, forColumn: columns, row: rows)
}
if round(MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows)))) == -0.8 {
    tileMap.setTileGroup(tileGroup4, forColumn: columns, row: rows)
}
if round(MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows)))) == -0.7 {
    tileMap.setTileGroup(tileGroup4, forColumn: columns, row: rows)
}
if round(MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows)))) == -0.6 {
    tileMap.setTileGroup(tileGroup4, forColumn: columns, row: rows)
}
if round(MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows)))) == -0.5 {
    tileMap.setTileGroup(tileGroup3, forColumn: columns, row: rows)
}
if round(MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows)))) == -0.4 {
    tileMap.setTileGroup(tileGroup3, forColumn: columns, row: rows)
}
if round(MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows)))) == -0.3 {
    tileMap.setTileGroup(tileGroup3, forColumn: columns, row: rows)
}
if round(MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows)))) == -0.2 {
    tileMap.setTileGroup(tileGroup3, forColumn: columns, row: rows)
}
if round(MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows)))) == -0.1 {
    tileMap.setTileGroup(tileGroup3, forColumn: columns, row: rows)
}
if round(MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows)))) == 0.0 {
    tileMap.setTileGroup(tileGroup2, forColumn: columns, row: rows)
}
if round(MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows)))) == 0.1 {
    tileMap.setTileGroup(tileGroup2, forColumn: columns, row: rows)
}
if round(MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows)))) == 0.2 {
    tileMap.setTileGroup(tileGroup2, forColumn: columns, row: rows)
}
if round(MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows)))) == 0.3 {
    tileMap.setTileGroup(tileGroup2, forColumn: columns, row: rows)
}
if round(MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows)))) == 0.4 {
    tileMap.setTileGroup(tileGroup2, forColumn: columns, row: rows)
}
if round(MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows)))) == 0.5 {
    tileMap.setTileGroup(tileGroup1, forColumn: columns, row: rows)
}
if round(MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows)))) == 0.6 {
    tileMap.setTileGroup(tileGroup1, forColumn: columns, row: rows)
}
if round(MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows)))) == 0.7 {
    tileMap.setTileGroup(tileGroup1, forColumn: columns, row: rows)
}
if round(MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows)))) == 0.8 {
    tileMap.setTileGroup(tileGroup1, forColumn: columns, row: rows)
}
if round(MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows)))) == 0.9 {
    tileMap.setTileGroup(tileGroup1, forColumn: columns, row: rows)
}
if round(MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows)))) == 1.0 {
    tileMap.setTileGroup(tileGroup1, forColumn: columns, row: rows)
}

Cela semble un peu long et pas très efficace.

3
E. Huckabee 16 nov. 2017 à 15:04

4 réponses

Meilleure réponse

Ma réponse va un peu plus loin que votre question, mais je pense personnellement que ce code aiderait à nettoyer au mieux votre code.

Vous pouvez regrouper les instructions if (à partir de l'apparence de votre code) comme ceci:

let noise = round(MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows))))
let tileGroup1Array = [1.0, 0.9, 0.8, 0.7, 0.6, 0.5]
let tileGroup2Array = [0.4, 0.3, 0.2, 0.1, 0.0]
let tileGroup3Array = [-0.1, -0.2, -0.3, -0.4, -0.5]
let tileGroup4Array = [-0.6, -0.7, -0.8, -0.9, -1.0]

Ensuite, vous pouvez vérifier:

if(tileGroup1Array.contains(noise)) { ... } else if(tileGroup2Array.contains(noise){ ... })
4
jbehrens94 16 nov. 2017 à 12:17

Juste pour le fun:

Aucune instruction if / switch nécessaire du tout

let noise = MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows)))) + 1
let index = Int(round(noise * 10)) / 5
let tileGroup = [tileGroup4,tileGroup3,tileGroup2,tileGroup1,tileGroup1]
tileMap.setTileGroup(tileGroup[index], forColumn: columns, row: rows)
1
Knight0fDragon 16 nov. 2017 à 15:05

Vous pourriez utiliser un switch et un interval matching

switch round(MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows)))) {
case -1.0...(-0.6):
    tileMap.setTileGroup(tileGroup4, forColumn: columns, row: rows)
case -0.5...(-0.1):
    tileMap.setTileGroup(tileGroup3, forColumn: columns, row: rows)
case 0.0...0.4:
    tileMap.setTileGroup(tileGroup2, forColumn: columns, row: rows)
case 0.5...1.0:
    tileMap.setTileGroup(tileGroup1, forColumn: columns, row: rows)
default:
    break
}
5
jeanggi90 16 nov. 2017 à 12:24

Une amélioration relativement simple consiste à calculer round en dehors du conditionnel, à utiliser une variable pour stocker la décision du groupe de titres à utiliser et à convertir la chaîne en if-then-else. Cela vous permettrait d'utiliser <= et => à la place de ==:

let rounded = round(MasterNoise.value(atPosition: vector_float2(Float(columns),Float(rows))))
var tileGroup : SKTileGroup = nil
if rounded <= -0.6 {
    tileGroup = titleGroup4
} else if rounded <= -0.1 {
    tileGroup = titleGroup3
} else if rounded <= 0.4 {
    tileGroup = titleGroup2
} else if rounded <= 1.0 {
    tileGroup = titleGroup1
}
tileMap.setTileGroup(tileGroup, forColumn: columns, row: rows)
5
dasblinkenlight 16 nov. 2017 à 12:18
47329225