Sprint 1 – Onboarding Challenge

Task Overview

Sprint 1 was about setting up my personal development environment and learning how to manage code and workflows as a Learning Experience Designer. The main focus was on VSCode, GitHub, Make, and Linux commands to get my GitHub Pages site running.

What I Actually Did

I started by creating my personal workspace:

  • Used mkdir -p <USERNAME> to create a personal directory.
  • Cloned the student repository using git clone https://github.com/<USERNAME>/student.git.
  • Ran ./scripts/activate.sh to configure GitHub credentials.
  • Set up and activated a Python virtual environment with ./scripts/venv.sh and venv.

Next, I installed all dependencies:

pip install -r requirements.txt
gem install faraday-retry

I had to debug multiple issues along the way, such as missing packages and misconfigured environment variables. Running Make commands like make serve-minema allowed me to serve the site locally and test changes before pushing.

I also practiced committing and pushing code to GitHub:

git add .
git commit -m "Setup initial project"
git push origin main

Watching GitHub Actions trigger automatically and seeing my changes live on GitHub Pages was a key part of the experience.

Challenges I Faced

  • Make commands sometimes failed due to missing dependencies.
  • Activating virtual environments in Kasm/Linux required troubleshooting.
  • Ensuring the GitHub Pages site published correctly after multiple commits.

What I Learned

  • How to create directories and organize projects using Linux commands.
  • How to clone and manage GitHub repositories effectively.
  • How to run and debug Make commands for automation.
  • How to configure and activate Python virtual environments.
  • How GitHub Actions work to deploy GitHub Pages automatically.
  • How to systematically troubleshoot errors and document solutions.

My Favorite Part

Getting my site online and fully functional was very satisfying. Every bug I fixed and command I ran made me feel more confident in managing my own development environment.

Overall Reflection

Sprint 1 taught me that a big part of coding is understanding the setup and tools. Running commands, troubleshooting, and managing repositories were all valuable skills I can build on. In the next sprint, I want to keep improving my workflow and start working on more complex projects with my personal GitHub Pages setup fully established.

Sprint 2 – JavaScript Fundamentals

Task Overview

Sprint 2 focused on learning JavaScript fundamentals and applying them to small projects and games. The goal was to strengthen my understanding of variables, functions, loops, arrays, objects, and DOM manipulation, and to start building interactive experiences on the web.

What I Actually Did

I completed several JavaScript exercises and homework assignments, including:

  • Practiced declaring variables using let and const for storing strings, numbers, and booleans.
  • Used mathematical and logical operators to perform calculations and make decisions in code.
  • Applied conditionals (if, else if, else) to control the flow of programs.
  • Iterated through arrays using loops (for, while, for...of) to perform repeated actions.
  • Created functions to organize reusable code for calculations, updates, and game actions.
  • Built objects to store structured data, including JSON-style objects for games.
  • Manipulated the DOM to display results, take user input, and update web pages dynamically.
  • Combined these skills to implement simple game mechanics like scoring, animation, and playlist shuffling.

Challenges I Faced

  • Debugging loops and functions when output wasn’t what I expected.
  • Properly connecting JavaScript with HTML elements for DOM manipulation.
  • Managing multiple objects and their properties in small game projects.
  • Understanding the flow of asynchronous events in a webpage.
  • Keeping track of variable scopes and ensuring functions accessed the correct data.

What I Learned

  • How to declare and use variables effectively.
  • How to write and call functions to simplify repetitive tasks.
  • How to use loops and conditionals to control program flow.
  • How to organize data in objects and arrays for complex tasks.
  • How to dynamically update web pages using DOM manipulation.
  • How to combine these concepts to create small interactive games and tools.
  • How to debug errors systematically and read console logs for insights.

My Favorite Part

Creating the playlist shuffle was especially satisfying because it applied nearly all the concepts I had learned in a single, interactive project. Watching the songs display in order and seeing the program run in real time gave me confidence in my coding abilities.

Overall Reflection

Sprint 2 reinforced the foundational concepts of programming in JavaScript. By practicing variables, functions, loops, objects, and DOM manipulation, I learned a lot from the JavaScript fundamentals. These skills will be essential as I move into more complex web development and game-based projects. One example of code that I enjoyed making is the playlist shuffle, as I had a lot of fun with it. The code is located below.

%%html
<div id="outputPH2">Playlist Shuffle Results:<br></div>

<script>
(() => {
  const output = document.getElementById("outputPH2");

  function playlistShuffle(playlist) {
    for (const song of playlist) {
      console.log(`Now playing: "${song}"`);
      output.innerText += `Now playing: "${song}"\n`;
    }
    console.log("All songs have been played!");
    output.innerText += "All songs have been played!\n";
  }

  const mySongs = [
    "Drake - God's Plan",
    "Kendrick Lamar - Alright",
    "J. Cole - Middle Child",
    "Travis Scott - SICKO MODE",
    "Post Malone - Circles",
    "Lil Baby - In A Minute",
    "Doja Cat - Woman",
    "The Weeknd - Blinding Lights",
    "Kanye West - Stronger",
    "Ariana Grande - 7 Rings"
  ]; 

  playlistShuffle(mySongs);
})();
</script>
Playlist Shuffle Results:

Sprint 3 – Mansion Game (Level 6 Boss Fight)

Task Overview

Sprint 3 focused on creating Level 6 of our class’s collaborative Mansion Game — the final boss fight.
Our team was responsible for designing, coding, and debugging the most technically challenging level in the entire game.
We had to apply advanced programming concepts like game physics, event handling, and timing, all while using the **OpenCS game engine, which wasn’t built for such a fast-paced, object-dense fight.

What I Actually Did

Our team divided the work into clear roles to stay organized.
I worked on documentation, blog writing, debugging, and helping with GitHub commits to ensure everything connected smoothly between levels.

In Level 6, we implemented:

  • Introductory Chamber with NPCs and dialogue to prepare players before the boss.
  • Boss Battle Room that triggered upon interacting with the double doors.
  • Health bar system for both the player and the boss.
  • Boss behavior system using classes and inheritance (Boss extending Enemy).
  • Projectile mechanics for fireballs, arrows, and scythes.
  • Dynamic attack patterns that changed based on the boss’s health:
    • Stage 1 (Full Health): Fireballs and arrow projectiles
    • Stage 2 (2/3 Health): Added scythes with curved movement paths
    • Stage 3 (1/3 Health): Faster attacks, higher damage, and an instant-kill melee range
  • Victory and Death screens with respawn functionality.

Challenges Faced

OpenCS Engine Limitations: The engine wasn’t designed for heavy projectile systems or fast combat, so we had to dig through the source code to understand how to extend it.

Performance Issues: Too many objects on screen caused lag or frame drops, forcing us to optimize update loops.

Collision Bugs: Getting hitboxes and timing to sync correctly between the player and reaper was tough.

GitHub Collaboration: Merging code from multiple branches caused frequent conflicts, especially when editing core files.

Balancing the Fight: Making it hard but still winnable took several rounds of testing and debugging.

- What I Learned

How to read and modify an existing game engine’s codebase.

How object-oriented programming (inheritance, encapsulation, classes) works in real projects.

How to manage projectiles, timers, and collision detection in a live game loop.

How to use GitHub Issues and Kanbans to coordinate tasks as a team.

How to debug complex interactions and optimize performance under pressure.

How to present and document my work clearly for both technical and non-technical audiences.

- My Favorite Part

Seeing our boss level actually work — with health bars, scythes flying, and the victory screen popping up — was an amazing feeling. All the hours of trial, error, and debugging paid off when the game finally ran smoothly and players could experience our level the way we imagined.

- Overall Reflection

Sprint 3 was by far the hardest and most rewarding sprint. We learned how to collaborate effectively, manage complex code, and push the boundaries of what the OpenCS engine could handle. Level 6 turned out to be an exciting and chaotic final boss fight, a perfect conclusion to the Mansion Game project. It taught me the importance of teamwork, debugging under pressure, and staying patient through technical challenges.