Lab 3

This lab was about creating a program for the 6502 Emulator that outputs to both character and graphics screens, accepts user input, and performs arithmetic operations. I decided to write a simple Number Guessing Game. 


Objective

The program generates a random number between 1 and 100, and the player guesses the number. It provides feedback like "Too High" or "Too Low" and indicates correct guesses visuals.


Features

  1. Character Screen:
    • Displays instructions and feedback messages.
  2. Graphics Screen:
    • Changes colors based on the result:
      • Green: Correct guess.
      • Red: Too low.
      • Yellow: Too high.
  3. Operations:
    • Compares the user’s guess with the random number.

Code

Here is the code below;

; Number Guessing Game for 6502 Emulator

; Constants
RANDOM_NUMBER = $42 ; Replace this with a random number generator
CHAR_SCREEN = $0400
GRAPHICS_SCREEN = $2000
GREEN = $1
RED = $2
YELLOW = $3

; Initialize program
    LDX #$00        ; Clear X register
    STX CHAR_SCREEN ; Clear character screen

; Display instructions
    LDA #$20        ; ASCII space
    LDY #$00
DisplayText:
    STA CHAR_SCREEN, X
    INX
    CPX #$50
    BNE DisplayText

    LDA #<Message
    LDY #>Message
    JSR PrintMessage

; Main game loop
StartGame:
    LDA RANDOM_NUMBER
    STA $50          ; Store the random number in memory
    JSR GetInput     ; Get user input
    LDX $51          ; Load user's guess
    LDY $50          ; Load random number
    CPX $50          ; Compare user's guess with random number
    BEQ CorrectGuess ; Branch if equal
    BCC TooLow       ; Branch if less than
    BCS TooHigh      ; Branch if greater than

TooLow:
    LDA #RED
    STA GRAPHICS_SCREEN
    LDA #<LowMessage
    LDY #>LowMessage
    JSR PrintMessage
    JMP StartGame

TooHigh:
    LDA #YELLOW
    STA GRAPHICS_SCREEN
    LDA #<HighMessage
    LDY #>HighMessage
    JSR PrintMessage
    JMP StartGame

CorrectGuess:
    LDA #GREEN
    STA GRAPHICS_SCREEN
    LDA #<WinMessage
    LDY #>WinMessage
    JSR PrintMessage
    JMP StartGame

; Subroutines
PrintMessage:
    LDA (Message), Y
    BEQ DoneMessage
    STA CHAR_SCREEN, X
    INX
    INY
    JMP PrintMessage
DoneMessage:
    RTS

GetInput:
    LDA #$10  ; Simulated input
    STA $51
    RTS

; Messages
Message:
    .asciiz "Guess the number between 1 and 100!"
LowMessage:
    .asciiz "Too Low! Try again."
HighMessage:
    .asciiz "Too High! Try again."
WinMessage:
    .asciiz "You got it!"


Reflection

This lab was a fun challenge, especially building logic with assembly language. While debugging was tough, the experience improved my understanding of how low-level programs interact with hardware. Learning languages like assembly that are so raw to machine language really shows how the interaction happens.

Comments

Post a Comment

Popular posts from this blog

Image
  Automatic Function Multi-Versioning for GCC Introduction: For this project, I will be working with the GCC compiler and learning how it works by building it from scratch on an AArch64 platform (which is 64-Bit). Setting up GCC like this lets me dig into how it compiles code and optimizes functions for different CPUs, especially as the goal is to experiment with Automatic Function Multi-Versioning (AFMV). Guide to Building GCC for AArch64 Step 1: Cloning the Source Code To get started, I needed the GCC source code. Cloning from the official GCC repository keeps things organized and up to date. Here’s the command to clone it: git clone git://gcc.gnu.org/git/gcc.git ~/gcc This creates a directory called ~/gcc , where all the source files are stored. The cloning process might take a few minutes, depending on your internet speed. Step 2: Setting Up a Build Directory It’s recommended to create a separate directory for building GCC instead of doing it directly in the source directory. ...
Read more

Building GCC Part 2

This is my attempt to learn and work with GCC as part of my SPO600 course. I’m working on Stage 2 of the project, where I have to create and test a Clone-Pruning Analysis Pass. You can find the first part in my blog page. Creating the Dummy Pass I started by creating a basic pass that should iterates through the program functions and output their names to a dump file.  Iterating Through GIMPLE Statements Next, I added logic to traverse the GIMPLE representation of each function. GIMPLE is an intermediate language used by GCC, and understanding it was crucial for the project. By iterating over the GIMPLE statements within each basic block, I could analyze the structure of functions. This step highlighted the importance of diagnostic dumps, as they provided a detailed view of what the pass was processing. While the GIMPLE code initially felt overwhelming, breaking it down into smaller sections made it easier. Setting Up The first step was to get the provided files into my working dir...
Read more

Wrapping Up Project : Stage 3

With the final stage of the SPO600 project, my journey into the GCC compiler comes to a close. This stage was all about tying up loose ends from Stage 2, testing the Clone-Pruning Analysis Pass, and reflecting on what I’ve learned throughout the project. Progress Overview The focus of Stage 3 was to finalize the work I started in Stage 2. Building on my earlier implementation, I managed to create a pass that iterates through functions, analyzes their GIMPLE representations, and outputs information to a dump file. Here's what my custom GCC pass can now do: Print Function Names : The pass successfully identifies and prints the names of all functions. Output GIMPLE Statements : It iterates through the GIMPLE representation of each function, printing the statements to the dump file. Count Statements : The pass tracks and stores the number of GIMPLE statements for each function. A snippet of my pass code from tree-ctyler.cc demonstrates the approach: unsigned int pass_ctyler::execute(fu...
Read more