In this lecture we finally start programming "Micro City Builder" in the Godot engine.

After completing this lecture, you will be able to:

• Set up a new Godot project for web publication with good folder organization.

• Establish a basic asset pipeline (set mesh save path) to transfer 3D models from Blender into Godot using glTF exports, addressing issues like multiple UV maps.

• Source and apply PBR textures.

• Investigate issues in real-time, like the sRGB to linear color space issue discovered during the video.

• Implement custom shaders for advanced visual effects like texture blending using noise.

• Design and implement a basic user interface (UI) using a Canvas Layer and Control nodes.

• Manage game states effectively by using an autoloaded singleton script, understanding the nuances of node loading order.

• Implement camera controls and camera-to-world raycasts for object placement.

• Create a visual cursor that follows the mouse on the ground and snaps to a 10-meter grid.

This lecture focuses on optimizing rendering performance for the tile-based system in this game. It covers a hands-on approach to debugging and refining game assets.

After completing this lecture, you will be able to:

• Understand and apply grid-based placement systems: Students will learn how to define and use a grid system, including identifying the 0,0 tile and calculating object positions relative to the grid center.

• Perform texture editing for visual consistency: Students will gain experience using GIMP to adjust textures, using the smudge and clone tool.

• Implement efficient rendering using multi-meshes: A core concept covered is the use of MultiMeshInstance3D to batch draw calls and improve performance by instancing multiple copies of a mesh from a single draw call.

• Develop an algorithm for dynamic mesh placement

• Troubleshoot and optimize game performance

The primary focus of this lecture is on refining the building experience and improving the underlying game systems and asset management.

After completing this lecture, you will be able to:

• Manage Game State and UI Interaction:

• Utilize mouse entered and mouse exited events to control game actions dynamically based on UI interaction.

• Programmatically attach signals to multiple UI elements to ensure consistent behavior.

• Enhance Visual Feedback with Custom Assets and Shaders:

• Create and export custom cursor meshes from Blender that accurately represent the shape of the building being placed (e.g., a house-shaped cursor instead of a simple cube).

• Explore new shader materials, including exploring Fresnel effects and simpler alpha blend shaders.

• Design custom RefCounted classes (e.g., BuildItem) to help develop a cleaner codebase.

• Understand the difference between class properties and instance properties and their implications for memory usage.

• Use efficient data structures like hashmaps to track tile positions and quickly check for overlaps.

• Manage instances of a MultiMeshInstance3D

This lecture showcases more changes on the game's UI/UX and core mechanics. Complex architectural challenges always arise during systemic games like builders- in this lecture, we look at issues encountered during development and how to reason and test your way out of them.

After completing this lecture, you will be able to:

• Adjust camera and movement mechanics to enhance player navigation.

• Understand the logic behind capturing mouse positions, raycasting from the camera in screen space, and snapping rotations to fixed increments.

• Rotate offset vectors for tile based mapping systems.

• Implement object deletion.

• Use optimization strategies like queue_freeing MultimeshInstance3Ds when their visible_count drops to zero.

• Gain practical debugging and problem-solving skills

• Continue to work on game design throughout the iteration process: for this game in particular, concepts like game economy, property tax, road connections for commercial buildings, and the decoupling of the build system from core game data.

This lecture focuses on the implementation of core game mechanics (the simulation) for this city builder game, moving beyond initial terrain loading and object placement.

After completing this lecture, you will be able to:

• Program an in-game financial system that tracks and displays the player's current cash amount.

• Take out loans, calculate balances, and implement an interest mechanic

• Create a dynamic time simulation system that:

• Converts real-time seconds into game time

• Allows for variable simulation speeds (1x, 2x, 4x, 8x, 16x, and a 50x debug speed).

• Manipulate time data derived from a Unix timestamp.

• Format numerical values for display on the HUD (money, time)

This lecture goes into more detailed about the data-oriented design for tracking all residential and commercial buildings in the game. Although the game only implements 1 type of residential building and 2 types of commercial buildings, the system is generalizable, and adding new types requires no code changes - just data changes.

After completing this lecture, you will be able to:

• Define and manage game state effectively by identifying and structuring key data points for complex game entities like residential and commercial buildings. This sets the stage for housing more complicated data, like the state of every single person (eventually, defined as zombies) in the game.

• Set up simulation mechanics, including time-based triggers: daily, monthly etc.

• Population, property tax, some more basic sim variables.

• Define abstract goals, like the "happiness" goal in the game, as well as workplace assignment (new residents getting assigned to work at particular places).

• Develop basic game economic models, incorporating concepts like property taxes, corporate taxes, revenue, expenses, and market influence on business profitability. Understand that this level of detail in a simulation can make a game interesting.

This lecture focuses on solving two primary problems within the game's development: managing data linking for build items and implementing an interactive hover-over element (tooltip) - a fairly important mechanic in strategy and city builder games.

After completing this lecture, you will be able to:

• Understand and implement data linking strategies for complex game objects, specifically between has maps (for fast lookup) and arrays (for fast iteration).

• Make design decisions regarding data structures and memory management, considering the impact of references and object freeing. You will also explore alternatives like using indices versus direct references.

• Create hover-over UI tooltips (important for city builders) to show build item information and build progress.

This episode provides an in-depth look into implementing a pathfinding system (AStar).

After completing this lecture, you will be able to:

• Implement A* pathfinding using Godot's AStarGrid 2D, including setting up the grid, managing solid and non-solid points, and retrieving paths between specific points.

• Develop fundamental city builder game mechanics like automatically connecting houses to businesses based on pathfinding results and proximity, while considering performance implications of iterative checks.

This lecture focuses on vertex and animated textures (VAT), a highly optimized technique for animating a large number of characters - it particularly helps on web.

After completing this lecture, you will be able to:

• Understand the core concept of Vertex Animated Textures (VATs).

• Prepare and clean a 3D model in Blender for use in this kind of pipeline.

• Rig a character using Rigify.

• Prepare a rig for animation retargeting.

• Utilize Rokoko and Mixamo for animation.

• Prepare a rig for animation retargeting and retarget Mixamo animations in Blender.

• Use a modified version of the Blender VAT plugin to export the textures - understanding how each column in these textures represents a unique vertex and each row represents an animation frame.

• Understand the second UV map (UV2), which is crucial for uniquely mapping each vertex to its corresponding data in the VATs.

• Implement and use the VAT shader in a game engine.

• Apply VAT to optimization techniques: the main point of using VATs in this way, for this game, is so that 1000s of animated Zombie characters, each in their own animation state, can be rendered.

This lecture focuses on the implementation of dynamic, animated characters, specifically our walking "zombie" character, using VATs. Multiple animation states are possible (and extremely efficient) to implement if your models have reasonably low poly counts.

See VAT Part 3 for multi-state VAT animation (walk and idle cycles).

After completing this lecture, you will be able to:

• Implement character spawning and single-state animation (using VAT).

• Utilize multi-meshes for efficient rendering of multiple character instances

• Set up and manipulate custom instance data for multi-meshes and understanding its role in fragment shaders for visual effects.

• Implement a basic character movement algorithm that allows characters to wander randomly between defined tile positions, as well as along the road path defined by the AStar Grid.

The game concept has finally emerged as a zombie city-builder, featuring a unique twist where the inhabitants are zombies! (Also the case that these zombies only eat mushrooms rather than brains). This lecture also goes through a practical way of showing "videos" in Godot, which aren't really videos, but rather playing frame-by-frame of a video in an image texture in an efficient way. The lecture uses ffmpeg.

After completing this lecture, you will be able to:

• Have a broad understanding of how to use tools like Inkscape to create vector art for your games.

• Use video editing tools like OBS and ClipChamp to grab screen recordings of your game's gameplay.

• Use ffmpeg to slice up videos, and break it down frame by frame.

• Bring this content into the Godot engine to "play" the video.

• Understand the limitations of the OGV format and why it isn't ideal in the current version of Godot.

This lecture concludes the section on Vertex Animated Textures; it looks at how to extend VAT to multi-state animations, and specifically for this game, switching between idle and animated states.

After completing this lecture, you will be able to:

• Create multi-state VAT animations in Blender and export them.

• Import the VAT animation into Godot, and set up a GDshader to be able to run the multiple states.

• Use CUSTOM_INSTANCE data associated with a multimesh to drive individual animation states for each instance (zombie) of the multimesh.

This is a short episode showing how the road asset was fixed - the original asset had a number of design issues.

After completing this lecture, you will be able to:

• Use GIMP to create a seamlessly tiled texture and apply it in Godot.

This episode discusses how the vertical slice for "ZTown" was polished and deployed.

After completing this lecture, you will be able to:

• Implement sound effects and music in a Godot game.

• Understand shader caching for Godot's compatibility renderer - a necessary step to reduce stuttering on Web.

• Use vertex "masking" to allow instances of a multimesh to have unique properties. In this game, each farm plot has mushrooms that can grow up through the soil. Vertex masking is used to make this effect.

• How to implement an in-progress building shader.