The Complete LibGDX Game Course Using Java

Download the Java JDK 8 for your platform and install it. Download Android Studio from the official Android developer site and install it.

Open Android Studio, create a new project, set up a Java Tester class with a main method, and print messages to the console to visualize a simple Java program.

Learn how to declare and use variables in Java for LibGDX games, including float, double, integer, string, and boolean, with naming, assignment, and comments to document code.

Master basic arithmetic with integers and floats, perform addition, subtraction, multiplication, and division, and print results with string concatenation, while using shortcuts like += and ++ in code.

Learn how to declare and use methods in Java, including void methods, parameters and return values, and call them from main to reuse code in game development.

Explore conditional statements in Java for game logic, using if-else with speed comparisons and booleans, and switch-case with break and default to manage outcomes.

Explore for and while loops in Java, using i and conditions to repeat code, control increments, print outputs, and prevent infinite loops in game development.

Learn arrays in java: declare int arrays, understand zero-based indexing, default values and fixed size, access elements with data[index], and iterate with for loops using length.

See how a class is a blueprint for creating objects, with variables like health, power, and name, and methods that operate on them. Use constructors to initialize players.

Learn how data encapsulation uses visibility modifiers to protect variables by making them private, and how getters and setters expose controlled access in a LibGDX Java context.

Learn how inheritance creates a base class for common properties like health, power, and name; extend it to warrior and override methods with super, getters, and setters.

Define a public interface actions with move and attack, implement it in warrior and archer classes, and provide class-specific behavior while printing actions to the console.

Explore arrays vs array lists in Java: resize by adding elements, access with get, remove items, and iterate with for and for-each loops for strings and objects.

Download libgdx and create your first project by configuring the Android SDK, setting the project name and package, and generating a desktop launcher to run in Android Studio.

Discover how to structure a LibGDX project with helper classes and static variables, and use a sprite with a texture to move a centered player in the render loop.

Learn how to manage scenes with a single LibGDX sprite batch, implement a screen interface for a main menu, and render using begin and end batch calls.

Create a custom player class that extends the Sprite class, center the player using get width and get height, and prepare for a physics body with colliders, gravity, and movement.

Learn to implement a physics system in a LibGDX game by creating a world and a dynamic body with a box shape and fixture, tied to the player's position.

Set up a LibGDX world with gravity and do sleep, create the player body, pass the world to the player, and sync the sprite with physics updates via delta time.

Draw player's body on screen with an orthographic camera and debug renderer, using a 100 pixels-per-meter ratio and the camera's projection matrix to map the physics world to screen coordinates.

Move the player by applying linear impulses or forces to its body using left and right keyboard input, at the world center and waking the body for responsive movement.

Implement a contact listener to detect collisions between the player and the cloud, using two fixtures with tagged user data to identify each object and implement sensor pass-through.

preview the jack the giant game in LibGDX, showing music toggle, high score and coin score, difficulty options, a fade start, cloud jumping, coin collection, and encrypted data saving.

Import assets for jack the giant by configuring a libgdx project and organizing backgrounds, buttons, clouds, collectibles, fonts, animations, and sounds under android assets and desktop modules.

Create a game info helper class in a LibGDX Java project, defining width 480, height 800, and pixels per meter 100, and configure the desktop launcher to use these values.

Practice creating a gameplay scene in LibGDX by implementing the screen, building a three-background array with textures from the backgrounds folder, and drawing them with a single sprite batch.

Utilizes a private orthographic main camera and a stretched game viewport to render three backgrounds, then moves the camera downward with delta time to demonstrate an infinite background effect.

Reposition backgrounds as the camera moves down to create an infinite scrolling effect; track the last background y position, calculate new positions using height, and check bounds each frame.

Create a cloud class extending sprite, hook it to the Box2D world as a static body, and render textured clouds from the assets to form obstacles and platforms.

Learn to set up a debug renderer and an orthographic camera in LibGDX, create a Box2D world with gravity, and render a cloud sprite by positioning and creating its body.

Create a cloud controller using physics world to create, position, and manage clouds; it builds a cloud array with two dark and six regular clouds, then shuffles for random spawn.

Position and draw clouds using a cloud controller, placing them with a fixed distance and rendering with a sprite batch, while shuffling to avoid the first cloud being dark.

This lecture explains how to randomize cloud x positions in LibGDX by defining minX and maxX, using a randomBetweenNumbers helper, and a controlX toggle to place clouds left and right.

Manage cloud spawning in a LibGDX game by creating and arranging clouds as the camera moves, disposing out-of-bounds textures, and tracking the last cloud position for consistent spacing.

Learn how to add a player with a dynamic physics body, drawn as a sprite, positioned atop the first cloud, and updated and rendered within the game loop.

Fix cloud body positioning by computing x and height with pixels per meter. Add a draw left flag with getter and setter and update rendering for left or right placement.

Create a LibGDX texture atlas for the player's walk frames using texture packer, producing a sprite sheet and atlas, then integrate them into Android assets for animation.

Animate the player using a texture atlas and a walking and idle animation, driven by delta time and an isWalking flag, with frame flipping to face left or right.

Learn to build a main menu for a LibGDX game using Java, implement the screen, set up camera and viewport, load textures, and manage transitions from main menu to gameplay.

Create a LibGDX main menu buttons class using a fit viewport and orthographic camera to load, position, and render play, high score, options, quit, and music buttons on a stage.

Add change listeners to each in-game button, use the stage as the input processor so touches are registered, and switch screens with game.setScreen(new GameplayScreen(game)).

Create a high score screen as a new Java class, initialize a camera, viewport, and background texture, and render it within the game. Then add labels and a back button.

Create a LibGDX high score menu with a stage and viewport, back button, score and coin labels, and a custom font, wiring input and resize handling for proper display.

Create an options menu in LibGDX using an orthographic camera and viewport, with a background texture and difficulty buttons (easy, medium, hard) plus a back button to the main menu.

Create an interactive LibGDX options menu by building buttons (easy, medium, hard, back) with a stage and viewport, wiring listeners to move a check sign and change screens.

Build a live hud showing coin score, life, and regular score with images and labels, plus a pause button, using a stage, viewport, fonts, and table layout.

Create a pause panel in a LibGDX game, add resume and quit buttons, align center, pause the game, and switch to the main menu on quit.

Fix the player's alignment with its body by adjusting the body's x position based on velocity, so they move and fall together while enabling coin and life collectibles.

Create a collectible class extending Sprite to spawn and collect items. Implement a static physics body with a polygon box shape, fixture, and position setup to distinguish coins and lives.

Position and spawn collectible items in the cloud controller, draw and update their positions, test spawning with clouds to collide with player, and prepare collision detection using a contact listener.

Implement collision detection in a LibGDX Java game using category and mask bits, a contact listener, and sensor collectibles so the player can pass through while collecting coins and lives.

Learn how to remove collectibles on collision by marking items with remove user data. Update category filters to destroyed and dispose of the textures to prevent repeated collisions.

Spawn collectible items randomly on non-dark clouds after the first cloud arrangement, choosing life or coin via random 0–1. Ensure items spawn only after clouds exist and adjust camera projection.

Remove off screen collectibles by iterating through the collectibles array, checking each y position against the camera, disposing textures, and removing off screen items to manage memory and gameplay flow.

Learn how to implement a game manager as a singleton in Java, ensuring a single, globally accessible instance via a private constructor and getInstance method.

Extend a singleton game manager by adding life, coin, and score counters, pause and first-touch start logic, and HUD updates to initialize values from main menu and track progress.

Create a check players bounce function to detect when the player goes out of bounds in any direction (up, down, left, right) and stop the game, effectively killing the player.

Track player's last y position to detect downward movement, then increment the score (200 per coin, 300 per life) and update coin and life counts in a LibGDX Java game.

Implement a player died method that pauses the game, removes the player, decrements lives, updates the UI, and loads the main menu when lives run out.

Explore building and coordinating actions in LibGDX, creating a runnable action and a sequence action to control delays, fades, and screen transitions between gameplay and main menu.

create a game over panel to display the final score and coin score, using a font generator, labels, and stage actors positioned at the center.

Create a game data class to store high score, coin score, difficulty settings, and music; save and load via JSON using a file handle, initializing on first run.

Load and display the high score and coin score from game data via the game manager, then persist easy, medium, and hard selections with a switch and position the sign.

Set the camera speed according to the selected difficulty (easy, medium, hard) by using delta time to adjust speed, max speed, and acceleration.

Implement background music in a LibGDX game with a singleton game manager: initialize, play, stop, and persist music across scenes. Use short sounds for coins and lives for quick effects.

Port the game to Android by implementing finger touch controls using the x coordinate and is touched, then deploy to a portrait device via Android Studio.

Preview the Flappy Bird game from the main menu, select different birds, play through pipes, and hear flap and die sound as high scores update.

Set up a new LibGDX project for a Flappy Bird game, configure package and main class, and import and organize assets into backgrounds, blue/green/red birds, buttons, fonts, sounds, and pipes.

Configure the desktop launcher with assets, create a Helpers game info class with width 480, height 800, pixels per meter, and apply these values to the desktop config.

Create a gameplay scene using LibGDX by wiring an orthographic camera and stretch viewport, then build three side-by-side background sprites and render them with a sprite batch.

Move backgrounds with a delta-time update, loop through each background sprite, and reposition them after the third to create an infinite background effect in LibGDX.

Create a grounds array of three ground sprites, position them below the middle, draw with the batch, and loop their movement for an infinite background effect.

learn to implement a bird class in a libgdx game using box2d physics, creating a dynamic body, circular shape, and fixture, then sync the sprite position with the physics body.

Create a debark orthographic camera and box2d debug renderer to visualize bodies, then implement bird flap by applying vertical velocity on touch and switching the bird to dynamic for landing.

Create a static ground body in libgdx with box2d, position it using pixel-per-meter scaling, and attach a fixture so the bird lands on and rests on the ground.

Create a pipes system in a LibGDX game, defining a pipes class to manage two kinematic pipe bodies with random Y positions, textures, and draw/update logic.

Move the pipes toward the bird with a move pipes method that sets negative x linear velocity for both pipes and deactivates off screen pipes using the main camera.

Create and manage multiple pipes by storing them in an array, drawing, updating, and moving each pipe, with one hundred and twenty pixels spacing and a two-second spawn sequence.

Fix collider alignment for the bird and pipes, set fixed rotations, and implement a middle score sensor between pipes with proper category bits to detect scoring when the bird passes.

Implement collision detection using a contact listener to handle bird-pipe, bird-ground, and score interactions, with alive checks and stop-pipes logic to end the game.

Learn to pause the game until the first touch, activate the bird and pipes on first touch, and implement a score hud with live updates and death handling.

create retry and quit image buttons when the bird dies, set their positions, attach listeners, and add them to the stage; configure input processing for restart or main menu.

Create a main menu with a night background, stage-based user interface buttons, and a responsive viewport, linking play and score buttons to start gameplay.

Implement a singleton game manager to store a birds array (blue, green, red) and an index, and use a change bird button to increment index and load the bird texture.

Animate birds by packing blue, green, and red images into atlases with texture packer, then import the atlases into the LibGDX project for sprite animation.

Load a bird texture atlas, create a seven frames per second animation, and drive it with elapsed time to render idle or alive birds based on the alive state.

Learn to save a high score in LibGDX by using Preferences to store and retrieve a score with a key, compare it to the current score, and flush updates.

showcases highscore by creating a private score label, generating and styling a bitmap font, retrieving the saved score from preferences, and displaying it in the main menu with centered positioning.