🎲 रेट्रो गेम: संख्या का अनुमान लगाएं (स्तरों, स्कोर और कस्टम आइकन के साथ)

🔧 आवश्यक घटक

• Arduino बोर्ड (उदाहरणार्थ, ऊनो, R4)
• I2C एलसीडी 1602 डिस्प्ले (I2C पता आमतौर पर 0x27)
• पुश बटन (गेम को रीसेट करने/आगे बढ़ाने के लिए)
• जम्पर तार और ब्रेडबोर्ड
• कंप्यूटर (सीरियल मॉनिटर इनपुट के लिए)

📌 वायरिंग कनेक्शन

1. I2C एलसीडी 1602 डिस्प्ले

• VCC: → आर्डुइनो 5V
• GND: → आर्डुइनो GND
• एसडीए: → आर्डुइनो A4 (यूनो) या संबंधित एसडीए pin
• एससीएल: → आर्डुइनो A5 (यूनो) या संबंधित एससीएल pin

2. रीसेट/एडवांस बटन

• एक टर्मिनल: → आर्डुइनो डिजिटल Pin 4
• अन्य टर्मिनल: → GND
• नोट: आंतरिक पुल-अप प्रतिरोधक का उपयोग करके इसे सेट करें pin के लिए मोड इनपुट_पुलअप कोड में

💻 कोड उदाहरण

नीचे पूरा स्केच दिया गया है जो अतिरिक्त सुविधाओं के साथ गेम को लागू करता है। इस कोड में:

• RSI गुप्त संख्या एक सीमा के भीतर उत्पन्न होता है जो प्रत्येक स्तर के साथ बढ़ता है (स्तर 1: 1-100, स्तर 2: 1-200, आदि)।
• स्कोर कीping अनुमानों की संख्या पर नज़र रखता है.
• A कस्टम स्माइली चेहरा (एक कस्टम एलसीडी कैरेक्टर के रूप में बनाया गया) खिलाड़ी के जीतने पर प्रदर्शित होता है।
• रीसेट बटन दबाने से गेम तुरंत पुनः प्रारंभ हो जाता है।

#include <LiquidCrystal_I2C.h>

// ----- LCD Settings -----
LiquidCrystal_I2C lcd(0x27, 16, 2); // I2C address 0x27, 16 columns x 2 rows

// ----- Game Variables -----
int secretNumber;
bool gameOver = false;
int guessCount = 0;
int level = 1; // Starting level

// ----- Reset/Advance Button Pin -----
const int resetButtonPin = 4;

// ----- Custom Character: Smiley Face -----
byte smiley[8] = {
  B00000,
  B01010,
  B01010,
  B00000,
  B10001,
  B01110,
  B00000,
  B00000
};

void setup() {
  Serial.begin(9600);
  lcd.init();
  lcd.backlight();
  
  // Set up reset button with internal pull-up resistor
  pinMode(resetButtonPin, INPUT_PULLUP);
  
  // Create custom smiley face character at slot 0
  lcd.createChar(0, smiley);
  
  // Seed the random generator using an unconnected analog pin
  randomSeed(analogRead(0));
  
  // Start the first game
  startNewGame();
}

void loop() {
  // ----- Check Reset/Advance Button -----
  if (digitalRead(resetButtonPin) == LOW) {
    // Wait until the button is released to avoid multiple triggers
    while (digitalRead(resetButtonPin) == LOW) { delay(10); }
    startNewGame();
    delay(500); // Debounce delay
  }
  
  // ----- Process Serial Input for Guesses -----
  if (Serial.available() > 0 && !gameOver) {
    int guess = Serial.parseInt();
    if (guess == 0) return; // Skip invalid input
    
    guessCount++; // Increase guess count
    
    lcd.clear();
    
    if (guess < secretNumber) {
      lcd.setCursor(0, 0);
      lcd.print("Too Low!");
      Serial.println("Too low! Try again:");
    } 
    else if (guess > secretNumber) {
      lcd.setCursor(0, 0);
      lcd.print("Too High!");
      Serial.println("Too high! Try again:");
    } 
    else {
      // Correct guess!
      lcd.setCursor(0, 0);
      lcd.print("Correct!");
      lcd.setCursor(0, 1);
      lcd.print("Guesses: ");
      lcd.print(guessCount);
      lcd.write(byte(0)); // Display custom smiley
      Serial.println("Correct! You win!");
      gameOver = true;
      
      // Increase level for the next game
      level++;
      
      // Wait a moment before starting a new game
      delay(3000);
      startNewGame();
    }
    
    delay(1500); // Short delay for user to see feedback
    
    // If the game isn't over, re-prompt on the LCD
    if (!gameOver) {
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Level ");
      lcd.print(level);
      lcd.print(" Guess?");
      Serial.println("Enter your next guess:");
    }
  }
}

void startNewGame() {
  gameOver = false;
  guessCount = 0;
  // Generate a new secret number between 1 and (level * 100)
  secretNumber = random(1, level * 100 + 1);
  
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Level ");
  lcd.print(level);
  lcd.setCursor(0, 1);
  lcd.print("1-");
  lcd.print(level * 100);
  
  Serial.print("New game started! Level ");
  Serial.print(level);
  Serial.print(": Guess a number between 1 and ");
  Serial.println(level * 100);
}

📋 यह कैसे काम करता है

• खेल आरंभीकरण:
  RSI startNewGame() फ़ंक्शन गेम स्थिति को रीसेट करता है: यह वर्तमान स्तर के आधार पर एक नया गुप्त नंबर उत्पन्न करता है, अनुमान काउंटर को रीसेट करता है, और एलसीडी पर स्तर और संख्या सीमा प्रदर्शित करता है।
• स्कोर कीping:
  हर वैध अनुमान से मूल्य बढ़ता है guessCountजब आप सही अनुमान लगाते हैं, तो अनुमानों की संख्या एक स्माइली चेहरे के आइकन के साथ एलसीडी पर दिखाई जाती है।
• एकाधिक स्तर:
  सही अनुमान लगाने पर, खेल स्वचालित रूप से अधिकतम संभव गुप्त संख्या सीमा को बढ़ाकर अगले स्तर पर पहुंच जाता है (स्तर 1: 1-100, स्तर 2: 1-200, आदि)।
• रीसेट बटन:
  पुश बटन (इससे जुड़ा हुआ) दबाने पर pin 4) तुरंत रीसेट हो जाएगा और एक नया गेम शुरू हो जाएगा, जिससे आप किसी भी समय पुनः आरंभ कर सकेंगे।
• उपयोगकर्ता का निवेश:
  सीरियल मॉनिटर का उपयोग आपके अनुमानों को दर्ज करने के लिए किया जाता है, और फीडबैक ("बहुत कम!" या "बहुत अधिक!") एलसीडी और सीरियल मॉनिटर दोनों पर प्रदर्शित किया जाता है।
• कस्टम वर्ण:
  जब आप जीतते हैं तो एक कस्टम स्माइली फेस कैरेक्टर परिभाषित और प्रदर्शित किया जाता है।

🎯 समापन

इस उन्नत रेट्रो गेम परियोजना में अब निम्नलिखित शामिल हैं:

• रीसेट बटन: किसी भी समय खेल को पुनः आरंभ करें.
• स्कोर कीping: इस बात पर नज़र रखें कि आपने कितने अनुमान लगाए हैं।
• एकाधिक स्तर: जैसे-जैसे आप जीतते जाएं, कठिनाई बढ़ती जाए।
• कस्टम चिह्न: जब आप जीतें तो एक मज़ेदार स्माइली चेहरे का आनंद लें!

प्रोजेक्ट को और अधिक समायोजित या विस्तारित करने के लिए स्वतंत्र महसूस करें, जैसे कि अधिक गेम स्तर जोड़ना या अतिरिक्त सुविधाएँ एकीकृत करना। अपने रेट्रो गेम कोडिंग का आनंद लें! 😊👍