@Its_angela

So Far: FINALLY got back into the actual game mechanics!! After being stuck on this for a while, I’ve started working on the guessing system - basically getting the computer to actually USE all the information it’s collected instead of just randomly guessing animals. This involved lots of new subroutines too… YAYY!!! Aside from that, the player can now ask questions and the computer is able to process and reply (to some extent lol).

The main challenge has been nested dictionaries (AGAIN). I’ve been working through exactly what each variable represents when looping through Bank, especially the difference between the attribute, the nested dictionary, and the individual value/status inside it. I’ve also started building an info dictionary which will store the characteristics the computer knows about, so it can use these to eliminate animals that don’t match.

I’ve also been working on keeping track of animals that have already been ruled out, then using that to create a list of possible animals before making a guess. Basically:

Bank → known information → eliminate animals → possible animals → GUESS.

The challenge: Because some attributes are single values, some are booleans, and others are lists (like regions/habitats), I can’t just compare everything in exactly the same way. Soooo… there’s definitely still some logic to figure out there!!

Next Steps: Finish the guess() subroutine, make sure the computer is correctly eliminating animals based on both yes AND no answers, and then connect everything properly to the main game loop so the computer can actually WIN instead of just guessing forever.

So Far: I re-structured my question bank and animal bank: my old version was inconsistent with use of dictionaries and lists, and whether attributes had multiple or boolean values, which made my code and logic MESSY. It’s been a while since I worked on this project, because quite frankly, I was stuck - turns out this project may have been a little complicated for my first project to learn python with. The first thing I did was try to work my way through the logic, especially where nested dictionaries + lists were involved, because that was my main source of confusion (yes, I did it manually on paper I found that easier). I then experimented a little with lists and dictionaries, until FINALLY rewriting my code so its a lot more consistent and easier to work with!! Next Steps: Yes, this does mean I’ll need to recode my subroutines, soooo… there’s definetely that! Recode my subroutines to work with the new, more consistent data structures. I’ll start with askQ, then processAnswer and animalAttribute, testing each one independently before connecting them together.

So Far: Spent the last couple of hours dealing with a massive headache trying to optimize my Chromebook setup. Because I’m using the browser-based cloud setup with github.dev and Replit, I spent a chunk of time testing the live-reload speeds and syncing changes between Git and Streamlit to make sure the environment won’t crash when the project gets bigger. Progress: Since the environment is finally stable, I pivoted to researching how to actually handle the math for the next phase. I looked into how Streamlit handles plotting graphs and started mapping out how to translate the physics formulas (like the gravitational field interactions) into Python vectors. It turns out doing real orbital physics in a browser app requires a lot of coordinate transformations so the dots don’t just fly off the screen. Next Steps: Start writing the actual gravity formulas in code, try to get the background looking less boring, and look into how to swap the manual coordinate slider for mouse-click inputs! I had to attach a picture, so I’ve chosen one from a different project: Atlas26 - a real-time 3D solar system simulation. That is not what my project is but I’d like to get it to look like that.

So far: FINALLY started building the actual game!!
Using the modular approach I mentioned, I built a subroutine that asks a question, validates the answer (nested while loop) and converts it into a Boolean to return it.
I’ve also started askQ(), which will use what the computer already knows to choose its next question, so questions are more intentional and don’t feel scripted.
The challenge: Some attributes are stored in dictionaries when there are lots of possible answers, like class, diet, habitat, etc., while others are just True/False booleans, like has_fur.
I’ve therefore started writing YET ANOTHER dictionary - yep, more more data writing, YAYY!! - to track each attribute as unknown, true or false depending on the information the computer has been given.
Most importantly, I’ve worked through functions, parameters, return values, dictionaries, keys/values, append() and local variables.
Next Steps: finish the attribute tracking system, make askQ() work, eliminate animals based on data and somehow get the computer answering THE PLAYER’s questions too!!

So Far: I did a LOTTT of writing. I made two main dictionaries: one containing all the animals and their characteristics, and another containing questions specific to each characteristic. Both have a bunch of embedded lists and dictionaries, so there is a LOT of data in there. Currently at 1050 lines of code… glad that’s out of the way so I can finally start getting the actual game mechanics to work!! Progress: Right now, when the program runs, the player gets assigned an animal, which they can change if they feel like they don’t know enough about it. The computer is assigned an animal too. The player is then shown all the animal options, (complete with emojis, ofc!! [couldn’t find an emoji for them all, sooo… some may be a little unconventional]) and… that’s it for now. Next Steps: I’m going to use a modular approach (thanks GCSE Computing!) so I figure: 1. Making a subroutine that identifies which question to ask next. 2. Making another subroutine that interprets the player’s answer and uses the linked attribute or value of the question to identify a characteristic of the player’s animal. 3. Making YET ANOTHER subroutine that uses those identified characteristics to keep track of which animal the player could have. And last but not least… figuring out how to get the computer to process the questions and answer them. *If anyone is actually reading this, I’d really appreciate any ideas, because I’m not too sure how yet!! *

So Far: Made a GitHub repository (took me a while to figure out how that works). I’m on a ChromeBook which complicates things a little, so I’ve decided to use github.dev (like a browser VSC?) to code, and because I’m using Streamilt, I linked it to Replit so I can pull changes from Git and see how it’s going. I tried clearing storage space to use Linux first (after AAAGES of research), which took hours, but then I realised that wouldn’t work (need more GBs), so this is the way to go for now I guess. Progress: I have an Earth and a Sun, both are 2D. No data from NASA - yet. They’re just dots. I’ve made a slider that moves the Earth (ideally it can be moved with a mouse, let’s see if I can figure that out). The background is also just plain black, hopefully I can get it to look cooler and more space-y. Baby steps people!!