PA

ProjectArs

Co-op strategy • adaptive AI teammate

Plan for Year 1

The project will be split into two parallel tracks. Each week I will focus on one of the tracks and publish ongoing progress to the GitHub repository and to a public devlog on my YouTube channel. At the end of the week, I’ll post a combined weekly update on the ProjectArs site.

WEEEK 1 — Setup & Foundations

This week I set up the core infrastructure for the project: Gmail, the GitHub repository, the YouTube channel, project web pages, and the initial .md files and website structure. I also outlined how all parts connect and spoke with people in the field who can help guide the next steps.

To prepare for the AI teammate, I completed a focused Python refresher and started with PyTorch, since the agent will be built in PyTorch. I also did a short Unreal Engine refresher — mainly Blueprints and a quick revisit of Paper2D.

WEEEK 2 — Map & Mechanics Timelapse

In this update, I started working directly in Unreal Engine. You’ll see how the first version of the game map was created, basic mechanics were implemented, and the first UI tests were done — all shown in a smooth timelapse.

It’s the first real step from planning into building the actual world of the game. Watch the process, the progress, and how the vision slowly comes to life. 🚀

WEEEK 3 — First Steps in PyTorch

This week I dove into PyTorch and neural networks. I followed a hands-on video course to grasp the basics and then implemented a single-neuron linear model (from a mentor’s snippet) to really understand what each part of a training script does.

I practiced the full training loop — forward pass, MSELoss, and the Adam optimizer — including the classic sequence: zero_grad() → backward() → step(). I logged the loss and weights during training, plotted a loss curve, measured runtime, and ran tests on sample inputs (on CUDA and CPU). I also learned the difference between saving only weights via state_dict and saving the entire model, then reloaded the model for inference to validate everything end-to-end.

WEEEK 4 — Systems, Upgrades & Polish

Big gameplay progress inside Unreal Engine this week. I created additional Widget Blueprints and wired new screens into the HUD flow. I introduced buildings with an upgrade path and hooked them into the economy. Resource production is now affected by modifiers (e.g., building level, bonuses), and I added a global time element to drive production ticks and UI timers.

I also invested time into visual polish — cleaner layout, clearer feedback, and more consistent visuals across panels. The whole game looks and feels more readable while the core loop (build → upgrade → generate) is taking shape.

  • New UI screens (additional Widget Blueprints) integrated
  • Buildings with upgrades and level-based production
  • Resource generation modifiers connected to gameplay
  • Timer / time-driven elements for economy & UI
  • Improved visual presentation across the game

WEEEK 5 — Tensor Basics in PyTorch

This week I continued with the PyTorch course and focused on the fundamentals of working with tensors. I practiced creating random tensors of different shapes (including an “image-like” tensor with shape (224, 224, 3)), as well as zero and one tensors using torch.zeros and torch.ones.

I explored tensor datatypes and properties — how to set dtype, device, and requires_grad, and how to inspect a tensor’s shape, number of dimensions, and its device location. I practiced basic operations such as addition, subtraction, multiplication, division, elementwise operations, and also matrix multiplication using torch.matmul, torch.mm, and the @ operator.

I also ran into one of the most common mistakes — mismatched inner dimensions during matrix multiplication — and learned to fix it using .T (transpose). I worked with essential aggregation functions like min, max, mean, and sum, as well as argmin/argmax to find index positions. I also reviewed key tensor manipulation methods such as reshape, stack, view, squeeze, unsqueeze, and permute.

In the PyTorch video course, I progressed from 2:00:00 to around 3:33:30, adding about an hour and a half of focused study within the same lesson as the previous week.

WEEEK 6 — Buildings Evolve & Resources Take Shape

This week I focused again on the building and economy systems inside Unreal Engine and recorded everything as a timelapse. Buildings can now be visually updated when they are upgraded — their images change based on level, making progression feel more readable and satisfying.

Every building now generates resources, and the entire system is constrained by a maximum level of 10. The underlying functionality and error handling are already in place, but the deeper gameplay logic and balancing are still work in progress and will evolve in future weeks.

  • Dynamic image changes when upgrading buildings
  • All buildings now produce resources
  • Level cap system implemented (max Level 10)
  • Core functionality wired in, logic/balancing to come next

WEEEK 7 — PyTorch Fundamentals & Reinforcement Learning

This week I continued studying the PyTorch fundamentals, focusing on strengthening the core concepts needed for building the AI teammate. I also explored a specific algorithm from the field of deep reinforcement learning to better understand how agents learn from interaction.

I continued progressing through the same PyTorch course as in previous weeks, solidifying my understanding of tensors, autograd, gradients, and the training loop structure.

WEEEK 8 — Smarter Buildings & Fully Functional Upgrade Logic

This week I focused on the core upgrade logic inside Unreal Engine. Buildings can now only be upgraded when the player has enough required resources, and the economy system finally behaves like a real, rule-driven structure.

I also refactored and cleaned up the Blueprint logic to make the upgrade flow clearer, more modular, and easier to expand later. The entire system is now more robust, predictable, and ready for future balancing and more complex buildings.

  • Completed resource-based upgrade validation
  • Buildings upgrade only if the player has enough materials
  • Cleaner, more organized Blueprint logic
  • Economy loop is now grounded in consistent rules

WEEEK 9 — Reinforcement Learning & Snake AI

This week I shifted focus from supervised learning to Reinforcement Learning (RL) to build a foundation for the future AI teammate. I chose the classic game Snake as a testbed for implementing a Deep Q-Learning agent.

The Environment: I built the game using Pygame, creating both a human-playable version and an AI-ready version. The AI version accepts vector inputs and provides specific rewards and penalties to guide the learning process.

The AI Agent: The agent uses a neural network to evaluate the state based on 11 input parameters (e.g., collision risks, direction, food location). I utilized an Epsilon-Greedy strategy for decision making and implemented Experience Replay (using both short-term memory and long-term history) to ensure stable training. I also built a visualization tool to track the agent's progress.

Contact