It’s called AnimFlow - https://animflow.io/

At a high level, AnimFlow is a simple idea:
Take a single image - a mascot, a character, a sticker - and turn it into a short AI-generated animation.

Not a cinematic video.
Not a full production pipeline.
Just a clean, short, expressive motion that feels usable.

What it actually does

The current version is very focused.

• You upload an image

• You describe a small action (e.g. “wave hello”, “idle breathing”)

• You get a short animation back

The output is intentionally:

• short

• loopable

• consistent with the original character

It’s designed more for animated characters, stickers, mascots, and lightweight content, not full videos.

Additionally, I think I am giving the best price on the market. Other popular services that I tried charge much more.

Here is the animation of my mascot character, which I generated in my service:

How I’m running it

From a technical perspective, it’s a fairly standard setup:

• Django backend + REST API

• Async job system for animation generation based on Celery

• GPU workers running the actual model, hosting on Runpod.io. Currently, I run optimized Wan2.2, but planning to try / integrate other models.

• Next.js Web app as the main client, I have also almost finished the iOS app

The important part is that everything is job-based:
You submit an animation request, it runs asynchronously, and you get the result when it’s ready. In the iOS app, you even get push notifications.

I’m keeping the system simple and modular so I can iterate quickly.

What’s next

Right now, this is very much an MVP.

My focus going forward:

• improve motion quality and stability

• try new models and experiments

• make outputs more “sticker-ready” + try different export formats (GIFs, spritesheets, etc)

I’m also trying to keep this as a small, sustainable project, not overbuild it.

Final thoughts

This is my first time launching something that feels like an actual SaaS product —
even if it’s still early.

I’m not expecting it to explode or anything.

But it’s a good step:

• building something end-to-end

• putting it in front of users

• and seeing what actually sticks

If you’re curious, I’ll be sharing updates as I iterate on it.

I interestingly got into programming. It all kicked off with a Half-Life 2 modification back in the day. I wanted to make something cool for my favorite game. Then I realized that I'm really bad at level design or modelling. So I then attempted to dip into the game logic, scripting and programming, and later began experimenting with the source code. Since then, I have built my career in web development and experimented with mobile apps, but game development has always been my interest. There’s nothing quite like building a world where players can dive in, make choices, and feel the magic of an interactive story.

That passion led me to Sorcery Duel, my latest project—a fast-paced, strategy-driven game where wizards clash in intense spell-slinging battles. Picture tactical duels packed with clever combos and a touch of fantasy flair. But here’s the wild part: I’m crafting it solo. No team, no big studio—just me.

Going solo sounds intense, and it is, but AI tools have made it possible. I’ve leaned hard on Claude Code, Grok, and ChatGPT to bring Sorcery Duel to life. These tools aren’t just sidekicks; they’re like having a virtual dev team, helping me code, brainstorm, design, and create visuals completely on my own. My roots in programming and game modding gave me the foundation to start, but AI is what’s enabling me to proceed with this dream. Even 5 years ago, when I was thinking about solo gamedev, it always felt that I needed at least a designer and an artist, who would share passion, have free time, and be interested in doing that just as a hobby, which seems almost impossible. But not now.

This article’s my chance to share the ride of building Sorcery Duel—the wins, the struggles, and how tools like Claude, Grok, and ChatGPT became my secret weapons. Whether you’re a coder, a gamer, or just curious about solo game dev, I hope this sparks something in you. Let’s jump into the spellcraft of making a game, one line of code at a time.

Overview of Sorcery Duel

Imagine two wizards squaring off, arcane sparks flying, each casting spells with cunning and flair. That’s Sorcery Duel. It’s a strategy-driven, head-to-head battler where every choice matters—think chess with a magical twist.

The setting is a vivid fantasy world—misty arenas, glowing runes, ancient towers humming with power. You play as a sorcerer wielding a spellbook packed with abilities from different magic schools. Each spell has unique costs, cooldowns, and effects, so strategy is everything. Want to freeze your opponent’s mana and follow with a fireball? Go for it. Prefer to summon a lava golem to smash through their defences while you prep a big finisher? That’s a vibe, too. The mechanics reward thoughtful planning, but keep things simple enough for anyone to dive in. It's still a mobile game, not an airplane control panel.

My landmarks for tactical battle pieces were Heroes of Might and Magic 3/5 and World of Warcraft combat systems. It is going to be turn-based, but with a little spark: spells are resolved at the same time, so the result would depend on what both wizards are casting. I decided to add this little real-time element to the classic turn-based approach. I am going to release the first version on iOS, with matches lasting 5–10 minutes, perfect for a quick session with a friend. I’m eyeing other platforms, such as PC or Android, down the road, but for now, it’s all about making those iOS duels shine.

But okay, let’s stop advertising my game. I know everyone here is interested in technologies and learning how to build staff.

AI Tools: The Game-Changer for Solo Development and how I used them

Image generation with ChatGPT

Visuals are the central part of the game, and for every game, it is what makes it feel like a whole fantasy world. I’ll admit, I don’t have a skill in illustration—my hands are better suited to a keyboard than a sketchpad. But what I do have is a sharp vision, formed from years of diving into games, soaking up fantasy universes like Warcraft or Skyrim, and getting a feel for how mechanics and aesthetics click.

That intuition guided me, even without artistic chops. Then came ChatGPT’s new image generation, and it flipped the script! Unlike the old days, when every AI-generated image was a fresh roll of the dice and tweaking meant starting over, this tool maintains consistency across generations. That lets me tweak specifics, such as replacing the staff with a glowing orb or swapping a button’s design with a single prompt. Sure, smart tools like “magic eraser” still help clean up edges, but this level of control, where I can refine without losing context, is a game-changer.

For example, here is how I modified this character's appearance

Using the prompt: “Perfect! One small change - make her not wear a hood, the head should be uncovered”

It is also great at generating buttons and being very consistent with it:

All 3 generated within the same chat.

Another thing - animations. Most of animations on 2D games are just a few frames, so for simple effects I just asked ChatGPT to generate a grid of effects frame by frame, and it works quite well. Here is the flying and pulsing fireball:

If you play every frame for 0.1 second, you get a nice animation.

The result is not always positioned perfectly. Sometimes, it still require a manual adjustment. So for flying boulder, where the position is important, I made a simple grid in the Pinta editor to perfectly position and align every frame:

Claude code

I don’t have a huge experience with Swift, so Claude Code helped me learn some language features in practice. As the initial point, I started with a plan, so Claude drafted a nice 10-step process, and updated it when completing the next task. Then I stepped away from that plan, when I got something working, but this is the last used version:

# SorceryDuel Implementation Progress

## Completed Tasks

### 1. Core Architecture & Data Models
- Created enums (MagicSchool, SpellType, SpellDirection, GameState)
- Implemented Wizard and Creature classes
- Built Spell protocol with concrete implementations (Attack, Defense, Summon, Curse)
- Created Effect system for ongoing spell effects
- Implemented SpellFactory for centralized spell management
- Designed TurnAction class for player actions
- Added Shield Defense system with directional protection

### 2. Game Scene & UI Layout
- Create 10x10 grid battlefield
- Position wizards at opposite corners
- Implement UI panels for spell selection
- Add status display (health, mana)

### 3. Player Wizards & Positioning
- Initialize wizards with appropriate textures
- Set up grid-based positioning system
- Implement visual indicators for active wizard

### 4. Bug Fixes & Implementation Updates (May 15, 2025)
- Fixed missing direction parameter in takeDamage method calls
- Updated DefenseEffect initialization with proper parameters
- Implemented addEffect method in Wizard class
- Added useMana method to Wizard class
- Made DefenseEffect properly implement the Effect protocol
- Improved spell effect handling in Wizard class

### 5. Turn-Based Gameplay Flow (Completed May 15, 2025)
- Built state machine for game phases
- Implemented selection sequence: school → type → spell → target → direction (if target is other wizard)
- Created turn resolution logic with visual effects
- Added support for direct, left, and right spell directions
- Implemented directional arrow sprites for spell targeting with visual feedback
- Created dynamic projectile paths for different directions (direct, left, right)
- Added smooth animation transitions between selection phases

### 6. Spell Direction & Resolution System
- Implement spell casting mechanics
- Build direction-based interaction rules
- Create damage calculation with magic school advantages

## Next Steps

### 7. Summoned Creatures & Battlefield Grid
- Implement creature summoning and positioning
- Create creature attack logic (they only shoot the closest target, whatever it is the opponent's wizard or opponent's creature)
- Build grid management system

### 8. Visual Effects
- Design and implement spell animations
- Create feedback for spell outcomes
- Add visual indicators for active effects

### 9. Game State Management
- Implement win/lose conditions
- Create game over screen
- Add restart functionality

### 10. AI Opponent (Optional)
- Implement basic decision-making logic
- Create difficulty levels

## Notes
- Core data models are complete and well-structured
- The SpellFactory provides a centralized way to access all spells
- The visual effects system is designed but will need implementation in GameScene
- Effect system is now properly implemented with protocol conformance
- Wizard class now handles effects and mana usage correctly
- Shield defense system implemented with directional protection (100% for primary direction, 50% for other directions)
- Magic school effectiveness is applied to shields (strong vs. weak schools)
- Each magic school has a unique shield spell that can absorb up to 100 damage points
- Shields last for 2 turns or until their protection value is depleted

It is always a really good idea to give Claude Code a lot of extra information and describe everything in detail. For instance, I usually formulated tasks in a separate text files, giving some particular code references and details. Here is an example that worked good for adding the spellpower ability to wizards:

I want you to work on a new Wizard stat - spellpower.
For every point of spellpower, Wizard's spells become 5% stronger.
It has following effects for different spells:

1. For attack spells - spellpower increases the damage.
For instance, ifa  fireball does 20 damage by default, then it will do 21 damage with 1 point in spellpower.

2. For shields - spellpower increases the shield absorbed amount, also by 5% per every point.
For instance, if a fire shield absorbs 60 damage, then with 2 points in spellpower, it will absorb 66 damage.

3. For summon spells - spellpower increases the creature's maximum health and damage.
For instance, if a golem has 50 health and does 3 damage by default, then with 4 points in spellpower,
it will be 60 health and 4 damage (3 + 3 * 0.05 * 4 = 3.6 --> 4)

4. For other future spells, I will implement them later myself

In case of a fraction resulting value, all numbers are rounded to the closest value. 4.4 --> 4; 4.6 --> 5; 4.5 --> 5.

And this is an example of refactoring, performed by Claude Code, but when I described a particular required changes:

Refactor GameState enum. The current implementation:
```
enum GameState {
    // Turn phases
    case player1Turn
    case player2Turn

    // Selection phases
    case selectingMagicSchool
    case selectingSpellType
    case selectingSpell
    case selectingTarget
    case selectingDirection

    // Resolution phases
    case spellResolution
    case gameOver
}
```

Selection phases should go into a separate enum `TurnState`, with these members:
```
enum TurnState {
    case selectingSpell
    case selectingTarget
    case selectingDirection
}
```

Game state goes between these states:
player1Turn --> player2Turn --> spellResolution --> player1Turn
                                        |
                                        |
                                        v
                                    gameOver

Turn state:
selectingSpell --> selectingTarget --> selectingDirection

selectingTarget and selectingDirection and optional for some spells

In the project, I created a separate folder for all the text files, so Claude can refer to them if needed to remember game rules or project tree, and I am saving completed tasks for the history. Here is my directory structure:

info/
├── Completed
│   ├── defence_spell_logic.txt
│   ├── task_animated_chars.txt
│   ├── task_animated_sprites.txt
│   ├── task_game_state.txt
│   ├── task_shield_effect.txt
│   ├── task_spellbook.txt
│   ├── task_spellpower.txt
│   ├── task_spells_limit.txt
│   ├── task_summon.txt
│   └── ui_task.txt
├── game_rules.txt
├── implementation_progress.txt
├── plan.txt
├── project_tree.txt
├── task_dispell.txt
├── ui_layout.txt
└── used_assets.txt

2 directories, 17 files

I also added some important game facts to CLAUDE.md file, as recommended in this article

Grok

I am, honestly, not a big fan of X. Even when it was Twitter, I kind of avoided that social network. But I have to assume - Grok is really good for certain tasks.

Even in the free version, it supports up to 25 attachments in one chat, which is excellent for the task of refactoring. This means that in the free version, it would almost certainly train on my codebase, but I don’t see a big problem with it if someone has some random modules from my hobby project.

So how I used it - I gave it a file and asked for refactoring plan:

I am implementing a 2D game in Swift for iOS. I have my main class with game logic called GameManager. However, it is becoming a bit too large. Are there any ways I can refactor it? Come up with a plan for now, do not write the code yet!

📄 GameManager.swift

Grok proposed a good plan. Here is the first part of the response with first 2 items:

The GameManager class in your GameManager.swift file is indeed large and handles multiple responsibilities, which can make it difficult to maintain and extend. Refactoring it will improve modularity, readability, and testability. Below is a detailed plan to refactor the GameManager class by breaking it into smaller, more focused components while preserving the existing functionality.

Refactoring Goals

1. Single Responsibility Principle (SRP): Split the GameManager into smaller classes or structs, each responsible for a specific aspect of the game logic.

2. Improved Readability: Organize related functionality into cohesive units to make the codebase easier to navigate.

3. Testability: Isolate logic to enable unit testing of individual components.

4. Maintainability: Make it easier to add new features or modify existing ones without altering the core GameManager.

5. Reusability: Create components that can be reused in other parts of the game or future projects.

Analysis of Current Responsibilities

The GameManager class currently handles:

• Game State Management: Tracks game state (gameState, turnState, currentPlayerTurn), player turns, and selection states (selectedSpell, selectedTarget, selectedDirection).

• Wizard Management: Initializes and manages wizards (player1Wizard, player2Wizard, activeWizard).

• Creature Management: Tracks and manages creatures (allCreatures, summoning, removal, and auto-attacks).

• Spell Management: Handles spell selection, targeting, direction selection, and resolution (including collision detection).

• UI and Visual Integration: Interacts with UIManager, VisualEffectsManager, SpellbookUI, and GameCamera for UI updates and visual feedback.

• Grid Interaction: Works with GridManager for position validation, highlighting, and creature placement.

• Game Flow: Manages turn switching, spell resolution phases, and game-over conditions.

Given these responsibilities, we can split GameManager into several smaller components.

Refactoring Plan

1. Extract Game State Management

New Component: GameStateManager (Class)

• Responsibility: Manage the game state, turn state, and player turns.

• Functions to Move:

  • currentPlayerTurn, gameState, turnState, spellSelectionComplete

  • setCurrentPlayerTurn(_:)

  • switchPlayerTurn()

  • beginSpellResolutionPhase()

  • resetTurnActions()

  • checkGameOverCondition()

  • handleGameOver()

  • resetGame()

• Dependencies: Will need references to UIManager, GameCamera, wizards (player1Wizard, player2Wizard), and stored actions (player1SelectedAction, player2SelectedAction).

• Purpose: Centralizes game flow logic (turn management, game phases, and game-over conditions) and reduces the GameManager’s responsibility for high-level state transitions.

• Interaction: GameManager will delegate turn-related and game state operations to GameStateManager.

2. Extract Spell Management

New Component: SpellManager (Class)

• Responsibility: Handle spell selection, targeting, direction selection, and resolution.

• Functions to Move:

  • selectedSpell, selectedTarget, selectedDirection

  • startSpellCastingSequence()

  • showValidTargets()

  • handleTargetingGridSelection(_:in:)

  • showDirectionOptions(for:)

  • cancelSpellSelection()

  • storeSelectedSpell()

  • resolveSpell()

  • resolveSpellsInOrder(_:)

  • checkAttackSpellCollisions(_:)

  • applySpellEffects(_:)

  • applyAttackEffectsWithCollisions(_:collisionResult:)

  • calculateCollisionWorldPoint(from:to:direction1:from2:to2:direction2:)

  • areDirectionsCrossing(_:_:)

  • calculateHalfDistancePoint(from:to:direction:cellSize:)

• Dependencies: Will need references to GridManager, VisualEffectsManager, UIManager, SpellbookUI, and wizards/creatures for targeting and effect application.

• Purpose: Isolates all spell-related logic, including selection, targeting, and resolution (including collision detection), into a single component.

• Notes:

  • The SpellManager will handle the complex logic of spell interactions (e.g., collision detection and resolution order).

  • Consider creating a SpellCollisionHandler struct or class to encapsulate collision-specific logic (checkAttackSpellCollisions, calculateCollisionWorldPoint, areDirectionsCrossing, calculateHalfDistancePoint) for further modularity.

• Interaction: GameManager will call SpellManager for spell-related actions, and GameStateManager will coordinate with SpellManager during the resolution phase.

……

Then you can execute that plan step-by-step, and it will provide new and updated files, so it is very easy to apply to the project:

I feel like this combo of Claude Code for adding code and Grok for refactoring modules worked really well for me. Grok does not always generate working code, and sometimes it mixes up variables, so you definitely need to keep an eye on it. But it's the same for all the AI-generated code.

I also used it as a generic AI assistant, when I need to chat about my game for free, since it also has memory feature now, and remembers many facts about it, same as ChatGPT.

Conclusion

I like the possibilities that get unlocked with the help of AI assistants. It's great when you can work on your hobby projects with good progress, even if you have only an hour or two a day or over the weekend. That looks fascinating, but it's also important to understand, predict, and analyze the consequences and influence that AI can have worldwide. From small projects like mine to drastic societal effects, and changing the whole way we work. Here are some of my thoughts.

1. AI is not a replacement for professionals, at least, for now. Despite of being helpful on generating images or code, it is still far from the professional level of understanding things deeply. For instance, the example above shows, that it put 2 different entities: turn state and game state into the same enum - GameState. Probably same applies to illustrations. Designers and illustrators make things look estetic and bringing some additional ideas or features into their characters, sometimes even not seen at the first glance, but understood subconsciously. Despite its complexity, AI is essentially about optimizing error minimization in data processing. So it would output a “middle”, “good” and “satisfying” solution, loosing some deep features. It would lack originality in the art images or generate suboptimal code. It leads to the next point.

2. AI makes things that work. But how exactly work - could be missing. For instance, there are multiple ways to implement concurrently executed tasks. At the first glance, it all is executed in the end, and it all working, but the actual result could be different. It plays even bigger role when you step away from the prototyping to the actual project, and trying to optimize it. For instance, when I implemented FitAssist, AI sometimes put some code on the main thread, which works fine while you don’t have much data, but if I would miss that, users could report, that the app is slow, and the more you use it, the slower it gets. So you really need to know your codebase.

3. We all started small. Learned how to code basic things and operations. Then built more knowledge on top of that. Now, AI can handle simple operations and tasks. People start saying that some Junior developer work could be replaced with AI. Yes, we might save money and human labour hours, but it would also mean that the person is not getting experience. Would not be able to proceed to being a middle and senior engineer later. Suppose we project for 10 years (which is always a silly idea, since processes never develop linearly, but just a mental exercise). In that case, we have products that somehow work, which were created with the active participation of AI, and the last person who manually worked with the codebase retired a year ago. Not a big win in the long term, right?

   Also, with the help of AI, a beginner developer is not required to learn everything. All answers are so easily available, all the tasks are solved magically. I still remember nights debugging my self-written graphics engine about 15 years ago, kept getting an empty black screen and trying to understand - what was wrong there, and why was my level not drawn. Now, why would you bother learning how it actually works, when the result is achievable with AI, and the provided solution seems to be doing its job. Why would you ask questions about why it is structured that way, and what are the other options to organize the codebase? AI probably would know, what architecture to choose, right?

   Some people can say that it already happened many times. Look at the car manufacturing facility in 1920:

   

   And at the modern South Korean manufactory with robots:

   

   Everything looks good - routine hard work gets automated, car quality and assembly precision increase significantly, and people are transitioning from manual labour workers to advanced robot operators.

   But I feel like the AI shift is different. I believe it is the first time in human history that automation is occurring in the creative class and intellectual professions. And it might have a bigger impact than we thought. It may be the first time we might delegate decision-making to a non-human. Not a particular algorithm, developed by a person, to work with a specific type of data, and output the decision. But to a generic AI model, that can perform reasoning on provided data, emulate a thinking process, and form a final decision, supporting it with facts from the provided data and its existing knowledge. And even if it could create some additional jobs for more AI engineers or AI ethics specialists, it feels like it might eventually shrink the total number of jobs available.

4. Probably, if progress continues at the same speed, within the next 3-5 years, an experienced developer equipped with a range of AI tools can handle the entire team's workload, especially during the product's prototyping phase. A senior lawyer might delegate contract analysis and matching it with the rules of law to AI. So the company would be happy to increase their salaries, since they are so productive. However, that would also mean they no longer need junior specialists. As well as illustrators and designers for small companies, since SEO can do those things on their own in their free time. That might increase economic inequality even further, as the number of jobs may shrink.

5. Yes, somebody might say, that it is a dog-eat-dog world, and you have to adapt. However, if the process of replacing human labour is avalanche-like, and about 50% of the population is left behind, it's only a matter of time before the consequences affect everyone.

   Economic inequality is not just a social justice theoretical concept, it might have broad real-world consequences. In the Russian Empire before the revolution, wealth distribution was quite extreme: 1.5% of the population owned 25% of the land, while most people were peasants or urban industrial workers living in poverty. That all, after communists seized power by force as a result of a civil war, led to an extreme process of repressing the wealthy, successful peasants - Dekulakization.

   Of course, it is an extreme case, but even now, people who have been left behind the progress are becoming easy targets for populist politicians. Who promise to return to the good old times, defeat all enemies, and solve all the complex problems with simple solutions. This only leads to increased polarization and tension in society, making the world more chaotic and less safe for everyone.

6. Do I propose stopping the progress and development of AI? Of course, not. You can never stop progress; all reactionary forces and ideas have historically lost, and we have to embrace the progress, make it our friend, not our enemy. But let’s keep in mind the consequences of our actions. Let’s stay in control of our fate. Let’s put people first. Let’s build things that would help people, not replace them. Let’s be mindful, because with great power comes great responsibility.

I’ve been writing code for about 15 years now, ever since I kicked off my first project. My debut in the mobile world came in 2014 with an Android music player—a passion project that sparked my love for app development. These days, I spend most of my professional life building web applications, but mobile apps remain my hobby. There’s something thrilling about the process—it’s different from web dev yet familiar enough that skills are transferable between these 2 worlds.

Sport, though, is my other passion. As a CrossFit athlete and fitness enthusiast, I’m no stranger to workout timers and the grind of tracking progress. I’ve always been fascinated by how technology can elevate that journey, turning sweat and reps into data-driven growth. I also used an app called “Start WOD Timer” in my workouts and wanted to improve some things there. That curiosity led me to "FitAssist," my first iOS app. It’s not just a tool—it’s a personal experiment in trying to pack many fitness tools into one app. I’d already experimented with pose recognition using YOLOv11 for a previous article, and I am looking forward to seeing that functionality in my fitness app someday.

I love a challenge, and learning Swift felt like the perfect one. After years of web projects, diving into Apple’s ecosystem was daunting but exciting—a chance to try something new and flex both my developer muscles and my fitness nerd brain. "FitAssist" was born from that spark, a mix of passion, code, and a little bit of grit. I wanted to make a useful app that would accompany your fitness exercises and help with tracking, posture, recommendations and so on, like a good assistant for your workouts.

Diving into iOS Development

Stepping into iOS development wasn’t entirely uncharted territory for me. With 15 years of coding experience, I’m no stranger to compiled languages or the mixes of threads and asynchronous code—skills obtained from some of the Android development and years of web projects. My Android experience gave me a solid foundation: I knew how to structure an app, deal with build systems, and optimize for mobile. But iOS? That was a fresh canvas, and Swift was the brush I’d never picked up before.

What surprised me was how familiar SwiftUI felt. As someone with deep React experience, I spotted the inspiration right away—declarative UI, component-based design, and state management. It was like meeting an old friend in a new city. Still, the Apple ecosystem was a bit of a new world. However, developer support was great! Enrolling in the Apple Developer Program resulted in an error with a recommendation to contact support. It turned out that their address recognition system didn’t get the correct address from my Ontario driver’s license. So, I submitted a support ticket—and within minutes, my phone rang. Apple’s support team walked me through it, checked my account, and suggested swapping in a different document. I re-submitted and successfully enrolled! Their responsiveness surprised me in the best way.

But before that, I leaned on Apple’s beginner tutorial for app development ("Scrumdinger" app at developer.apple.com). It covers a big variety of topics: covering architecture, components, and best practices with a clarity that even a seasoned dev can appreciate. I dove into Xcode, started piecing together "FitAssist," and felt the thrill of seeing my first SwiftUI views render. This was my playground now, and I was ready to build.

Building the Core: The MVP Takes Shape

When I started on "FitAssist," I looked to an app I’d used a ton: Smart WOD Timer. It’s a solid tool for CrossFit workouts: clean UI, reliable countdowns, and a simple setup.

But here’s the thing: you probably can’t build something totally new in fitness apps. What you can do is grab solid ideas and make them better. That’s where my MVP began. I wanted a workout timer that felt more flexible, inspired by the actual timer we use at the CrossFit gym. It’s generic enough to handle any workout: CrossFit WODs, Interval trainings, running - not locked into one style.

For the config, I went with a fresh approach: configurable and adapts to whatever you’re training.

The timer itself? It shows what matters mid-workout—time, rounds, a lap button to mark progress—without cluttering your focus. I kept the UI simple and responsive.

Open the app, and you’re ready to sweat - quick load and no screen-hopping to start. That was my rule: instant, practical, no distractions.

I also played with the Health Storage API to pull in pulse data, and draw a graph with it, using SwiftUICharts.

HealthKit permissions seemed tricky at first, but I figured it out, and seeing heart rate tied into the app felt like a win. Coding it in Swift turned out to be exciting once I got rolling. This MVP wasn’t perfect, but it was mine—a fitness tool I’d actually use.

Also, I created a landing page for this project using lovable.dev.

I was so impressed with that service. It helps you make amazing things in just a few prompts and allows you to connect the custom domain and backend database with Supabase. The best thing - you own the code, it all gets pushed to your GitHub repo.

Just as an experiment, I was able to create a dark / light mode button, tied to the system settings, in about half an hour. With just a few prompts and then fixing some styles after.

I used some code assistants, mostly Grok, to write the app code because Grok has many free features. But that is a topic for another article with a code assistant comparison.

The Road Ahead: Planned Features and Lessons Learned

"FitAssist" is just getting started, and I’ve got big plans. Right now, I’m working on a running feature - tracking distance, pace, and location, all plotted on a map. It’s gotta be smooth and useful, something I’d rely on for my own runs. But here’s the deal: handling location and Health data means security’s non-negotiable. I’m not about letting that stuff leak. So, I think I should keep everything on the user’s device using SwiftData, with iCloud sync as an option. It’s all local, all private, data never goes to any external server. I want "FitAssist" to be “privacy first,” because that’s how I’d want my own data treated.

Later, I want to bring in computer vision algorithms with pose recognition and movement detection. Picture this: I prop my phone up, and it films me doing a handstand, then breaks down the move: form, balance, the line. I could re-watch it, tweak my technique. Also, it would be great to have rep counts or feedback on back squats. Similar to what I did and described in my previous article, where I was experimenting with YOLOv11.

Another feature I’m thinking about is a workout generator. Pick your intensity, gear, and favorite moves, and let it generate a custom plan, based on common and well-known WODs, structuring it with warmup - main workout - cooldown and stretch.

Building this MVP taught me a ton—Swift’s features, Apple’s ecosystem, and how to make things work there. FitAssist isn’t just an app - it’s my main hobby project and a sandbox for blending my passions: code and fitness. I am looking forward to implementing many cool ideas. The road ahead is wide open, and I’m ready to run with it.

You can download the app completely free from the AppStore:

https://apps.apple.com/ca/app/fitassist-workout-assistant/id6743733478

In this article, we explore how to stream video from your smartphone to your computer, using it as a webcam. Then, we combine this with OpenCV video capturing and use YOLOv11 for pose estimation and movement detection.

I am using Python, OpenCV and Ultralytics library for coding and Camo Studio as software.

Streaming from smartphone

To emulate real-life gym usage, I decided to use a video from my smartphone for the detection task. Luckily, I found a nice article, that describes how to do exactly that and convert your smartphone to a webcam: https://medium.com/@saicoumar/how-to-use-a-smartphone-as-a-webcam-with-opencv-b68773db9ddd

Long story short, you install Camo Studio on both a laptop and a phone, and connect them:

After that, it could be used in OpenCV as video capture:

    cap = cv2.VideoCapture(1)

    # Your resolution from Camo
    cap.set(cv2.CAP_PROP_FRAME_WIDTH, 720)
    cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 1280)

    while cap.isOpened():
        ret, frame = cap.read()

Pose estimation with YOLOv11

Pose estimation is the task of identifying the specific points of an object, in this particular example, in the human body. The keypoints can represent various parts of the object, such as joints.

There are different models that could be used for this task, such as:

• Ultralytics YOLOv11

• Facebook Sapiens

• Mediapipe from Google

• CoreML

A popular dataset and output format is COCO17, which is widely used in pose estimation.

It looks like many models were trained using this dataset since the output format is the same. However, some of them are using extended COCO-WholeBody: 133 keypoints (17 kps body, 6 kps feet, 68 kps face, 42 kps hands). The Google model outputs 33 key points.

However, for tracking body movements in our task, we only need body keypoints, which are pretty much the same for all models, so I decided to stick to YOLOv11 since it is easy to use.

It outputs the following keypoints:

0: Nose 1: Left Eye 2: Right Eye 3: Left Ear 4: Right Ear 
5: Left Shoulder 6: Right Shoulder 7: Left Elbow 8: Right Elbow 
9: Left Wrist 10: Right Wrist 11: Left Hip 12: Right Hip 
13: Left Knee 14: Right Knee 15: Left Ankle 16: Right Ankle

You can simply call the model on every frame. I used the medium version, which gives about 10 FPS when working on the CPU - enough for a test, anyway.

To draw the result, you can use result.plot(), which will return the copy of the frame, but I decided, that I wanted to build a pipeline, that applies all the changes to the existing frame, so I went one level deeper, and used Annotator utility class, and its kpts function, to draw the keypoints.

The resulting code:

model = YOLO("yolo11m-pose.pt")

# ... capture init code and a loop ...
    results = model(frame)
    # Model can accept a list of images or a single image, but returns a list
    result = results[0]
    keypoints = result.keypoints.xy.tolist()
    keypoints = keypoints[0]  # we are taking the first detected person

    annotator = Annotator(frame)
    annotator.kpts(result.keypoints.data[0], result.orig_shape, 5, True)
    annotated_frame = annotator.result()

    draw_angles(annotated_frame, keypoints)

    cv2.imshow("YOLO Inference", annotated_frame)

draw_angles function calculates the angle in the knee and a hip joint, and draws that single number next to them.

I also added a FPS counter in the top left corner. So the resulting image looks like this:

Movement detection

Movement detection is a more advanced technique, relying on analyzing keypoints across time.

Ultralytics provides a separate Workouts Monitoring module, that can automatically track movements across certain keypoints.

However, since I plan to keep experimenting with different models and even platforms, it is more helpful to implement them yourself.

I wanted to create a simple gesture detector that would use a raised hand for 2 seconds as a signal to start and stop video recording.

I implemented this simple class:

class GesturedVideoCapture:
    is_recording: bool = False
    video_writer: cv2.VideoWriter | None = None
    capture_gesture_start_time: float = 0.0

    GESTURE_HOLD_TIME = 2.0 # 2 seconds

    def process_frame(self, frame, keypoints, current_time):
        nose = keypoints[0]
        nose_seen = nose[0] > 0 and nose[1] > 0
        left_ear_seen = keypoints[3][0] > 0 and keypoints[3][1] > 0
        right_ear_seen = keypoints[4][0] > 0 and keypoints[4][1] > 0

        left_wrist = keypoints[9]
        right_wrist = keypoints[10]

        in_capture_gesture = (
            nose_seen and left_ear_seen and right_ear_seen and
            right_wrist[1] < nose[1] < left_wrist[1]
        )

        if self.is_recording and self.video_writer is not None:
            resized = cv2.resize(frame, (WRITER_WIDTH, WRITER_HEIGHT))
            self.video_writer.write(resized)

        if self.capture_gesture_start_time:
            if in_capture_gesture:
                if self.capture_gesture_start_time + self.GESTURE_HOLD_TIME < current_time:
                    # Hold for GESTURE_HOLD_TIME seconds - starting or stopping capture
                    if self.is_recording:
                        self.stop_and_save_capture()
                    else:
                        self.start_capture()

                    return
            else:
                self.capture_gesture_start_time = 0
        elif in_capture_gesture:
                self.capture_gesture_start_time = current_time


    def start_capture(self):
        print("Start capturing")
        self.is_recording = True
        self.capture_gesture_start_time = 0
        self.video_writer = cv2.VideoWriter(
            f"output_{int(time.time())}.mp4",
            cv2.VideoWriter_fourcc(*'avc1'),
            10,
            (WRITER_WIDTH, WRITER_HEIGHT)
        )


    def stop_and_save_capture(self):
        print("Stop capturing")
        self.is_recording = False
        self.capture_gesture_start_time = 0
        self.video_writer.release()
        self.video_writer = None

That could be added into a main loop pipeline, after draw_angles:

video_capture = GesturedVideoCapture()

# .....
        draw_angles(annotated_frame, keypoints)
        video_capture.process_frame(annotated_frame, keypoints, time.time())

And here is the result: the video writer, that is activated by a raised hand:

The code is available here - https://github.com/hypnocapybara/pose_estimation_test

Artificial intelligence (AI) is transforming the way we consume, create, and share information on the internet. From speech recognition to natural language processing, from computer vision to text summarization, AI tools are enabling us to access and understand vast amounts of data in various formats and languages.

In this article, I will show you how to build your personal Telegram bot using open-source AI tools and Python libraries to monitor, transcribe, summarize, and voice videos from your YouTube subscriptions. I tried to focus on self-hosted solutions and tools, and experimented with voice cloning.

As a desired result, you automatically get short and informative summaries, voiced by your favorite blogger, using voice-cloning technology!

Special attention is paid to app architecture, to make it as close to the real production-ready and scalable service as possible. I used the background workers and job scheduling library RQ (Redis Queue) and its Django integration django-rq. Also, I will show how to integrate the asynchronous Telegram bot library aiogram with modern Django.

Project schema and architecture

Showcased below is a visual representation of the pipeline.

To implement the scheme shown above, I created a Django project, since this library has a nice ORM and out-of-the-box admin interface. django-rq is used for executing tasks.

The whole list of used libraries:

• Django - for the admin web interface and database management

• Django-RQ - for task workers and job execution queue

• pytubefix - to parse YouTube videos and channels

• OpenAI Whisper - for video transcription

• nltk.tokenizer - to split text into sentences

• OpenAI API - to generate key moments with ChatGPT

• aiogram - for Telegram bot

Every step of the pipeline could be replaced with a similar solution because of the modular architecture.

The core logic is described in the main module. It has 2 models. YoutubeChannel:

class YoutubeChannel(models.Model):
    url = models.URLField()
    enabled = models.BooleanField(default=True)
    title = models.CharField(max_length=200, blank=True, null=True)
    last_parsed_at = models.DateTimeField(blank=True, null=True)
    voice_file = models.FileField(upload_to='channels/', blank=True, null=True)

And YoutubeVideo:

class YoutubeVideo(CreatedUpdatedMixin):
    channel = models.ForeignKey(YoutubeChannel, on_delete=models.CASCADE)
    url = models.URLField()
    youtube_id = models.CharField(max_length=100, blank=True, null=True)
    title = models.CharField(max_length=200, blank=True, null=True)
    audio_file = models.FileField(upload_to='videos/audio/', blank=True, null=True)
    transcription = models.TextField(blank=True, null=True)
    transcription_language = models.CharField(max_length=10, blank=True, null=True)
    summary = models.TextField(blank=True, null=True)
    voiced_summary = models.FileField(upload_to='videos/voiced/', blank=True, null=True)

It saves the data for all the pipeline stages.

Tasks are executed in django-rq, and split into 2 queues: default and ai. Default is used for any external API calls, like parsing YouTube or sending Telegram messages. It could have multiple workers and not be resource-consuming. "AI" queue, on the other hand, works with high-performance tasks, like transcription generation, summarization or voicing. In code, tasks are marked with @job decorator, specifying the queue for the task.

Now, let's explore step-by-step how the whole pipeline works.

Youtube monitor

To work with YouTube, there is a nice library called pytube. Unfortunately, it has not been actively maintained in recent times and crashes when working with Channels. So I have found another one, that implements the same functionality and uses the same interfaces - pytubefix.

There are 3 functions in the YouTube Monitor component of the pipeline.

parse_all_channels - loops through enabled channels and creates tasks to parse each of them:

@job('default')
def parse_all_channels():
    print('running parse all channels')

    for channel in YoutubeChannel.objects.filter(enabled=True):
        parse_channel.delay(channel)

parse_channel - processes videos of a particular channel. For simplicity, the current implementation analyzes only the most recent video. It checks if it is not already in the database, and then creates the YoutubeVideo record and runs the pipeline with it:

@job('default')
def parse_channel(channel: YoutubeChannel):
    print(f'running parse channel {str(channel)}')

    yt_channel = Channel(channel.url)
    channel.title = yt_channel.channel_name
    channel.save()

    try:
        last_video = yt_channel.videos[0]
    except IndexError:
        return

    if YoutubeVideo.objects.filter(channel=channel, youtube_id=last_video.video_id).exists():
        return

    new_video = YoutubeVideo.objects.create(
        channel=channel,
        url=last_video.watch_url,
        youtube_id=last_video.video_id,
        title=last_video.title,
    )

    channel.last_parsed_at = timezone.now()
    channel.save()

    parse_video.delay(new_video)

parse_video - fetches and saves the audio stream with the highest bitrate:

@job('default')
def parse_video(video: YoutubeVideo):
    print(f'running parse video {str(video)}')

    yt_video = YouTube(video.url)

    video.youtube_id = yt_video.video_id
    video.title = yt_video.title
    video.save()

    audio_streams = [stream for stream in yt_video.streams if stream.type == 'audio']
    audio_streams = sorted(audio_streams, key=lambda s: s.bitrate, reverse=True)
    if not audio_streams:
        return

    stream: Stream = audio_streams[0]
    buffer = io.BytesIO()
    stream.stream_to_buffer(buffer)
    video.audio_file.save(f'{video.youtube_id}.{stream.subtype}', buffer)
    video.save()

    transcribe_video.delay(video)

Transcription

The next important stage is the audio transcription. Some libraries allow you to work with YouTube-generated captions. But I find that OpenAI's Whisper gives better results. I used the self-hosted solution with a "medium" model. They are also providing API for this if you want to avoid high-performant computations.

The process is pretty straightforward. The only thing to point out is the job timeout, I set it to 1 hour. It usually takes 15-20 minutes to transcribe a 2h video on my personal MSI GF65 Thin laptop.

@job('ai', timeout=60 * 60)
def transcribe_video(video: YoutubeVideo):
    print(f'running transcribe video {str(video)}')

    model = whisper.load_model('medium')
    result = model.transcribe(video.audio_file.path)

    video.transcription_language = result['language']
    video.transcription = result['text']
    video.save()

    summarize_video.delay(video)

Summary

For summarization, I initially tried to use open-source LLMs. Unfortunately, my laptop is too weak for it and cannot run even quantified LLaMA 2 or Mistral 7B. So, I gave up and switched to using ChatGPT's API.

The core idea of the process is that I split the input text into sentences (using nltk.tokenize package), and form blocks of sentences until I reach the context window limit. I then summarize each block separately, with a 2-sentence overlap between blocks.

In the resulting summary, I combine outputs from all the blocks. In some algorithms, you also summarize all the outputs. However, I found that concatenation is better since there is not a lot of overlap of key moments.

This algorithm is quite simple but assumes that the initial transcription is correctly split into sentences. So it could be presented like this sequence of steps:

1. Split the text into a list of sentences

2. Group sentences into slightly overlapped blocks. Each block should fit the LLM context window size

3. Summarize each block using LLM and a special prompt

4. Join resulting outputs into the generic summary

The code and LLM prompts can be found in the related module in my repository

Voicing

My core idea was that people want to hear the voice of their favorite blogger. That's why I was oriented on tools that provide a voice cloning feature. Some libraries can do that. For example, VALL-E looks promising, and would be interesting to try it later. But I end up using Coqui TTS. I tried to use their studio, and the internal models look really awesome! But even open-source models are pretty good, providing a quality result.

For simplicity, I uploaded the speaker prompt to the YoutubeChannel model, but it could be extracted from the audio stream, based on intervals, returned by Whisper.

The resulting function:

@job('ai', timeout=20 * 60)
def voice_summary(video: YoutubeVideo):
    from apps.telegram.tasks import send_video_notifications

    print(f'running voice summary {str(video)}')

    if not video.summary:
        return

    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    tts = TTS('tts_models/multilingual/multi-dataset/xtts_v2').to(device)
    _fd, temp_filename = tempfile.mkstemp()
    try:
        tts.tts_to_file(
            text=video.summary,
            speaker_wav=video.channel.voice_file.path,
            language=video.transcription_language,
            file_path=temp_filename,
        )
        with open(temp_filename, 'rb') as file:
            video.voiced_summary.save(f'{video.youtube_id}.wav', file)
            video.save()
    finally:
        os.remove(temp_filename)

    send_video_notifications.delay(video)

Sending results

Now we have all the data. The last step: deliver it to the user. For that purpose, I am using aiogram library. For more info on basic bot setup, feel free to check my last article.

The tricky part is how to run an async bot in the sync-by-default Django environment and vice-versa, how to execute sync Django ORM commands inside the async bot.

So the bot entry point is this management command python manage.py run_bot:

import asyncio

from django.core.management import BaseCommand
from django.conf import settings

from apps.telegram.bot import run_bot


class Command(BaseCommand):
    def handle(self, *args, **options):
        asyncio.run(run_bot(settings.TELEGRAM_BOT_TOKEN))

The implementation of async run_bot is also quite simple:

async def run_bot(token: str) -> None:
    dp = Dispatcher()

    dp.message(CommandStart())(command_start_handler)
    dp.message()(echo_handler)

    bot = Bot(token, parse_mode=ParseMode.HTML)
    dp.message.middleware(UserMiddleware())
    await dp.start_polling(bot)

Since the service purpose is mostly to transfer information from the server to users, we need just any handler, to register user. And TelegramUser creation happens in the UserMiddleware:

class UserMiddleware(BaseMiddleware):
    async def __call__(
        self,
        handler: Callable[[Message, Dict[str, Any]], Awaitable[Any]],
        event: Message,
        data: Dict[str, Any]
    ) -> Any:
        data['user'] = await TelegramUser.get_or_create_from_telegram_user(event.from_user)
        return await handler(event, data)

get_or_create_from_telegram_user uses new asynchronous Django ORM functions: aget and acreate which allow you to execute database queries from an async context. Now, it is enough to send the "/start" command to the bot, and the user should be created in the database. Plus, the bot can send notifications to the user.

Running & getting a result

The most exciting part - seeing how every cog builds up into a mechanism, and it all starts working together! There are a certain amount of processes to be run for the pipeline:

• Web server with an admin panel

  • python manage.py runserver

• RQ workers for AI tasks

  • python manage.py rqworker ai

• RQ workers for other tasks

  • python manage.py rqworker default

• RQ scheduler

  • python manage.py rqscheduler

Here is an example of running processes and consumed resources:

And the example of the resulting message (using GPT-4 for summary):

Conclusion & future improvements

In the end, I got a working prototype that could be easily Dockerized and run as a personal service. Especially considering that with so many models available online, you might not need to run high-performance computing on your own. So, any VPS could deal with simple API calls.

The biggest problem that I see now is the quality of summarized key moments. During some tests, I realized that ChatGPT 3.5 can mix up facts, so you cannot fully trust the resulting information to be 100% accurate, especially if it is about daily news or current events. ChatGPT-4 handles that much better, and the resulting quality is quite impressive. gpt-4-1106-preview model has a context window of 128k tokens, which is enough to fit almost any video in one chunk. But it is expensive - costed me 0.20$ per one API call for a medium-size transcription. So, it might be necessary to play more with prompts or try different LLMs.

Also, besides summary accuracy, to make it 100% production-ready, I would improve things like:

• Add mutexes to tasks

• Add tasks error handling

• Dockerize the project

• Use webhooks, instead of polling for the Telegram bot

Regardless, this working prototype is an interesting playground. Source code is available in GitHub.

Hopefully, you enjoyed reading this!

Disclaimer

This article and the content herein, including code, example processes, and the use of AI tools for voice cloning, are intended for personal information and educational purposes only. Unauthorized distribution of generated voice-cloned content without the author's explicit permission is strictly prohibited. Before using any of the mentioned tools in commercial products, consult with their license agreement. All credit goes to the rightful owners.

I started my programming path from the book "C++ for Dummies". Then I solved programming tasks and made my first steps in different computer science areas using this language.

I have my favorite game: "Half-Life 2", and during high school / first year in university, I tried making mods for it. And because I was really bad at modelling and level design, I practiced modifying the game logic, adding new entities and implementing some features in the game code. And the C++ code of the "Source Engine" (game engine developed by Valve company and used in Half-Life games) was a really nice example of best practices in objective-oriented programming. I was very impressed with how logical and straightforward that code is. After typical examples in programming books and articles, it was an absolutely new view. I realized, that the code could be abstract, human-readable and simple. And operate with objects, representing real-world entities, instead of just variables.

That's why I feel really warm about C++, game development / simulations, and graphics visualization. And in this article, I will implement and describe a simple game about cell colonies.

Game rules

The idea for the game comes from John Conway's "the game of life", Spore and just the nature of bacterial columns.

There are 2 objects: a food base and a cell / bacteria.

The food base has a limited amount of supply and a limited amount of cells, that could feed from it. It has an "active radius", so the cell can take food from the base when being within this radius. The limited capacity and amount of food will motivate cells to expand the colony and move toward other bases.

Cell / bacteria have these features:

• Limited lifetime, after that cell dies

• Limited health, after some attacks cell dies

• After eating a needed amount of food, the cell splits, creating 2 new cells

• When hungry, the cell moves to a nearby food base

• When seeing other colony's cells, attacks them

• Collides with other cells

So generally, the cell is a basic unit, like in every RTS game.

Objects

Let's finally put that rules into the code.

Since both game entities have common props: position, a link to the world, they could go into a base class Entity:

class Entity {
    public:
    Entity(World* world, Point2 pos);
    virtual void Process() = 0;
    inline Point2 GetPosition();

    protected:
    Point2 position;
    World* world;

    friend class World;
};

The Process function is triggered by the world update and should handle the object's internal state changes.

For food, need to describe the amount, radius and track cells, that enter or leave the food base:

class Food : public Entity {
    public:
    Food(World* world, Point2 pos, int maxAmount, float radius, int maxCellsCount);

    void Process();
    void Die();

    inline float GetRadius();

    inline int GetMaxCellsCount();
    inline int GetCurrentCellsCount();
    inline bool HasFreeSpots();
    inline bool HasAmountAvailable();

    bool IsCellInActiveZone(Cell* cell);
    bool HasAvailableAmount();
    void HandleEaten();
    void CellLeave(Cell* cell);
    void CellOccupy(Cell* cell);

    protected:
    int currentAmount = 0;
    int maxAmount = 0;
    std::vector<Cell*> cells;
    int maxCellsCount = 0;
    float radius = 0;

    friend class World;
};

Cells need functions and variables to track health, starvation, attacks, split, etc. So the class declaration is bigger, but the implementation of each function should be simple and obvious, so all this logic is assembled piece-by-piece, which is a nice benefit of abstract programming

class Cell : public Entity {
    public:
    Cell(World* world, Point2 pos, int ownerId, std::map<std::string, std::string> params);

    void Process();

    bool CanSplit();
    void Split();

    bool IsTooHungry();
    bool IsTooOld();
    inline bool IsOutOfHealth();
    void Die();

    bool IsInCooldownFromAttack();
    bool CanAttack(Cell* otherCell);
    void Attack(Cell* otherCell);
    void TakeDamage(float amount);

    bool CanEat();
    void Eat();
    void OccupyFoodBase(Food* food);
    void LeaveFoodBase();
    bool IsWithinFoodBase();
    bool IsInCooldownFromFeed();

    inline float GetRadius() {return this->radius;}
    inline int GetUserId() {return this->userId;}

    // === Should go to AI module ===
    enum Intention {
        Nothing,
        WannaFeed,
        WannaAttack,
        Patrolling
    };

    void FormDecission();
    bool HasReachedThePoi();
    void MoveToPoint(Point2 poi, float poiRadius);
    void StopActivity();

    protected:
    // eat
    Food* feedBase = nullptr;

    // health
    float healthCurrent = 0;
    float healthMax = 0;
    float birthTime = 0;
    float lifetime = 0;

    // move
    bool inMove = false;
    Point2 poi;
    float poiRadius;
    Vector2 velocity;
    float speed = 0;
    float radius = 0;

    // feed & fission variables
    // when reach feedMax - self-dublicate
    int feedCurrent = 0, feedMax = 0;
    float lastFeedTime = 0; // last global time when cell feeded
    float feedCooldown = 0; // cooldown between feed actions (when cell cannot act)
    float feedInterval = 0; // min interval before feed actions
    float maxTimeWithoutFood = 0;
    float foodDetectRadius = 0;

    // attack variables
    float attackRange = 0;
    float attackPower = 0;
    float lastAttackTime = 0;
    float attackCooldown = 0;
    float enemiesDetectRadius = 0;

    // belonging
    int userId = 0;

    // === Should go to AI module ===
    Intention intention;

    friend class World;
};

Ideally, all the decision-making parts should go into a separate AI class, that would handle only intension-forming logic.

It is a lot of code, but just take a look at the Process function, it is so abstract and human-readable:

void Cell::Process() {
    if (this->feedBase && !this->IsWithinFoodBase()) {
        this->LeaveFoodBase();
    }

    if (this->IsOutOfHealth() || this->IsTooHungry() || this->IsTooOld()) {
        return this->Die();
    }

    if (this->IsInCooldownFromAttack() || this->IsInCooldownFromFeed()) {
        this->inMove = false;
        return;
    }

    if (this->CanSplit()) {
        return this->Split();
    }

    this->FormDecission();
}

And the main object - World which is just a container for cells and food, that runs the simulation and implements functions to manipulate it (but not to render it! Which is important, to split those 2 processes)

class World {
    public:
    World(float width, float height);
    inline float GetCurrentTime();
    void Step(float delta);

    Cell* CreateBacteria(Point2 position, int ownerId);
    Food* CreateFood(Point2 position, int maxAmount, float radius, int maxCellsCount);
    void DestroyCell(Cell* cell);
    void DestroyFood(Food* food);

    const std::vector<Cell*>& GetCells();
    const std::vector<Food*>& GetFood();

    protected:
    float width, height;

    std::vector<Cell*> cells;
    std::vector<Food*> food;

    float currentTime = 0;
};

The main idea here - you have a special class, that can do the simulation, and it is separated from render. Potentially, that could even be used to train a neural network with a positive reinforcement algorithm, that will process cell decisions.

Also, basic cell collisions were implemented. In real usage, better to trust that logic to a separate physics engine (like box2d), but for a simple demo, it is fine to remember a simple 2D math and process collisions manually.

The article can even end here, but for the game, you need user input to manipulate the world, plus it needs to be rendered.

Render

When it comes to rendering hardware-accelerated graphics, you usually have to write a lot of extra code, before you can actually draw something. Such as:

• A code to create a window and obtain an OpenGL context

• OpenGL code to bind vertex buffer, vertex and fragment shaders, map coordinates and many other different instructions

That's why I would like to use any library, that will encapsulate all this logic and give a simple API to draw objects and handle keyboard and mouse input. Plus, a nice bonus if it is cross-platform (including web). I searched a little bit and found a perfectly matching library - piksel.

Everything that you need is just to inherit the BaseApp class and implement needed functions:

class App : public piksel::BaseApp {
public:
    App(World* w, int width, int height);
    void setup();
    void draw(piksel::Graphics& g);
    void keyPressed(int keycode);
    void keyReleased(int keycode);
    void mousePressed(int code);
    void mouseMoved(int x, int y);

protected:
    void ProcessCamera(float step);
    bool IsSeenByCamera(const Point2& point);

    void DrawCells(piksel::Graphics& g);
    void DrawFood(piksel::Graphics& g);

    World* world;
    std::chrono::system_clock::time_point lastUpdateTime;
    Point2 cameraPos;
    int pressedKeys;
    int mouseX, mouseY;
};

To draw primitives, you can use simple functions g.rect, g.ellipse, etc. To simplify, let's just draw cells as circles (of a different color) and food as white rect.

As a result, we can have cell colonies epic battles:

So the resulting project structure is as follows:

The source code is available on GitHub.

Maybe when having some time, I will continue to develop that game. There are different possible directions:

• Use box2d as a physics engine (it would be a nice experience)

• Play more with the best cells and food params

• Use sprites for game entities

• Implement UI, cells selection and control (like in RTS games)

• Implement different levels with complicated relief and a path search algorithm to allow cells to move there

Telegram is a cloud-based mobile and desktop messaging app with a focus on security and speed. For me, Telegram - is not just a messenger. It is the first app I open in the morning to read the news. And I am making a significant part of daily communication with Telegram. Plus, it is a developer-friendly service with an open API, so you can create your own clients and apps. More than, Telegram creators are encouraging it and have published a library to speed up that process.

Bots

Bots are third-party applications, hosted on your own server and run inside Telegram. Users can interact with bots by sending them messages, commands and inline requests. You implement the whole bots' logic and control their interaction with users using HTTPS requests to Telegram's Bot API. For example, if you have a website and monitor its availability. You can write a simple bot that will send you an alert if it's offline. There is a nice article about bots on the official website

Creating a bot

To create your own bot, you need to message a special bot - BotFather. In this article, we will create our own bot, that will implement a to-do list app. It should:

• keep user's notes in the database
• delete expired items (let's say that 1 hour is the expiry period)
• be able to fetch and send the whole list of saved notes

So, let's talk to BotFather:

Now, we have a bot token, it's everything we need. Let's dive into the code. Important code listings will be provided during the article. The whole repo link is at the bottom.

GINO ORM

First, let me introduce you to the other subject of this article - GINO ORM. Gino is a lightweight asynchronous ORM built on top of SQLAlchemy core for Python asyncio. GINO 1.1 supports PostgreSQL with asyncpg, and MySQL with aiomysql.

Create a new poetry project and add the required dependencies:

poetry new hashnode-todo
cd hashnode-todo
poetry add python-dotenv aiogram gino emoji

Then let's create models.py (and I would prefer to rename the project folder to "bot"):

from gino import Gino
from sqlalchemy import func

db = Gino()


class User(db.Model):
    __tablename__ = 'users'

    id = db.Column(db.Integer, primary_key=True)
    telegram_user_id = db.Column(db.String(length=200))
    created_at = db.Column(db.DateTime(timezone=True), default=func.now())
    first_name = db.Column(db.String(length=255))
    last_name = db.Column(db.String(length=255))
    username = db.Column(db.String(length=255))


class Note(db.Model):
    __tablename__ = 'notes'

    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
    created_at = db.Column(db.DateTime(timezone=True), default=func.now())
    text = db.Column(db.Text)

Also, we need to define a settings file:

import os
from dataclasses import dataclass
from dotenv import load_dotenv


load_dotenv()


@dataclass
class Settings:
    DATABASE_CONNECTION: str
    TELEGRAM_BOT_TOKEN: str


settings = Settings(
    DATABASE_CONNECTION=os.getenv('DATABASE_CONNECTION'),
    TELEGRAM_BOT_TOKEN=os.getenv('TELEGRAM_BOT_TOKEN'),
)

And simple .env file:

DATABASE_CONNECTION=postgresql://postgres@localhost/hashnode_todo
TELEGRAM_BOT_TOKEN=

Now we are ready to work with a database.

For this tutorial, we will initialize the database with gino.create_all() call. In real usage, the migration tool "Alembic" is recommended by GINO authors (and it was created by SQLAcheme author). Or you could assume, that other applications manage the database, so you only define the schema for the already existing database.

The database initialization file:

import asyncio

from bot.models import db
from config import settings


async def main():
    await db.set_bind(settings.DATABASE_CONNECTION)
    await db.gino.create_all()
    await db.pop_bind().close()


if __name__ == '__main__':
    asyncio.get_event_loop().run_until_complete(main())

Now you can run it with poetry run python bot/create_models.py

GINO queries

Let's think about the functions list, that we gonna need. And we know, that Telegram always has the user_id to identify the sender. So we need:

• add_note(user, text)
• get_notes(user)
• process_expired_notes()

And the simple service code with all required basic operations:

from datetime import datetime, timedelta
from typing import List

from bot.models import User, Note


async def add_note(user: 'User', text: str) -> 'Note':
    return await Note.create(
        user_id=user.id,
        text=text
    )


async def get_notes(user: 'User') -> List['Note']:
    return await Note.query.where(Note.user_id == user.id).gino.all()


async def process_expired_notes():
    await Note.delete.where(
        Note.created_at < datetime.now() - timedelta(days=1)
    ).gino.status()

Now we have all database management functionality, and we can use it in the bot

aiogram

aiogram is a pretty simple and fully asynchronous framework for Telegram Bot API written in Python 3.7 with asyncio and aiohttp.

If your bot needs to handle many requests, then asynchronous is your parachute.

Basic bot

Let's start with a simple bot, replying with "hello" on your /start command. The proposed structure is probably not ideal, but very scalable. I use it in some complex projects.

First, we need a base runner file main.py in the project root:

from aiogram import executor

from bot.models import db
from bot.main import dispatcher
from config import settings


async def on_startup(dispatcher):
    await db.set_bind(settings.DATABASE_CONNECTION)


async def on_shutdown(dispatcher):
    await db.pop_bind().close()


if __name__ == '__main__':
    executor.start_polling(
        dispatcher=dispatcher,
        skip_updates=True,
        on_startup=on_startup,
        on_shutdown=on_shutdown,
    )

And file for dispatcher and importing dialogs (bot/main.py):

from aiogram import Bot
from aiogram.dispatcher import Dispatcher
from config import settings


bot = Bot(token=settings.TELEGRAM_BOT_TOKEN)
dispatcher = Dispatcher(bot)
Dispatcher.set_current(dispatcher)


import bot.dialogs

Finally, the first dialog file for the "start" command:

from aiogram import types
from aiogram.dispatcher import Dispatcher


dp = Dispatcher.get_current()


@dp.message_handler(commands=['start'])
async def start_handler(message: types.Message):
    await message.answer('Hello from bot!')

Then just run it with poetry run python main.py

Now our simple bot can send the simple answer:

Middlewares

Middlewares are called on every message, so you can do throttling, logging or add variables to all future handlers. Let's add a middleware, that will get or create a user in the database.

First, adding a new service with one function - get_or_create_user:

from bot.models import User


async def get_or_create_user(
        user_id: str,
        first_name: str,
        last_name: str,
        username: str,
) -> ('User', bool):
    created = False
    user = await User.query.where(User.telegram_user_id == user_id).gino.first()
    if not user:
        user = await User.create(
            telegram_user_id=user_id,
            first_name=first_name,
            last_name=last_name,
            username=username
        )
        created = True

    return user, created

Second, the middleware itself:

from aiogram import types
from aiogram.dispatcher.middlewares import BaseMiddleware

from bot.services.users import get_or_create_user


class UserStorageMiddleware(BaseMiddleware):
    def __init__(self, database):
        self.database = database
        super().__init__()

    async def on_process_message(self, message: types.Message, data: dict):
        user = message.from_user
        db_user, _created = await get_or_create_user(
            user_id=str(user.id),
            first_name=user.first_name,
            last_name=user.last_name,
            username=user.username
        )
        data['user'] = db_user

Pay attention to conditionally-added variables to the data dictionary. If for some reasons, the 'user' is not set in the middleware, and you are declaring it in the handler, you will get an exception!

Third, add this middleware to the dispatcher:

dispatcher = Dispatcher(bot)
Dispatcher.set_current(dispatcher)

dispatcher.middleware.setup(UserStorageMiddleware(database=db))

And you can now use the user variable in handlers. Let's make our bot reply with the user's first name:

@dp.message_handler(commands=['start'])
async def start_handler(message: types.Message, user: 'User'):
    await message.answer(f'Hi, {user.first_name}!')

Keyboards and state

Keyboards are the last thing we need to implement for the planned note-taking bot. They allow you to show pre-defined actions and easily interact with the bot in one tap.

Let's add a file with a function to return the keyboard (bot/keyboards.py):

from aiogram import types
from aiogram.utils.emoji import emojize

from bot.texts import KEYBOARDS


def main_keyboard() -> types.ReplyKeyboardMarkup:
    markup = types.ReplyKeyboardMarkup(resize_keyboard=True)
    markup.row(
        types.KeyboardButton(emojize(KEYBOARDS['list_notes'])),
        types.KeyboardButton(emojize(KEYBOARDS['add_note']))
    )
    return markup

And a small file with texts:

RESPONSES = {
    'welcome': 'Hello, {user}, I am note taking bot for hashnode',
}

KEYBOARDS = {
    'list_notes': ':spiral_notepad: List notes',
    'add_note': ':heavy_plus_sign: Add note',
}

Plus, modify the start command handler:

@dp.message_handler(commands=['start'])
async def start_handler(message: types.Message, user: 'User'):
    await message.answer(
        RESPONSES['welcome'].format(user=user.first_name),
        reply_markup=main_keyboard(),
    )

And that simple steps allow you to make the bot more interactive:

Just 2 more steps to finish! Stay tuned :)

Pressing the button just sends its text. So we can use the Text filter in the message handler, to catch that event. Based on that, let's add another dialog file (bot/dialogs/list_notes.py), which will return all your notes

from aiogram import types
from aiogram.dispatcher import Dispatcher
from aiogram.dispatcher.filters import Text
from aiogram.utils.emoji import emojize

from bot.texts import KEYBOARDS
from bot.models import User
from bot.services import notes as notes_service
from bot.keyboards import main_keyboard


dp = Dispatcher.get_current()


@dp.message_handler(Text(equals=emojize(KEYBOARDS['list_notes'])))
async def handler_list_notes(message: types.Message, user: User):
    notes = await notes_service.get_notes(user)

    if not notes:
        answer_text = "You don't have any actual notes"
    else:
        notes_text = '\n\n'.join([
            f'{n.created_at.isoformat()}\n{n.text}' for n in notes
        ])
        answer_text = 'Your notes:\n\n' + notes_text

    await message.answer(
        answer_text,
        reply_markup=main_keyboard()
    )

For adding notes - we gonna use the state. If any state is activated, only related handlers can process the message. So we need to declare the State class and a handler, that will set it. Plus, we gonna replace the keyboard, showing only one "Cancel" button:

class AddNoteState(StatesGroup):
    enter_text = State()


@dp.message_handler(Text(equals=emojize(KEYBOARDS['add_note'])))
async def handler_add_note(message: types.Message):
    await AddNoteState.enter_text.set()
    await message.answer(
        RESPONSES['add_note']['prompt'],
        reply_markup=cancel_keyboard(),
    )

Then we just define the handler for the state, which will save the entered text as a new note:

@dp.message_handler(state=AddNoteState.enter_text)
async def handler_note_text(message: types.Message, state: FSMContext, user: 'User'):
    await notes_service.add_note(user, message.text)
    await state.finish()
    await message.answer(
        RESPONSES['add_note']['success'],
        reply_markup=main_keyboard(),
    )

A full resulting bot interaction:

A full source code is available on GitHub