विंडोइंग सिस्टम

struct CharacterStats {
  var health = 0.0
  var speed = 0
  var strength = 0
}

class GameCharacter {
  var stats = CharacterStats()
  var characterClass: String?
  var name: String?
  var active = false
  let id = makeRandomID()
}

let someStats = CharacterStats()
let someCharacter = GameCharacter()

let differentStats = CharacterStats(health: 100.0, speed: 6, strength: 18)

someStats.health
// => 0
someCharacter.name
// => nil

someStats.health = 87.3
someStats.health
// => 87.3
someCharacter.name = "Luther"
someCharacter.name
// => "Luther"

someCharacter.id  = "new id"
// Error: Cannot assign to property: 'id' is a 'let' constant

struct CharacterStats {
  var health = 0.0
  var speed = 0
  var strength = 0

  mutating func takeHit(_ damage: Double) {
    health = max(0.0, health - damage)
  }
  func canLift(_ weight: Int) -> Bool {
    weight < strength * 100
  }
}

class GameCharacter {
  var stats = CharacterStats()
  var characterClass: String?
  var name: String?
  var active = false
  let id: String = makeRandomID()

  func takesDamage(_ damage: Double) {
    stats.takeHit(damage)
    if stats.health <= 0 {
      active = false
    }
  }
  func sayName() -> String {
    return "My name is \(name ?? "no one"), my class is \(characterClass ?? "undetermined")"
  }
  func lift(_ weight: Int) -> String {
    if stats.canLift(weight) {
      return "No problem!"
    } else {
      return "Ooof! No way."
    }
  }
}

var myChar = GameCharacter()
myChar.stats = CharacterStats(health: 72.8, speed: 19, strength: 6)
myChar.active = true

myChar.lift(750)
// => "Ooof! No way."
myChar.takesDamage(80)
myChar.active
// => false

struct Position {
    var x = 0

    mutating func move(x: Int) {
        // Here, 'self.x' refers to the struct's property,
        // while 'x' refers to the parameter passed to the method.
        self.x = x
    }
}

निर्देश

इस अभ्यास में आप एक ऐसे कंप्यूटर सिस्टम की नकल करेंगे जो विंडो पर आधारित है। आप कुछ विंडो बनाएँगे जिन्हें हिलाया जा सकता है, जिनका साइज़ बदला जा सकता है, और जो अपनी सामग्री दिखाती हैं। नीचे दी गई तस्वीर उन वैल्यू को दर्शाती है जिनके साथ आप काम करेंगे।

                  <--------------------- screenSize.width --------------------->

       ^          ╔════════════════════════════════════════════════════════════╗
       |          ║                                                            ║
       |          ║          position.x,_                                      ║
       |          ║          position.y  \                                     ║
       |          ║                       \<----- size.width ----->            ║
       |          ║                 ^      *──────────────────────┐            ║
       |          ║                 |      │        title         │            ║
       |          ║                 |      ├──────────────────────┤            ║
screenSize.height ║                 |      │                      │            ║
       |          ║            size.height │                      │            ║
       |          ║                 |      │       contents       │            ║
       |          ║                 |      │                      │            ║
       |          ║                 |      │                      │            ║
       |          ║                 v      └──────────────────────┘            ║
       |          ║                                                            ║
       |          ║                                                            ║
       v          ╚════════════════════════════════════════════════════════════╝

1. एक Size स्ट्रक्ट बनाइए

Size नाम का एक स्ट्रक्ट बनाइए जिसमें Int टाइप की दो प्रॉपर्टी हों, width और height, जो विंडो की मौजूदा चौड़ाई और ऊँचाई रखती हैं। शुरुआती चौड़ाई और ऊँचाई क्रमशः 80 और 60 होनी चाहिए। इसमें एक resize(newWidth:newHeight:) मेथड भी रखिए जो नई चौड़ाई और ऊँचाई के पैरामीटर लेता है और नए साइज़ के अनुसार प्रॉपर्टी बदल देता है।

let size1080x764 = Size(width: 1080, height: 764)
// Returns Size
var size1200x800 = size1080x764
// Returns Size
size1200x800.resize(newWidth: 1200, newHeight: 800)
size1200x800.height
// Returns 800

2. एक Position स्ट्रक्ट बनाइए

Position नाम का एक स्ट्रक्ट बनाइए जिसमें Int टाइप की दो प्रॉपर्टी हों, x और y, जो विंडो के ऊपरी बाएँ कोने की मौजूदा आड़ी और खड़ी स्थिति रखती हैं। x और y की शुरुआती वैल्यू 0 होनी चाहिए। स्थिति (0, 0) स्क्रीन का ऊपरी बाएँ कोना है। जैसे-जैसे आप दाएँ जाते हैं, x की वैल्यू बढ़ती जाती हैं, और जैसे-जैसे आप नीचे जाते हैं, y की वैल्यू बढ़ती जाती हैं।

इसमें एक moveTo(newX:newY:) मेथड भी रखिए जो नए x और y पैरामीटर लेता है और नई स्थिति के अनुसार प्रॉपर्टी बदल देता है।

var point = Position(x: 10, y: 20)
// Returns Position
point.moveTo(newX: 100, newY: -100)
point.y
// Returns -100

3. एक Window क्लास बनाइए

एक विंडो क्लास बनाइए जिसमें ये प्रॉपर्टी हों:

• title : String, शुरुआती वैल्यू "New Window" है
• screenSize : Size, स्थिर वैल्यू, जिसमें width = 800 और height = 600
• size : Size, शुरुआती वैल्यू Size स्ट्रक्ट की डिफॉल्ट वैल्यू है
• position : Position, शुरुआती वैल्यू Position स्ट्रक्ट की डिफॉल्ट वैल्यू है
• contents : String?, शुरुआती वैल्यू nil है

आपको इस क्लास के लिए एक खाली इनिशियलाइज़र भी बनाना चाहिए।

let window = Window()
window.title
// Returns "New Window"

4. विंडो का साइज़ बदलने वाला मेथड जोड़िए

• resize(to:) : (Size) -> () - यह मेथड इनपुट में एक Size स्ट्रक्ट लेता है और विंडो का साइज़ बताए गए साइज़ तक बदलने की कोशिश करता है। लेकिन नया साइज़ कुछ सीमाओं से बड़ा नहीं हो सकता।
• ऊँचाई या चौड़ाई की सबसे छोटी अनुमत वैल्यू 1 है। 1 से कम माँगी गई ऊँचाई या चौड़ाई को 1 तक सीमित कर दिया जाएगा।
• सबसे बड़ी ऊँचाई और चौड़ाई विंडो की मौजूदा स्थिति पर निर्भर करती है, क्योंकि विंडो के किनारे स्क्रीन के किनारों से आगे नहीं जा सकते। इन सीमाओं से बड़ी वैल्यू को उतने ही बड़े साइज़ तक सीमित कर दिया जाएगा जितना वे ले सकती हैं। जैसे, अगर विंडो की स्थिति x = 400, y = 300 पर है और height = 400, width = 300 का साइज़ माँगा जाता है, तो विंडो का साइज़ height = 300, width = 300 कर दिया जाएगा, क्योंकि y दिशा में स्क्रीन इतनी बड़ी नहीं है कि वह इस माँग को पूरी तरह पूरा कर सके।

5. विंडो हिलाने वाला मेथड जोड़िए

• move(to:) : (Position) -> () - यह resize(to:) जैसा ही है, लेकिन यह मेथड साइज़ के बजाय विंडो की स्थिति को माँगी गई वैल्यू पर बदल देता है। resize की तरह यहाँ भी नई स्थिति कुछ सीमाओं से आगे नहीं जा सकती।
• x और y दोनों के लिए सबसे छोटी स्थिति 0 है।
• किसी भी दिशा में सबसे बड़ी स्थिति विंडो के मौजूदा साइज़ पर निर्भर करती है; किनारे स्क्रीन के किनारों से आगे नहीं जा सकते। इन सीमाओं से बड़ी वैल्यू को उतने ही बड़े साइज़ तक सीमित कर दिया जाएगा जितना वे ले सकती हैं। जैसे, अगर विंडो का साइज़ x = 250, y = 100 पर है और x = 600, y = 200 पर जाने की माँग की जाती है, तो विंडो को x = 550, y = 200 पर ले जाया जाएगा, क्योंकि x दिशा में स्क्रीन इतनी बड़ी नहीं है कि वह इस माँग को पूरी तरह पूरा कर सके।

6. विंडो का टेक्स्ट बदलने और विंडो की जानकारी दिखाने वाले मेथड जोड़िए

• update(title:) : (String) -> () - यह मेथड title प्रॉपर्टी को उस स्ट्रिंग की वैल्यू पर सेट कर देता है जो पास की गई थी।
• update(text:) : (String?) -> () - यह मेथड contents प्रॉपर्टी को उस ऑप्शनल स्ट्रिंग की वैल्यू पर सेट कर देता है जो पास की गई थी।
• display() : () -> String - यह मेथड एक स्ट्रिंग लौटाता है जो बताती है कि विंडो में इस समय क्या-क्या है। जैसे, अगर विंडो का title "My First Window" है, position: x = 10, y = 100; size: width = 200, height = 150; और contents: "I 😍 my window" है, तो उसे यह स्ट्रिंग लौटानी चाहिए: "My First Window\nPosition: (10, 100), Size: (200 x 150)\nI 😍 my window\n" - अगर contents nil है, तो आखिरी लाइन "[This window intentionally left blank]" होनी चाहिए

7. Window क्लास के लिए एक इनिशियलाइज़र बनाइए

विंडो सिस्टम में एक इनिशियलाइज़र होना चाहिए ताकि विंडो को अपने इनपुट के साथ बनाया जा सके। Window क्लास के लिए एक और इनिशियलाइज़र बनाइए। इस इनिशियलाइज़र को ये पैरामीटर लेने चाहिए: title, contents, और दो ऑप्शनल पैरामीटर size और position। size और position पैरामीटर की डिफॉल्ट वैल्यू Size और Position स्ट्रक्ट की डिफॉल्ट वैल्यू होनी चाहिए।

let window = Window(title: "My First Window", contents: "I 😍 my window")
window.display()
// Returns "My First Window\nPosition: (0, 0), Size: (80 x 60)\nI 😍 my window\n"

let window2 = Window(title: "My Second Window", contents: "I 😍 my window", size: Size(width: 200, height: 150), position: Position(x: 10, y: 100))
window2.display()
// Returns "My Second Window\nPosition: (10, 100), Size: (200 x 150)\nI 😍 my window\n"