Completed
Rotating around ball in code and understanding light versus heavy decisions
Class Central Classrooms beta
YouTube playlists curated by Class Central.
Classroom Contents
Godot 4 - 3D- Code Architecture Course in a Single Video - Fully Explained
Automatically move to the next video in the Classroom when playback concludes
- 1 Intro:
- 2 Importing assets and why pool?:
- 3 Setting up Billiard Table and import settings:
- 4 Reorganizing FileSystem structure:
- 5 Basic lighting and explaining 3D axes:
- 6 Setting up the Ball scene:
- 7 Auto-generating collision shapes versus making one manually:
- 8 Assigning material textures in the Inspector:
- 9 Assigning texture in the code:
- 10 Creating a unique material to fix shared references:
- 11 Deciding on how we should approach our gameplay system:
- 12 Setting up the play system and deciding on what script hits the ball:
- 13 Starting play system code with shooting the ball:
- 14 Aiming and stick system nodes 1 - fixing import orientation:
- 15 Aiming and stick system nodes 2 - positioning camera and stick:
- 16 Aiming and stick system nodes 3 - rotating around the ball:
- 17 Rotating around ball in code and understanding light versus heavy decisions
- 18 Organizing code with subroutines and hiding and fixing the mouse:
- 19 Aiming and stick system nodes 4 - manipulating nodes to optimize local space:
- 20 Moving stick within clamped positions in code:
- 21 Strongly typing, static typing, and the walrus operator:
- 22 Understanding basis to shoot the ball in the aim direction:
- 23 Using AnimationPlayer to tween stick shooting animation:
- 24 Hitting ball at the end of the animation:
- 25 Having variable starting animation key:
- 26 Communicating between different systems using custom signals:
- 27 Creating wall colliders for the playing surface:
- 28 Correcting bounce and deceleration with PhysicsMaterial and damping:
- 29 Implementing variable shot power using lerp:
- 30 Preventing wall clipping with physics step vs continuous collision detection:
- 31 Global values as class constants vs static variables vs object references:
- 32 Spawning balls and assigning respective textures in the code:
- 33 Procedurally spawning the balls in a triangular ball rack:
- 34 Using enumerators to establish ball types:
- 35 Setting a maximum y velocity to keep balls on the table surface:
- 36 Starting the gameplay finite state machine, booleans vs enums vs state pattern:
- 37 Deciding on way to check if all balls have stopped, for readability and scalability:
- 38 Establishing a readable, scalable system for processing the game rules:
- 39 Completing a player's turn with signals:
- 40 Considering which systems should set the play state:
- 41 Creating dynamic resources for sharing state instead of a global singleton:
- 42 Implementing the new game state resource to share state between systems:
- 43 Setting up the scene for table pockets:
- 44 Handling what happens when a ball has been potted by checking object identity:
- 45 Devising a cheat mode to make testing ball pocket rule test mechanics easier:
- 46 Working with physics engine quirky properties to stop a ball:
- 47 Setting up the HUD label nodes system and shared saved TextSettings:
- 48 Using a setter to emit whenever the play state has changed, and updating text:
- 49 Nested classes and subclasses to store what happened during a shot:
- 50 Setting up processing if a solid or stripes ball was potted during a shot:
- 51 Devising how to communicate which player is solids and which is stripes:
- 52 Forcing Godot to update to recognize new enum values
- 53 Checking and setting player suits while using some programming tricks:
- 54 Making rules process only under the correct state and with fresh occurrences:
- 55 Showing player suit in HUD by extracting the string names of the BallType enum:
- 56 Allowing player to keep their turn if they hit in a ball of their suit:
- 57 Setting up fouls and a placeholder for ball-in-hand mode, with basic debugging:
- 58 Tracking down and fixing a race condition by deferring a function call:
- 59 Using lambda functions to handle irregular cases of code execution:
- 60 Making ball hittable after going back on table, and forcing turn change on foul:
- 61 Devising simple and flexible way to keep track of balls remaining per player:
- 62 Setting up win condition by checking eight ball potting and balls remaining:
- 63 Handling game ended without bloating game state, and displaying result:
- 64 Fix bugs and wrap up game ran out of characters for timestamps:
- 65 Thank you!:
