No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Property Observers

9/27
Recursos

Aportes 26

Preguntas 0

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

willset y el didset

🧐

react, is that you?

Se parece un poco al didMount de react JAJAAJJAJA

willSet is called just before the value is stored.
didSet is called immediately after the new value is stored.

class LifeGame{
    var life: Int = 0{
        willSet(newLife){
            if(newLife > 100)
            {
                self.life = 100
                print("not is posible more that 100 in life")
            }
            
        }
        didSet{
            if(life > 100){
                life = 100
            }
            if(life <= 0)
            {
                print("game Over")
            }
            print("life : \(life)")
           
        }
    }
}

Acá está mi aporte, no vi uno que hiciese todas las funciones, asi que acá lo dejo:

class PlayerLife{
    /* Asigno la vida inicial */
    var life: Int = 100{
        willSet(newLife){
            /* Hago un if, para que, en caso de incrementar la vida
               por encima de 100, solo diga 100 */
            if newLife >= 100{
                print("Vida: 100")
            } else if newLife <= 0 {
                print("Vida: 0")
            }else {
            /* Si la vida < 100 imprime el resultado */
                print("Vida: \(newLife)")
            }
        }
        didSet {
            
            /* Hago un if, para que, si la vida > 100
               cambie el resultado a 100, así los cálculos saldrán bien,
	             y viceversa con la vida cuando es <0 */
            
            if life > 100 {
                life = 100
            } else if life < 0 {
                life = 0
            }
            
            /* Después hago otro if, dependiendo de si la vida
               incrementa, disminuye o se queda igual, imprime el resultado */
            
            if life > oldValue {
                print("Tu vida ha incrementado \(life - oldValue)pts.")
            } else if life < oldValue {
                print("Tu vida ha disminuido \(oldValue - life)pts.")
            } else {
                print("Tus pts. de vida son iguales")
            }
            /* Hago un if que, si la vida baja de 0, indica que estás muerto*/
            if life <= 0 {
                print("Has muerto")
            }
        }
    }
}

let player = PlayerLife()
player.life = 90
player.life = 30
player.life = 80
player.life = 1000
player.life = 1234
player.life = -1200

Hola dejare mi respuesta por aqui … esta es la cuenta de mi tio , me la presto para aprender a programar soy Ivette ,espero se unan mas mujeres al curso


class VidaJugador{
    var totalVida: Int = 0{
        willSet(nuevaVida){
            print("La vida del jugador valdra  \(nuevaVida)")
        }
        didSet{
            if totalVida >= 0 && totalVida <= 100 {
                print("la vida del jugador  subio a \(totalVida - oldValue) ")
                
            }
             else if totalVida > 100 {
                    print("La vida del jugador solo puede valer hasta 100 ")
                } else {
                print("Game over no te quedan vidas ")
            }
            
        }
    }
}
let vidaJugador = VidaJugador()
vidaJugador.totalVida = 10
vidaJugador.totalVida = 50
vidaJugador.totalVida = -1
vidaJugador.totalVida = 120

estoy super contento reto :


class VidaDeJugador {
    var vidaJugador: Int = 0 {
        //willsert
        willSet (newVidaJugador){
            if newVidaJugador >= 100{
                print("llegaste a la vida máxima")
            }else if newVidaJugador == 0 {
                print("Perdiste ya no tienes vida")
            }
        }
        didSet {
            if vidaJugador < 100 {
                print("perdiste vida  \(oldValue - vidaJugador) vida actual \(vidaJugador)")
            }
        }
    }
}

let player = VidaDeJugador()

player.vidaJugador = 100
player.vidaJugador = 65

player.vidaJugador = 0

Muy similar a los triggers en db

RETO!
Me divertí haciendo esto 😄

class Player{
  var life: Int = 30{
    willSet(newLife){
      print("Vida cambiara a: \(newLife)hp")
    }
    didSet{
      if life > 100{
        let minusLife = life - oldValue
        life -= minusLife
        print("La vida no puede subir mas de 100 \nVida actual: \(life)hp")
      }else if life > oldValue{
        print("Vida incrementada \nVida actual: \(life)hp")
      }else{
        print("Recibiste un ataque! Cubrete! \nVida actual: \(life)hp")
      }
    }
  }
}
//Pruebas
let attack = Player()
attack.life += 70
print(attack.life)

Mi aporte

import Foundation

class Jugador {
  var vida: Int = 100 {
    willSet(newVida){
      switch newVida {
        case 1...100:
              vida > newVida ? print("Daño obtenido \(vida - newVida)") : print("Vida obtenida \(newVida - vida)")
        case ...0:
              print("Has perdido.")
        default: 
            self.vida=100
      }
    }
    didSet{
      switch vida {
        case 50...100:
              print("Tienes bastante vida \(vida)")
        case 1...50:
              print("Te queda poca vida \(vida)")
        default: 
            self.vida=100
      }
    }
  }
}

let player = Jugador()

player.vida -= 20
player.vida += 40
player.vida += 200
player.vida -= 70
player.vida -= 100
class MarioMario {
    var numberOfLives: Int = 3 {
        didSet {
            switch numberOfLives {
            case ...0:
                print("Game Over! Better luck next time!")
            case 101...:
                print("No one is invincible!")
                numberOfLives = 100
            default:
                print("You can continue gaming")
            }
        }
    }
}

let marioMario = MarioMario()
marioMario.numberOfLives -= 3
marioMario.numberOfLives += 10
marioMario.numberOfLives = 105
marioMario.numberOfLives
class VidaJugador{
    var totalVida: Int = 0 {
        willSet(NewTotalVida){
            print("El numero de total de vida es: \(NewTotalVida)")
        }
        didSet{
            if totalVida < 0 {
                print("Game Over")
            }
            else if totalVida > 100 {
                print("El maximo valor es 100")
                totalVida = 0
            }
        }
    }
}
let vida = VidaJugador()
vida.totalVida = 80
vida.totalVida = 101
vida.totalVida = -6
vida.totalVida = 0 
class Personaje {
    var vida : Int=50 {
        willSet(nuevaVida){
            print("hp:\(vida)")
        }didSet{
            if vida>oldValue{
                    print("hp:\(vida) xd")
            }else if vida<oldValue {
                    print("dead")
            }
    }
}
}
let chief = Personaje()
chief.vida = 100
chief.vida = 10
chief.vida = 0

No es mucho, pero es un trabajo honesto. 🥺😅🤪

class LivesPlayer{
    var totalLives: Int = 0{
        willSet(changeInLives){
            if changeInLives <= 0{
                print("El número de vidas va a disminuir en \(changeInLives)")
            } else{
                print("El número de vidas va a aumentar en \(changeInLives)")
            }
        }
        didSet{
            //Una vez que ha cambiado su valor, se ejecuta esta parte y mandamos el aviso
            totalLives += oldValue
            if totalLives <= 0{
                print("El juego ha terminado! Game Over! 😢")
            }else if totalLives > 0 && totalLives <= 100{
                print("La nueva cantidad de vidas disponibles es \(totalLives)")
            }else if totalLives > 100{
                totalLives = 100
                print("La nueva cantidad de vidas disponibles es \(totalLives)")
            }
        }
    }
}
//reto

class player{
    var lifePoints: Int = 100{
        willSet(changeLivePoints){
            print("Life Points + \(changeLivePoints)")
        }
        didSet{
            if lifePoints < 0{
                print("Game Over")
            }
            if lifePoints > 100 {
                print("Maximum Life Points are 100")
                lifePoints = 100
            }
        }
    }
}
let player1 = player()

player1.lifePoints += 500
player1.lifePoints -= 6
class LifePlayer
{
    var stringGameOver = "GAME OVER"
    
    var plusLifes : Int8 = 0
    {
        willSet(newLifes)
        {
            if newLifes > 100
            {
                lifes = 100
                print("El numero maximo de vidas solo puede ser 100")
            }
            else if newLifes <= 100
            {
                lifes += newLifes
                print("Se han agregado \(newLifes)")
            }
        }
    }
    
    var lifes : Int8 = 5
    {
        
        didSet
        {
            if lifes <= 0
            {
                print(stringGameOver)
            }
            else if lifes > 100
            {
            print("El jugador solo puede tener como maximo 100 vidas")
            lifes = 100
            }
        }
    }
    
}
class LifeGamer {

    var life: Int = 100
    var pointLife: Int = 0{
        willSet(newLife){
            life = life + newLife
        }didSet{
            if life > 100 {
                life = 100
                print("La vida no puede ser mayor a 100")
            }else if life <= 0{
               print("<<<GAME OVER>>>")
            }else{
                print("Puntos de vida Actuales: \(life)")
            }
        }
    }
}


let lifeGamer = LifeGamer()
lifeGamer.pointLife = -40
lifeGamer.pointLife = -20
lifeGamer.pointLife = 50
lifeGamer.pointLife = 15
lifeGamer.pointLife = -50
lifeGamer.pointLife = -55
class HeroLife {
    
    var life: Double = 10.00 {
        willSet(currentLife){
            if currentLife <= 0 {
                print("GAME OVER!!! good luck the next time")
            }else if currentLife <= 100 {
                print("Your health is good!!! Go back and finish the game")
            }
        }
        didSet {
            if life > 100 {
                print("Your health is full you don't need medical attention")
                life = 100
            } else if life <= 0 {
                print("GAME OVER!!! good luck the next time")
                life = 100
            }
        }
    }
}

let heroHealth = HeroLife()

heroHealth.life = 80
heroHealth.life = 50
heroHealth.life = -80
// Reto
class Life{
    var lifeValue: Int = 100{
        willSet(newLifeValue){
            if newLifeValue <= 0{
                print("Game Over, el valor de tu vida es: 0%")
            }else if newLifeValue <= 100{
                print("Continua el juego, el valor de tu vida es: \(newLifeValue)%")
            }
        }
        didSet{
            if lifeValue > 100{
                lifeValue = 100
                print("Tu vida se a renovado al \(lifeValue)%")
            }
        }
    }
}

let newGame = Life()
newGame.lifeValue = 20
newGame.lifeValue = 1200
newGame.lifeValue = -1
newGame.lifeValue = 300

El mejor profesor y los mejores ejercicios!

class Player {
    var hp: Int16 = 100 {
        willSet {
            if newValue > hp {
                print("Te has curado.")
            } else {
                print("Te has hecho daño.")
            }
        }
        didSet {
            if oldValue > hp {
                print("Has perdido \(oldValue - hp) HP.")
            } else {
                if hp > 100 {
                    hp = 100
                }
                print("Has recuperado \(hp - oldValue) HP.")
            }
            if hp > 0 {
                print("Ahora tienes \(hp) HP.")

            } else {
                print("Game over")
            }
        }
    }
}```
class Health {
    var health: Int = 100 {
        willSet(newHealth) {
            if newHealth <= 0 {
                print("Game Over!!")
            } else if newHealth >= 100 {
                print("Salud al máximo !!")
            } else {
                print("El juego continúa, salud = \(newHealth)")
            }
            
        }
        didSet{
            if health < 0 {
                health = 0
            } else if health > 100 {
                health = 100
            }
        }
    }
}

let gameHealth = Health()
gameHealth.health = 50
gameHealth.health = 105
gameHealth.health = -1
class LifePlayer{
    var health: Int = 100{
        willSet(newHealth){
            if newHealth >= 0 && newHealth <= 100{
                print("Ahora solo tienes \(newHealth)")
            }
        }
        didSet{
            if health <= 100 && health >= 0{
                if health > oldValue{
                    print("recarga de vida")
                }else {
                    print("Tu vida disminuyó")
                }
            }else if health <= 0{
                print("GameOver")
            }
        }
    }
}

var juanitoLife = LifePlayer()

juanitoLife.health

//juanitoLife.health = -20
juanitoLife.health = 80
juanitoLife.health = 10
class LifeOfSomeone {
    var life: Int = 100 {
        //willset es llamado justo antes de que la variable se guarde
        willSet(newValue){
            print("Tu nivel de vida es de \(newValue)")
        }
        //didSet es llamado justo despues de que la variable se guardo
        didSet{
            let max: Int = 100
            if life > max {
                print("No se puede tener un nivel de vida mayor a \(max)")
            } else if life < 0 {
                print("GAME OVER")
            } else {
                print("Tu nivel de vida paso de ser \(oldValue) a \(life)")
            }
        }
    }
}

let vidaVesino = LifeOfSomeone()
/*
 Aqui cambiar la vida (life) de vidaVesino
 vidaVesino.life -= 5
 
 Imprime dos lineas la primera del willSet: Tu nivel de vida es de 95.
 La segunda linea imprime el didSet: Tu nivel de vida paso de ser 100 a 95
 */
class Game
{
    var life: Int = 100{
        willSet(newLifeStatus)
        {
            if newLifeStatus > 100
            {
                print("El porcentaje de vida no puede ser mayor a 100")
            }
        }
        didSet
        {
            if life <= 0
            {
                print("Juego terminado!")
            }
        }
    }
}

let myGame = Game()
myGame.life = 101
myGame.life = 78
myGame.life = 0
myGame.life = -11