Forem: sm.lee

Refactoring for Scalability: Implementing a 16-Team Tournament Logic in Python

sm.lee — Mon, 30 Mar 2026 05:17:25 +0000

https://gist.github.com/239ad492cbc875f802e6d5facf35db81.git

To bring my baseball project to a full league scale, I've been working on a tournament simulation engine. It currently features a Round of 16 group stage, a bracket for the Quarter-finals and Semi-finals, and a Best-of-five Series for the Grand Finals. I'm still tweaking the fine-grained league regulations, but I wanted to share the progress so far.

To run the simulation, simply copy and paste the code into your Python environment and execute it.

I built a baseball simulator in Python (with JSON-based teams)

sm.lee — Wed, 25 Mar 2026 07:37:26 +0000

engine
https://gist.github.com/ccf99187f6f438d18dae7adeafd584ab.git
main
https://gist.github.com/b6b79da45e8d896212a5b3b4214919b9.git
Teams
https://gist.github.com/64f40cf6a132812f2e7522333e2ddd62.git
teams
https://gist.github.com/863bde9738786ce7073b04c5504416e3.git

It's been just over two weeks since I started building my baseball simulation. I'll admit, the sheer difficulty of development has dampened my spirits at times. But I’m sticking to my '1% improvement' philosophy—challenging myself consistently, even if it's just a little bit each day.

I’ve refactored the project structure as follows:

Previous Structure:

Team files

Main (Execution)

Team Stats + Load Team + Prepare Next Batter (Combined)

New Refactored Structure:

Team files

Main (Execution)

Team Stats (Separated)

Load Team + Prepare Next Batter (Separated)

The reason for this separation is to minimize potential errors and ensure scalability as I add more teams to the simulation.

During this process, I faced numerous challenges—from base-stealing bugs to countless errors during the file separation phase. There were moments when I felt like giving up, but I pushed through by focusing on solving just one immediate error at a time.

I’m also learning a lot from AI about system architecture, file modularization, and how to improve overall code quality. A huge thank you to my followers and everyone who takes the time to read my posts!

[How to Run]
Please save the engine, main, Teams, and teams files separately. In the main file, update the from statements with the specific names of the engine and Teams files you are using before executing main.

Is this "Nano Banana" image for real?

sm.lee — Sun, 22 Mar 2026 22:59:54 +0000

I’m currently in the middle of a fierce battle to integrate graphics into my baseball simulation project and bring the game to life.

I specifically requested a certain composition from the AI to achieve this look.

My specific request was for a teddy bear in this exact composition, but it just lazily stuck on two ears and decided that was enough.

I was going for that adorable teddy bear look, but once again, the AI gave me... well, this.

Even after trying for that cute teddy bear aesthetic, the AI keeps messing up the spatial logic—placing the pitcher, batter, and umpire in ways that just don't make sense. It's a constant process of 'prompt engineering' to see how I can get the AI to actually understand the baseball field layout I want.

Refactoring Struggles: Successfully Modularized, But Hitting a Wall with Scalability

sm.lee — Sat, 21 Mar 2026 05:51:58 +0000

main
https://gist.github.com/5c0c1c7ff0892e0a14175f7d99350d15.git
engine
https://gist.github.com/2ad8c7eea57128cfcbaa261385a1a4f0.git
teams
https://gist.github.com/15e234746f5d4d5026158c4671d599dc.git

Today, I attempted a major refactoring of my project files. I successfully separated the code into three main files: engine, main, and teams. However, my next goal—splitting the teams file into individual files for each team to allow for easier expansion—proved to be a formidable challenge.

I spent 3 to 4 hours battling persistent errors, but ultimately, the attempt was unsuccessful. To truly master refactoring, I’ve realized I need to go back to simpler simulations, re-evaluate if my logic aligns with how the machine processes data, and then see if those principles can be applied to my current project.

I’ve heard that sharing failed attempts can be just as helpful as sharing successes, so I am posting my current progress here. A huge thank you to all my followers and readers for your continuous support.

PS: To run this, copy the code from the three links into separate Python files. In your main file, update the from statements to match the filenames of your engine and teams files in your local environment.

Refining Baseball Logic: Inning Closures, Probabilities, and the Challenge of

sm.lee — Fri, 20 Mar 2026 07:08:33 +0000

engine
https://gist.github.com/b1a4440aebe8e7dc0d874cfbce457479.git
main
https://gist.github.com/df25b31531621cddd6a6d5804150c5d4.git

To be honest, I’m writing from South Korea. Since English isn't my first
language, I’ve been using Gemini to help translate my thoughts into these posts. Following my previous update, I’ve spent several hours battling errors to refine the game logic and carefully adding detailed commentary to the code. I considered translating the comments into English, but Gemini suggested keeping them in Korean—it adds a unique touch, and those truly interested will find a way to translate and understand the logic.

Building on the previous version, I’ve now implemented the logic for the game to end if the home team is leading after the top of the 9th, as well as "walk-off" (Sayonara) scenarios for the bottom of the 9th. I’ve also finalized the probability settings for each team, covering batting averages, walks, outs, and various types of hits.

The "walk-off hit" logic is still a work in progress. Ideally, the game should end the moment the winning runner touches home plate. However, implementing this requires a system to track each individual runner's position, so I've decided to tackle that in a future update to focus on simpler milestones first. Currently, a walk-off hit behaves a bit like a home run, where trailing runners might still be included in the final score—a small detail I look forward to perfecting soon.

I’m consistently posting here because my goal is to become a skilled developer, work abroad, or be invited to collaborate on global projects. It’s a long journey, but with the support of my followers and readers, I feel like I’m getting closer every day. I appreciate your continued interest and will keep sharing my progress.

How to use: In the 2nd line of the main file, please update the filename next to from to match your local environment.

Python Baseball Engine Update: How to Separate Game Logic from UI

sm.lee — Thu, 19 Mar 2026 21:38:19 +0000

engine
https://gist.github.com/71b4fa98b36ce1c4d1ca10f78b383e56.git
main
https://gist.github.com/6067572dc747d5e142a2915121c15a4a.git

To truly master coding, I am focusing on understanding every single line of code and writing detailed explanations for each one.

In this update, I’ve added the logic for switching sides (innings) once three outs are reached. More importantly, I have separated the code into two parts: the Engine, which handles the core game logic, and the Main (Execution), which handles the user interface.

I plan to keep pushing forward and improving this project, so please stay tuned for more! A huge thank you to all my followers and readers for your support.

PS: To run this, save the Engine and Main as separate Python files. In the second line of the Main file, make sure to update the from [filename] import Baseball statement to match your Engine's filename. Then, you're all set to play!

Detailed commentary to every line

sm.lee — Thu, 19 Mar 2026 04:01:23 +0000

https://gist.github.com/fb98eb9d932bbdab90538a5d54726536.git

I have officially completed the study of the remaining parts of the logic and added detailed commentary to every line of the code. It was a great journey of breaking down each function to truly understand how the engine works.

A huge thank you to all my followers and everyone who has been following this series. Your support keeps me motivated! Happy coding!

Update: Refining the Base Running Logic for a 'Base on Balls' (Walk)

sm.lee — Thu, 19 Mar 2026 00:26:57 +0000

https://gist.github.com/ae32fe94c7d178d3ddfd9f635293f494.git

I’m sharing an updated file that specifically focuses on the 'Base Running Logic during a Walk' (Base on Balls), along with detailed commentary. I’ve included a step-by-step breakdown within the code to explain the 'chain reaction' of forced runner movement and how each base is cleared and re-occupied.

A huge thank you to all my followers and everyone who has been following my progress. Happy coding!

How I Mastered Baseball Simulation Logic: A Step-by-Step Breakdown

sm.lee — Wed, 18 Mar 2026 20:24:34 +0000

https://gist.github.com/f1d4a15db7c02052fc9a9e0783fab79c.git

Today, I took a deep dive into the base_running logic of my Python baseball simulation. At first, the code felt like a black box, but by breaking it down line by line and using metaphors like "Excel SUM," I finally claimed ownership of the logic. Here is how it works.

The "Clean Slate" Strategy (scored = 0)
Before any play begins, we must reset the current plate's score. This ensures that runs from the previous batter don't bleed into the current one. It's a temporary "basket" for the current hit's results.
Handling Home Runs with "Excel Logic"
Python
if advance == 4:
scored = sum(self.bases) + 1
I applied my knowledge of Excel's SUM function here. We treat True as 1 and False as 0. By summing the bases and adding 1 (the batter), we get the total runs instantly. Simple and elegant!
The "Anti-Collision" Reverse Loop
Python
for i in range(2, -1, -1): # Checking 3rd -> 2nd -> 1st base
This is the most critical part. To prevent "runner collision" (where a runner moves twice in one turn), we must process the bases from 3rd to 1st. By clearing the path ahead, each runner moves exactly as they should.
The Logic of Movement (True vs False)
Scoring: If i + advance >= 3, the runner leaves the field (becomes False) and enters the score sheet (scored += 1).

Advancing: If they stay on the field, we plant a new flag (True) at their new position.

Cleanup: Regardless of where they go, the original base must be cleared (False).

Conclusion
I started the day feeling overwhelmed by the complexity, but by slowing down and translating the code into my own words, I turned stress into a "1% incremental growth."

PS: I've added detailed comments in the code to explain the base-running logic after a hit.

Small Wins Matter: Refining Steal Logic with Success and Attempt Probabilities

sm.lee — Wed, 18 Mar 2026 04:09:53 +0000

https://gist.github.com/4c33a6c0d12b61dbb315ae7eacb7b650.git

Following up on my previous post, I’ve just completed an update that adds separate probabilities for both steal attempts and steal success. Even though it hasn't been long since my last update, my passion for achieving these "small wins" kept me moving forward. I want to express my sincere gratitude to everyone who reads my posts and to all my followers.

Building a Better Baseball Sim: Testing Logic with Manual and Probabilistic Inputs

sm.lee — Wed, 18 Mar 2026 03:22:30 +0000

https://gist.github.com/ad07af01cbbe20b787a50104393a9570.git
https://gist.github.com/d57f4cdbef10252d343575bb177590c5.git

Until now, I had been writing my baseball simulation code by simply accepting whatever the AI provided without proper verification. This led to several logical inconsistencies in the code. To truly learn and master the fundamentals, I’ve decided to start over. I am now manually inputting base-running, stealing, and batting scenarios to observe how the runners move and to solidify my understanding of the basics.

I have prepared two test files for this purpose:

The first file allows for manual input of all scenarios, including hits, walks, and steals.

The second file generates hits and walks based on probability, while still allowing for manual steal attempts.

I plan to continue testing by adding more features bit by bit. See you in the next update!

Bug that eluded me last time

sm.lee — Tue, 17 Mar 2026 02:32:39 +0000

Revised material by Gemini
https://gist.github.com/6298723571a21eed258913513c70dd02.git

Fixed and Updated Version
https://gist.github.com/8ea0e1f2b7759971f5b7b116bcd69ed6.git
simulation
https://gist.github.com/8f8ab58e57631f458fee95403b613dac.git

I'm back with a new post, having finally found and fixed the bug that eluded me last time. I felt it was a missed opportunity to immediately clear the bases after the 3rd out. To enhance the excitement of the baseball simulation, I worked hard to preserve the base-running situation from the 2-out mark, displaying it just before the side change even when the 3rd out occurs.

I plan to keep challenging myself and will continue posting, whether I fail or succeed. I want to express my deepest gratitude to all my followers and everyone who reads my posts.

PS: To get started, save the Engine and Simulation codes as separate Python files within the same folder. In the Simulation code, update the from statement at the top to match your Engine file's name, then run the Simulation file. It should work perfect