Crossword Word Building Game (Advanced)

[Pankaj-Str]

Problem Statement

Design and implement a Crossword Word Building Game in Python. The game involves answering a general knowledge question, building a word character by character, and creating new words based on specific rules. The game continues in rounds until the user exits, with a scoring system and validation to ensure rules are followed.

---

Assignment Requirements

1. Question & Answer Input

   • Display a general knowledge question (e.g., "What is the national animal of India?").
   • Prompt the user to specify the maximum character length of the answer.
   • Collect the answer character by character, ensuring it matches the specified length.
   • Display the complete answer and validate it against the correct answer.
   • End the game with the correct answer if the user’s answer is incorrect.

2. Character Selection

   • Prompt the user to select one character from the current word (initially the answer, later the new word).
   • Validate that the chosen character is a single character present in the current word.

3. Word Creation Rules

   • The user must form a new word that:
     • Contains the selected character.
     • Includes at least one character not in the previous word.
     • Is at least as long as the previous word.
   • Example: If the previous word is "TIGER" (5 letters) and the chosen character is "I", a valid new word is "INJECTION" (contains "I", has new characters, ≥ 5 letters), but "INK" is invalid (too short).

4. Validation Logic

   • Validate new words to ensure they meet all rules.
   • Display error messages for invalid words (e.g., missing chosen character, too short, no new characters) and prompt for retry.
   • Prevent duplicate words (words already used in the game).

5. Scoring System

   • Award points for valid words:
     • Base points for a valid word.
     • Bonus points if the new word is at least 2 characters longer than the previous word.
   • Display the running score after each valid word.

6. Game Continuation

   • After each valid word, ask the user to continue or exit.
   • If continuing, prompt for a new character from the latest word and form a new word.
   • On exit, display:
     • List of all words used.
     • Final score.

7. Bonus Requirement

   • Store used words in a list and prevent duplicates.
   • Display the list of used words at the end.

---

Input/Output Example

Welcome to the Crossword Word Building Game!
Q: What is the national animal of India?
Enter the maximum character length of the answer: 5
Enter the answer character by character (max 5 characters):
Character 1: T
Character 2: I
Character 3: G
Character 4: E
Character 5: R
Answer → TIGER

Choose a character from 'TIGER': I
Make a new word using 'I': Injection
✅ Valid! Score updated.
Total Score = 7

Do you want to continue? (yes/no): yes

Choose a character from 'INJECTION': N
Make a new word using 'N': Nation
✅ Valid! Score updated.
Total Score = 12

Do you want to continue? (yes/no): yes

Choose a character from 'NATION': A
Make a new word using 'A': Ant
❌ Error: New word must be at least 6 characters long.
Try again: Another
✅ Valid! Score updated.
Total Score = 17

Do you want to continue? (yes/no): no

Game Over.
Words used: ['TIGER', 'INJECTION', 'NATION', 'ANOTHER']
Final Score = 17

---

Assignment Tasks

1. Implementation
   Write a Python program implementing the full game logic. Handle user inputs robustly (e.g., invalid characters, incorrect answer lengths).

2. Scoring System
   Implement the scoring system with base and bonus points. Display the score after each valid word.

3. Validation Logic
   Validate words to reject invalid entries with clear error messages and retry prompts.

4. Bonus: Duplicate Prevention
   Store used words in a list to prevent duplicates and display the list at the end.

---

Notes

• Include at least 4 predefined general knowledge questions and answers for testing.
• Treat inputs as case-insensitive (e.g., "Tiger" and "TIGER" are the same).
• Handle invalid inputs gracefully (e.g., non-single characters, invalid words).
• Assume words are valid English words without requiring a dictionary check.

---

.

[TheAdityaKashyap]

score = 0
word_used = []

print(f"Welcome to the Crossword Word Building Game!")
print(f"Q: What is the national animal of India?")
max_len = int(input("Enter the max charchter lenghth of the anwer"))

answer = ""
for i in range(max_len):
    ch = input(f"Character {i + 1}: ").upper()
    answer += ch
    
print(f"Answer : {answer}")
word_used.append(answer)
score += len(answer)


while True:
    print(f"Choose a leeter from {word_used[-1]}: ")
    ch = input().upper()
    
    new_word = input(f"Make  a new Word {ch}: ").capitalize()
    
    if len(new_word) < 6:
        print(f"Error: nw word must bee of 6 letter")
        new_word = input(f"Try agan: ").capitalize()
        
    print(f"Valid  score update")
    score += len(new_word)
    word_used.append(new_word)
    print(f"Total Score: {score}")
    
    cont = input(f"DO you want to continue: ").lower()
    if cont != 'yes':
        break
    

print(f"Game Over")
print(f"Word Used : {word_used}")
print(f"Final Score: {score}")

[DeveshPatill]

import sys
import json
import random
import os

# ==========================
# CONFIGURATION
# ==========================
SAVE_FILE = "crossword_game_session.json"
ALPHA_ONLY = True
BASE_POINTS = 2         # base points per valid word
LENGTH_MULTIPLIER = 1   # +1 point per letter
BONUS_POINTS = 5        # if new_word_len >= prev_len + 2
QUESTIONS = {
    "What is the national animal of India?": "TIGER",
    "What is the capital of France?": "PARIS",
    "What planet is known as the Red Planet?": "MARS",
    "Which is the largest ocean on Earth?": "PACIFIC",
    "What gas do plants absorb from the atmosphere?": "CARBON",
    "What is the fastest land animal?": "CHEETAH",
    "Which element has the chemical symbol 'O'?": "OXYGEN",
}

# ==========================
# HELPER FUNCTIONS
# ==========================
def input_nonempty(prompt):
    while True:
        s = input(prompt).strip()
        if s:
            return s

def collect_answer_by_chars(max_len):
    """Collect answer character by character."""
    chars = []
    print(f"Enter the answer character by character (max {max_len} characters):")
    for i in range(1, max_len + 1):
        while True:
            c = input(f"Character {i}: ").strip()
            if len(c) == 1:
                if ALPHA_ONLY and not c.isalpha():
                    print("Please enter an alphabetic character.")
                    continue
                chars.append(c.upper())
                break
            else:
                print("Please enter exactly one character.")
    answer = "".join(chars)
    print(f"Answer → {answer}")
    return answer

def is_valid_new_word(new_word, chosen_char, prev_word, used_set):
    """Check all rule validations for new word."""
    if not new_word:
        return False, "Empty word."
    nw = new_word.upper().strip()
    if ALPHA_ONLY and not nw.isalpha():
        return False, "Word must contain only alphabetic characters."
    if chosen_char.upper() not in nw:
        return False, f"New word must contain '{chosen_char.upper()}'."
    if len(nw) < len(prev_word):
        return False, f"New word must be at least {len(prev_word)} characters long."
    prev_set, new_set = set(prev_word.upper()), set(nw)
    if not (new_set - prev_set):
        return False, "Must include at least one new character."
    if nw in used_set:
        return False, "Word already used. Try a new one."
    return True, None

def calculate_points(new_word, prev_word):
    """Dynamic scoring based on length and bonus."""
    base = BASE_POINTS + (len(new_word) * LENGTH_MULTIPLIER)
    bonus = BONUS_POINTS if len(new_word) >= len(prev_word) + 2 else 0
    return base + bonus, bonus > 0

def save_session(used_words, score, current_word, question, correct_answer):
    """Save game progress to file."""
    session_data = {
        "used_words": used_words,
        "score": score,
        "current_word": current_word,
        "question": question,
        "correct_answer": correct_answer,
    }
    with open(SAVE_FILE, "w") as f:
        json.dump(session_data, f, indent=2)
    print(" Game progress saved successfully!\n")

def load_session():
    """Load saved game if available."""
    if os.path.exists(SAVE_FILE):
        try:
            with open(SAVE_FILE, "r") as f:
                data = json.load(f)
            print(" Loaded saved game progress!\n")
            return data
        except Exception:
            print(" Could not load save file. Starting fresh.\n")
    return None

# ==========================
# GAME LOGIC
# ==========================
def play_round(prev_word, used_words, score):
    print()
    while True:
        chosen = input_nonempty(f"Choose a character from '{prev_word}': ").strip().upper()
        if len(chosen) != 1:
            print("Please choose exactly one character.")
            continue
        if chosen not in prev_word.upper():
            print(f"'{chosen}' not in '{prev_word}'. Try again.")
            continue
        break

    while True:
        new_word_in = input_nonempty(f"Make a new word using '{chosen}': ")
        valid, err = is_valid_new_word(new_word_in, chosen, prev_word, set(used_words))
        if valid:
            new_word = new_word_in.upper().strip()
            used_words.append(new_word)
            points, bonus = calculate_points(new_word, prev_word)
            score += points
            print(f" Valid! +{points} points {'(Bonus!)' if bonus else ''}")
            print(f"Total Score = {score}")
            save_session(used_words, score, new_word, None, None)
            return new_word, score
        else:
            print(f" Error: {err}")

# ==========================
# MAIN FUNCTION
# ==========================
def main():
    print(" Welcome to the Crossword Word Building Game (Advanced+)\n")

    # Load previous game if available
    session = load_session()
    if session:
        used_words = session["used_words"]
        score = session["score"]
        current_word = session["current_word"]
        question = session["question"]
        correct_answer = session["correct_answer"]
        print(f"Resuming from last word: {current_word} | Score: {score}")
        resume = input_nonempty("Continue previous game? (yes/no): ").strip().lower()
        if resume in ("no", "n"):
            session = None
            print("\nStarting a new game.\n")

    if not session:
        # Random question
        question, correct_answer = random.choice(list(QUESTIONS.items()))
        print(f"Q: {question}")
        while True:
            try:
                max_len_raw = input_nonempty("Enter the maximum character length of the answer: ")
                max_len = int(max_len_raw)
                if max_len <= 0:
                    print("Please enter a positive number.")
                    continue
                break
            except ValueError:
                print("Enter a valid integer.")

        user_answer = collect_answer_by_chars(max_len)

        if user_answer.upper() != correct_answer.upper():
            print("\n Incorrect answer. Game Over.")
            print(f" Correct Answer: {correct_answer}")
            print("\nGame Over.\nWords used: []\nFinal Score = 0")
            sys.exit(0)

        print("\n🎉 Correct! Let's start the word-building rounds.")
        used_words = [user_answer.upper()]
        score = 0
        current_word = user_answer.upper()

        save_session(used_words, score, current_word, question, correct_answer)

    # Gameplay loop
    while True:
        current_word, score = play_round(current_word, used_words, score)

        while True:
            cont = input_nonempty("Do you want to continue? (yes/no): ").strip().lower()
            if cont in ("yes", "y", "no", "n"):
                break
            print("Please answer 'yes' or 'no'.")
        if cont in ("no", "n"):
            break

    print("\n Game Over.")
    print(" Words used:", used_words)
    print(f" Final Score = {score}")

    # Save final state before exit
    save_session(used_words, score, current_word, question, correct_answer)

if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print("\n\n Exiting game. Goodbye!")
        sys.exit(0)