6. Handling User Input with Amazon Q CLI

While the game logic is written in Python, we’ll use the Amazon Q CLI to invoke the Python script. We are not directly using the Amazon Q CLI to handle user input within the Python script. The `input()` function in Python handles user input in this case. The Amazon Q CLI essentially acts as a launcher for our game.

Running the game using the Amazon Q CLI:

The key is to use the Amazon Q CLI to execute the shell script (or batch file on Windows) that runs the Python game. We’ll use `aws cloudshell invoke-lambda-function` or `aws ssm send-command` (if you want to use an instance) if you’re integrating with AWS. However for local usage, direct execution is much simpler:

1. If using the shell script: Open your terminal, navigate to your project directory, and execute the script:

   ./run_game.sh

2. If using the batch file (Windows): Open your command prompt, navigate to your project directory, and execute the batch file:

   run_game.bat

The Amazon Q CLI (in this case) is essentially a glorified command executor, letting the shell script handle execution of the Python script. The game itself interacts with the user using the standard `input()` and `print()` functions in Python.

Why this approach?

Directly using the Amazon Q CLI for interactive input is not its primary purpose. Its strength lies in managing AWS resources. This method allows us to leverage the CLI for its command-line interface while using Python for its simpler user interaction capabilities.

7. Building the Game Loop

The game loop is the heart of any interactive game. It handles the continuous cycle of: processing input, updating game state, and rendering output. In our simple text-based game, the game loop is managed within the `while` loop in the `play_number_guessing_game()` function in Python.

Components of the Game Loop:

1. Input Handling: The `input()` function prompts the player for input (their guess).
2. Game State Update: The game state is updated based on the player’s input. This includes:
   • Checking if the guess is correct.
   • Decrementing the number of attempts.
3. Output Rendering: The game state (feedback, remaining attempts) is displayed to the player using `print()`.
4. Loop Condition: The loop continues as long as the player has attempts remaining (`attempts_left > 0`).

Simplified Game Loop Diagram:

+---------------------+
|  Input (Player Guess) |
+---------------------+
       |
       V
+---------------------+
|  Update Game State  |
| (Check Guess,      |
| Decrement Attempts) |
+---------------------+
       |
       V
+---------------------+
| Output (Feedback,   |
| Attempts Remaining) |
+---------------------+
       |
       V
+---------------------+
|  Loop Condition     |
| (Attempts Left > 0) |
+---------------------+
       |
       Yes ------------> (Back to Input)
       |
       No -------------> Game Over

The `while` loop in our Python code effectively manages this cycle. The game continues until the player guesses correctly or runs out of attempts.

8. Displaying Game State

Displaying the game state involves presenting information to the player in a clear and understandable way. In our text-based game, this is primarily done using the `print()` function.

Elements of Game State Display:

1. Welcome Message: Introduces the game and explains the rules.
2. Attempts Remaining: Keeps the player informed of how many guesses they have left.
3. Feedback: Provides feedback on each guess (“Too high,” “Too low,” “Correct!”).
4. Game Over Message: Informs the player when they have lost or won the game.

Improving the Display:

While the current display is functional, we can improve it by:

• Adding Color: Use ANSI escape codes to add color to the text, making it more visually appealing. (Note: this might not work on all terminals).
• Clearing the Screen: Use `os.system(‘cls’ if os.name == ‘nt’ else ‘clear’)` to clear the screen before each guess, providing a cleaner interface.
• Adding Visual Separators: Use lines of characters (e.g., “—“) to separate different sections of the output.

Example with Color (Requires ANSI support in your terminal):

import random

def play_number_guessing_game():
    """Plays the number guessing game with color."""
    # ANSI color codes
    RED = "\033[91m"
    GREEN = "\033[92m"
    YELLOW = "\033[93m"
    RESET = "\033[0m" # Reset to default color

    secret_number = random.randint(1, 100)
    attempts_left = 7

    print(GREEN + "Welcome to the Number Guessing Game!" + RESET)
    print("I'm thinking of a number between 1 and 100.")

    while attempts_left > 0:
        print(f"You have {attempts_left} attempts remaining.")
        try:
            guess = int(input("Enter your guess: "))
        except ValueError:
            print(YELLOW + "Invalid input. Please enter a number." + RESET)
            continue

        if guess < secret_number:
            print(RED + "Too low." + RESET)
        elif guess > secret_number:
            print(RED + "Too high." + RESET)
        else:
            print(GREEN + f"Congratulations! You guessed the number {secret_number} in {7 - attempts_left + 1} attempts." + RESET)
            return

        attempts_left -= 1

    print(RED + f"You ran out of attempts. The number was {secret_number}." + RESET)

if __name__ == "__main__":
    play_number_guessing_game()

9. Optional: Integrating with AWS Services

This is where the Amazon Q CLI’s power can truly shine. We can integrate our game with various AWS services to add features like:

• Storing High Scores in DynamoDB: Use DynamoDB, a NoSQL database, to store player high scores persistently.
• Implementing a Leaderboard with DynamoDB and Lambda: Use a Lambda function to query DynamoDB and display a leaderboard of top players.
• Using SQS for Asynchronous Tasks: If the game involved more complex computations, you could offload those tasks to an SQS queue and have a separate process handle them asynchronously.
• Deploying the Game Logic as a Lambda Function: Potentially, you could package your Python code as a Lambda function and invoke it using the Amazon Q CLI. This is more complex but opens up possibilities for serverless game logic.

Example: Storing High Scores in DynamoDB (Conceptual):

1. Create a DynamoDB Table: Create a DynamoDB table to store player names and scores. The table should have a primary key (e.g., player name).
2. Modify the Python Code: Add code to:
   • Connect to DynamoDB.
   • Insert the player’s score into the table if they win.
3. Use the Amazon Q CLI to Execute the DynamoDB Operations (Ideally through Lambda): While you *could* directly interact with DynamoDB from the Python script, a more secure and scalable approach is to trigger a Lambda function using the Amazon Q CLI. The Lambda function would then handle the DynamoDB interaction.

Illustrative (Simplified) Python Code Snippet (Requires boto3 library):

import boto3

def save_score(player_name, score):
    """Saves the player's score to DynamoDB."""
    dynamodb = boto3.resource('dynamodb', region_name='your_region') #Replace with your region
    table = dynamodb.Table('your_high_scores_table') #Replace with your table name

    try:
        table.put_item(
           Item={
                'player_name': player_name,
                'score': score
            }
        )
        print("Score saved to DynamoDB!")
    except Exception as e:
        print(f"Error saving score: {e}")

Invoking the DynamoDB operation (via Lambda, conceptually):

aws lambda invoke --function-name your_lambda_function --payload '{"player_name": "YourName", "score": 100}' output.txt --cli-binary-format raw-in-base64-out

Important Considerations:

• IAM Permissions: Ensure that the IAM role associated with your AWS CLI configuration (or Lambda function) has the necessary permissions to access DynamoDB (or other AWS services).
• Security: Avoid hardcoding credentials in your code. Use IAM roles and environment variables for secure access to AWS resources.
• Error Handling: Implement robust error handling to gracefully handle failures when interacting with AWS services.

10. Testing and Debugging Your Game

Testing and debugging are crucial for ensuring your game works as expected. Here are some tips:

1. Test Different Scenarios:
   • Guessing too low.
   • Guessing too high.
   • Guessing the correct number on the first attempt.
   • Guessing the correct number on the last attempt.
   • Running out of attempts.
   • Entering invalid input (non-numeric).
2. Use Print Statements for Debugging: Add `print()` statements to your code to track the values of variables and the flow of execution. For example:

   print(f"Secret number: {secret_number}")
   print(f"Guess: {guess}")
   print(f"Attempts left: {attempts_left}")

3. Use a Debugger: If you’re using an IDE like VS Code or PyCharm, use its built-in debugger to step through your code and inspect variables.
4. Test Edge Cases: Test with edge cases, such as guessing the lowest possible number (1) or the highest possible number (100).
5. Handle Exceptions: Use `try…except` blocks to handle potential errors gracefully, such as invalid input.

Example Debugging Scenario:

Suppose the game is not giving the correct feedback. You can insert `print()` statements to see the values of `secret_number` and `guess` before the `if` statements to understand why the feedback is incorrect.

if guess < secret_number:
    print(f"DEBUG: guess={guess}, secret_number={secret_number}") #Added for debug
    print("Too low.")
elif guess > secret_number:
    print(f"DEBUG: guess={guess}, secret_number={secret_number}") #Added for debug
    print("Too high.")

11. Optimizing Your Game for Performance

While our simple game doesn’t require extensive optimization, understanding optimization principles is important. Here are some general tips:

1. Minimize I/O Operations: Reduce the number of times you read from or write to the console (e.g., reduce unnecessary `print()` statements).
2. Use Efficient Data Structures: For more complex games, choose the appropriate data structures (e.g., lists, dictionaries) for optimal performance.
3. Optimize Algorithms: If your game involves complex algorithms, analyze their time complexity and look for ways to improve their efficiency.
4. Profile Your Code: Use profiling tools to identify performance bottlenecks in your code.

Specific to our Number Guessing Game:

There’s not much optimization to be done in our simple game. The only potential improvement is to minimize the number of `print()` statements within the loop if performance becomes a concern (which is unlikely).

When AWS Integration is involved:

• Minimize the number of calls to AWS services. Batch operations where possible.
• Ensure Lambda functions have sufficient memory allocated.
• Optimize DynamoDB queries and indexes for efficient data retrieval.

12. Conclusion: The Potential of Amazon Q CLI for Creative Applications

While the Amazon Q CLI is primarily designed for managing AWS infrastructure, this guide demonstrates its potential for creative applications like building simple arcade games. By leveraging its command-line interface and scripting capabilities, we were able to create a functional Number Guessing Game. Furthermore, we explored the possibilities of integrating with AWS services to enhance the game’s features, such as storing high scores and implementing leaderboards.

Key Takeaways:

• The Amazon Q CLI is a versatile tool that can be used for more than just DevOps tasks.
• Building simple games can be a fun and engaging way to learn about the CLI’s functionalities.
• Integration with AWS services opens up a wide range of possibilities for enhancing game features.
• Thinking outside the box and exploring unconventional uses of tools can lead to valuable learning experiences.

This exercise highlights the importance of exploring the capabilities of tools beyond their intended purpose. The Amazon Q CLI, while not a game development engine, provides a unique platform for experimenting with cloud integration and command-line interaction. This is just the beginning. With imagination and creativity, you can push the boundaries of what’s possible with the Amazon Q CLI and other powerful tools.