Learn Java Creating Android Games Using the LibGDX library

Learn to create your first libgdx project with the gdx setup tool, configure the desktop subproject and core assets, then run the desktop launcher.

Learn to embed a libgdx application into a Java desktop app and run multiple samples from one tool, enabling quick testing of viewports, shape renderer, and other game experiments.

Learn to implement the libgdx application listener and its lifecycle methods: create, resize, render, pause, resume, dispose—and observe calls with a logger showing render 60 times per second.

Learn libgdx's six core modules: application, files, input, net, audio, and graphics, and access them via gdx fields, comparing desktop and Android implementations.

Explore how libgdx polls input every frame in render, detecting left/right mouse buttons and W and S keys, while rendering coordinates and button states with a bitmap font.

Explore input listening by implementing an input processor, registering it with LibGDX, and handling key and touch events, while displaying up to 15 on-screen messages; learn about input adapters.

Explore input handling by weighing polling and event listening, and learn how input multiplexer delegates key events to multiple input processors for ui and game controls.

Explore Android Studio tips for LibGDX development, including enabling line numbers, shortcuts for commenting, class and resource search, code formatting, import optimization, and live templates.

Learn to eliminate copy paste by using Java reflection and LibGDX wrappers to inspect fields and methods at runtime, enabling a single tool to run all samples.

Apply the dry principle to LibGDX game code by creating a reusable LibGDX utils class with private constructor and static clear screen methods for default black or custom colors.

Embed LibGDX in a Java desktop app using LWJGL AWT canvas within a Swing JFrame. Use reflection to instantiate samples such as input listening or input polling.

Embed a LibGDX game into a Java desktop app using an AWT canvas and JFrame, with a grid bag layout control panel for a sample list and launching a sample.

Learn to harness reflection to run all LibGDX samples, design a common sample info system and a factory, and extend a reusable sample base for Android games.

Experiment with an orthographic camera in LibGDX, control position and zoom via delta time and input, and learn how viewports map world units to the screen.

Learn how libgdx viewports manage multiple screen sizes and aspect ratios using world units, with resize updates and various strategies such as stretch, fit, and fill.

Explore cycling through five viewports—stretch, fit, fill, screen, extend—via a modulus index, compare their behaviors, and learn why thinking in world units with a fixed 800x600 virtual size matters.

Explore how sprite batch optimizes rendering in LibGDX by using an orthographic camera and a fit viewport with world units, and manage drawing between begin and end calls.

Finish the first section by summarizing camera placement, texture drawing, and input handling, then explore reflection as a powerful tool and use a simple playground for experiments and live templates.

Learn to build your first Android LibGDX game in Java: an obstacle-avoidance game with a loading screen, main menu, and high-score system. Manage gameplay with three lives and time-based scoring.

Create an obstacle avoid game using LibGDX, setting up Android and desktop subprojects, configuring Gradle and plugins, and implementing a game screen with world units and a game config.

Learn to use shape renderer in LibGDX to draw debugging shapes like rectangles and circles, manage world units with a camera and viewport, and apply begin/end blocks and projection matrices.

Learn to render shapes with shape renderer in LibGDX by drawing circles, rectangles, and points in world units and using a world grid.

Learn to implement the ViewportUtils class in a LibGDX project, drawing a grid with an orthographic camera and viewport, using cell-based world units and pixel-per-unit calculations.

Create a player as a circle bounce with x and y position and radius and size. Center the camera and render the player using world units and the viewport.

Move the player left and right using an update method called every frame, adjusting x speed based on input, updating position, and rendering with basic debug graphics.

Create a debug camera controller to move and zoom for LibGDX games, enabling real-time camera debugging. Start at world center and apply position to an orthographic camera.

Learn to extend a debug camera controller in LibGDX with zoom in, zoom out, and reset, and clamp zoom levels while preparing a configurable key mapping for future games.

Create and load a debug camera configuration from a json file to fix key conflicts with the camera controller, define defaults, and parse using LibGDX utilities.

Create a debug camera config class that reads a json key value map, applies defaults, converts string keys to keyboard codes, and exposes getters and input checks like isLeftPressed.

Explore how to configure and print the debug camera setup using a configuration file, map keyboard inputs for zoom and movement, and integrate a debug camera into LibGDX camera controller.

Explore how a debug camera controller uses a json configuration to control movement and zoom in libgdx, with defaults, key mappings, and viewport centering.

Block the player's x position from leaving the world by clamping it between half the player's width and world width minus half the width, using LibGDX MathUtils.

Add obstacles in a LibGDX game by spawning them every 0.25 seconds, randomizing x within world width, moving downward with yspeed, and rendering in the debug view.

Refactor time creates a game object base to remove duplicate code between the player and obstacle classes, applying the dry principle and centralizing common x, y, and bounds logic.

Detect collisions between the player and obstacles by tracking an alive flag and calling is player colliding with obstacle, which uses intersector to test circle bounds of player and obstacle.

Learn to create and render bitmap fonts in LibGDX using the Hiero tool, generating fnt and png assets, applying color and gradient effects, and integrating fonts into your game UI.

Explore rendering bitmap fonts in LibGDX using BitmapFont and GlyphLayout. Create fonts, measure text, center it on screen, and enable multi-line and color markup in your game UI.

Enhance the game hud by adding a lives counter, creating a font asset, configuring world units, and rendering the remaining lives with a responsive layout.

Learn how to add scoring to a LibGDX game by introducing a score interval, a timer that increments score every 1.25 seconds, and displaying the score on the HUD.

A practical trick in LibGDX to smooth the on-screen score by using delta time and a separate display score, updating the score gradually instead of jumping.

Learn how to implement robust game over logic in a LibGDX game by guarding life loss with obstacle hit flags, updating only when not game over, and preventing repeated collisions.

Add difficulty levels to your LibGDX game by defining a difficulty level enum with easy, medium, and hard, each assigning a unique obstacle speed.

Apply the single responsibility principle by separating rendering code from game logic into a game control and a game render to improve robustness and support different resolutions.

Extracts game logic from rendering code, deprecates the old game screen, and introduces a new game screen and a game controller to separate logic from rendering for robust, maintainable code.

Create a new game renderer class to isolate rendering from game logic, wiring the camera and viewport, and implement render and dispose methods in LibGDX.

Separate game logic from LibGDX rendering to improve maintainability, and wire a private game controller to the render UI to access lives, player, and obstacles via getters.

Learn to fix bugs from multiple viewports by applying each viewport on resize, updating the camera and projection matrix, and avoiding pixel-based thinking to ensure consistent rendering across screens.

Learn how to remove off-screen obstacles in a LibGDX game by checking obstacle positions in update, removing those that pass below world bounds to improve performance and visual consistency.

Fix obstacle spawn logic by ensuring obstacles spawn within the visible area, adjusting spawn position by half the obstacle size, and verifying rendering origin with debug lines.

Learn how object pooling reuses inactive bullets and obstacles to reduce memory and lag in LibGDX games, by obtaining and resetting free objects for reuse.

Learn how to implement obstacle pooling in LibGDX using reflection pool, configure an obstacle pool, enforce no-argument constructors, and reuse objects to reduce memory and garbage collection.

Import gameplay textures from assets, initialize rendering layers, and draw background, player, and obstacles in the correct order using a game play camera and viewport.

Learn to fix bounds and texture positioning by centering the sprite with its texture, correcting for bottom-left origin, and offsetting by half width and half height.

Center the player by adjusting the start position in world units, considering the bottom-left origin and boundary checks. This uses public game constants to keep the player inside the world.

Fix obstacle positioning by aligning bottom left coordinates with obstacle size and centers for collision detection, moving constants to the game config so obstacles stay inside world bounds across sizes.

Restart the game after the player collides with an obstacle by resetting lives, repositioning the player, and clearing and reusing the obstacle pool, with a private restart method.

Add touch controls to move the player in Android games using LibGDX by converting screen touches to world coordinates via the viewport, and handling input in the renderer.

Learn to run your libGDX Android game on an emulator or real device by using the AVD manager, enabling debugging, and selecting a deployment target.

Completing your first LibGDX game, this lecture teaches how to manage view ports with world sizes, notify ports on size changes, and apply object pooling with poolable interface.

Learn how asset manager enables reference-counted resources, loading textures, fonts, and sounds once and disposing them efficiently. Explore loading sets, constants, and retrieving assets for use in LibGDX projects.

Apply asset management in your LibGDX game by using asset descriptors and a single asset manager to load and reuse textures and fonts, avoiding memory leaks.

Learn how to improve art rendering by packing textures into a single atlas, using a texture packer and atlas file to map regions, and manage disposal with the asset manager.

Pack textures into an atlas using a texture packer, set up texture regions for efficient rendering, and manage assets with an asset manager to free resources in a LibGDX game.

Learn to reduce texture swapping by packing assets into an atlas and drawing texture regions with the sprite batch, tracked by render calls through the asset manager.

Implement a reusable loading screen in LibGDX to manage asset loading with an asset manager, showing a progress bar and avoiding long black screens.

Diagnose and fix a LibGDX crash by switching screens after rendering completes, using a post-render flag and logging lifecycle calls to ensure loading screens dispose correctly.

Explore how asset manager reference counts resources to optimize memory, pack textures into a texture atlas, manage loading screens and screen transitions, and debug with a logger.

Explore libgdx scene graph with actors, groups, and a stage; create a custom actor with a texture region, and manage input, act and draw, and stage driven rendering.

Learn how to create and manage actions for actors in a LibGDX stage, using rotate, fade, move, scale, and sequential and parallel actions, while understanding action pooling and automatic removal.

Use the LibGDX table to lay out UI by adding actors as cells, controlling size, position, padding, spacing, and alignment, while enabling stage debug lines for visualization.

Understand how the skin class centralizes UI resources—textures, fonts, colors, and drawable regions—via a JSON skin file, enabling easy customization of buttons, checkboxes, and menus with LibGDX.

Prune unused assets, extract UI textures, and pack them into a dedicated atlas with texture packer. Define UI region names and asset descriptors, then load assets on the loading screen.

Create a LibGDX menu screen with a dedicated MenuScreen class, a stage and viewport, a single batch, and an asset manager, then build play and high score buttons using tables.

Build a high score screen in LibGDX using assets, a viewport, and a stage. Create UI with labels, back button, and table layouts, then navigate back to the menu screen.

Implement a singleton game manager to update and display high scores, stored with LibGDX preferences using a high score key and flushed to disk.

Design and implement the options screen for an Android game using LibGDX, positioning easy, medium, and hard buttons and a checkmark, with back navigation and asset and stage management.

Learn how to implement and fix difficulty selection in a LibGDX game by using a game manager, difficulty levels, and preferences, ensuring the options screen updates and checkmarks position correctly.

Consolidate duplicated screen code by introducing a menu screen base in libgdx, moving show, resize, render, hide, and dispose to a common base, with a protected create UI method.

Eliminate manual UI positioning by building a reusable libgdx custom skin. Extract assets, create a skin json descriptor, and load a unified skin to style menus quickly.

Create a custom skin to organize textures, texture regions, fonts, and colors for LibGDX widgets, then define text button, label, and checkbox styles in a white skin.js for efficient rendering.

Learn to implement a custom skin in the menu screen using libGDX, creating text buttons with skin styles, region drawables, and streamlined UI setup for easy localization and maintenance.

Learn to integrate a custom skin into the high scores screen of a LibGDX game, reuse the menu skin, and apply texture regions and label styles to buttons and backgrounds.

Implement a custom skin from a texture atlas for the options screen in a LibGDX game by using a checkbox group for easy, medium, and hard, eliminating manual layout.

Fix checkbox alignment in a LibGDX Android game by aligning checkboxes to the left with padding on the options screen, using skin-based UI and a checkbox factory.

Learn to add sounds in a LibGDX game by using asset manager to load and play hit sounds on collision, creating sound descriptors and managing assets during loading screens.

Explore LibGDX stages, groups, and tables to design responsive user interface and scene layouts. Use skins and a skin.json file to manage widgets like text buttons, labels, and checkboxes.

Learn how to replace inheritance with composition using an entity component system in libGDX, where entities hold components and systems process them through the engine for efficient game object management.

Learn that the engine is the framework's center and an entity is a game object, then build a simple sample where bullets spawn every second and remove after three seconds.

Explore building a LibGDX game with an entity–component–system: define entities with position, size, and texture components, and implement a render system to draw the game world.

The render system composes entities from position, size, and texture components, selects them with a family, and renders them using a batch, viewport, and camera.

Explore how to use the Ashley engine to manage entities and components, listen for entity and family events, and add or remove components on the fly to simulate invisibility.

Create a libgdx project using the setup tool, selecting desktop and Android subprojects, then import, build, and set the working directory to the assets folder to run and verify.

Copy four folders into the desktop and core packages to reuse menus and logic, then rename the old game screen to deprecated and create a new screen with updated imports.

Learn to implement a grid render system in LibGDX using entities and components, a viewport, and a pooled engine that updates every frame.

Implement a debug camera system that works with the camera controller to move and zoom world grid. Separate logic into utility systems, wire them into rendering, and manage system priorities.

Create a dedicated entity factory to assemble player, obstacles, and background; implement bounce component with circle data; center player, set position, add entities to the engine, and enable debugging outputs.

Build a debug render system with IteratingSystem that draws bounce component based debug graphics for the player and obstacles, using a component mapper and a viewport and camera.

Introduces a player system with movement and player components to handle left/right input, update x speed, and integrate the system into the engine.

Create a position component and a movement system that update the player's x and y from speed, using movement and position components to move the entity and align bounce-based collision.

Create a bounce system that uses balance and position components to update the player's x and y positions each frame, preventing the player from leaving the world.

Introduce a world wrap system and a world rep component to mark the player, clamp position to the viewport, and keep the player inside the world.

Implement an obstacle spawn system using an interval system, creating obstacles with bounce, movement, and position components via an entity factory, and integrate world rep to constrain them.

Create a clean up component as a marker and a clean up system to remove obstacles after they cross a minimum y position, separating clean up logic from game controller.

Develop and integrate a two-family collision system that detects player-obstacle overlaps using obstacle and player components, plays a collision sound, and resets pooled obstacle components.

Learn to implement a dedicated hud render system in LibGDX that draws lives and score from the game manager using a viewport, font, and layout, separate from game entities.

Implement a collision listener to detect player hits obstacles, decrement lives, check game over, and reset or re-spawn the player by updating and reusing entities in LibGDX.

Fix the score update by adding a LibGDX score system and a reset method in the game manager, ensuring lives reset and the game no longer returns to the menu.

Create a render system that draws background, player, and obstacles by adding texture and dimension components with positions, then render using a viewport, batch, and atlas texture regions.

Fix bounds and texture positioning demonstrates aligning the bounce circle with the object's center using the dimension component, adjusting world bounds with clamping, and toggling debugging systems for gameplay.

Clean up the code by deleting unused classes and strengthen your understanding of the flea entity component system, with engines, entities, components, and reusable systems like bounce, render, and spawn.

Create a new LibGDX project with the project generator, configure package and settings, import, adjust the working directory, copy sources from the previous obstacle game, then run the default application.

Prepare a new LibGDX project by copying assets and code, deprecating unused classes, and reorganizing packages for a ready Android game.

Learn to create a player sprite in LibGDX by extending a texture region with position, origin, rotation, scale, and bounds, then refactor with an entity factory for clean rendering.

Enable debug rendering to reveal the grid and the player's circle around the plate, then diagnose and fix a null pointer in the sprite bounds during construction.

Refactor obstacles into an obstacle Spryte by creating a shared game sprite base with texture region and bounce radius. Update the pool and controller, and fix no-argument constructor errors.

Refactor the code by implementing a custom obstacle pool inside the entity factory, supplying texture regions to obstacles, and replacing reflection pools and no-argument constructors in the game controller.

Continue refactoring the game by fixing obstacle bounce and collision detection, and decide between sprite and Spryte usage while moving background creation to a factory.

Introduce a new sprite class and draw via the sprite drop method, with optional overrides. Provide a texture or texture region to avoid null pointer errors.

Learn to create an empty LibGDX project with GDX project generator, set up obstacle-avoid game by copying actors, game class, and renderer from a prior project, and run to verify.

Prepare a LibGDX project by copying old game code into the new android and desktop modules, reuse core sources, and deprecate legacy classes while verifying the game runs.

Create and integrate a new game screen in LibGDX, enabling zoom in/out, camera control, and unified rendering and UI logic while handling assets, layout, and on-screen score and lives.

Build a base actor class to power players and obstacles, managing texture region, collision shape, and automatic updates on position, size, and rotation, with stage managed drawing.

Create the player actor on a LibGDX stage, set its collision radius and size, assign its texture region, and implement update logic for movement and world boundaries with debug visuals.

Create obstacle actor logic with a pool, update loop, collision checks, and texture region setup to manage obstacles on the stage in a LibGDX Android game.

Learn to implement a LibGDX game background using atlas texture regions and an Image on the stage, with proper sizing and rendering order.

Finish the game logic by implementing scoring, collision detection, and restart behavior, including display score, game over handling, and obstacle management on the stage.

Explore how to restart a LibGDX game scene by safely removing obstacles. Compare remove index vs clear and iterator-based removal, and understand how array size changes during iteration.

Learn to build a simple snake game in LibGDX for Android. See a moving head, coins that grow the snake, self-collision ending the game, and high score saving.

Create a simple snake game project with the LibGDX project generator, configure desktop and Android subprojects, import to Android Studio, and set up game configuration, world dimensions, and screens.

Prepare and initialize a single asset manager and sprite batch for a LibGDX game, set up rendering components and camera, and outline disposal and getters for a streamlined snake game.

Create an abstract entity base class for all game objects, housing position, size, and a bounding rectangle for collision detection, with setPosition and setSize updating the bounding box.

Create the snake head by extending the entity base, set a one-unit world size, and render it via the game controller for future movement.

Move the snake head in a LibGDX Java game using input and a timer-driven update. Wrap around world bounds and navigate four directions with a configurable snake speed.

Create a coin entity for the snake, with a fixed size and a single available coin, spawning at random world bounds, rendered blue, and respawning after being eaten.

learn to build a snake class in a LibGDX project that uses a head and body parts, detects coin collisions, and grows by inserting body parts.

Master collision detection in a LibGDX snake game by detecting head-to-body overlaps and preventing growth-related collisions, while managing render order and coin growth.

Define and manage game states (ready, playing, game over) with a singleton game manager. Ensure updates run only when playing, handle restarts, and prevent back flip via opposite direction logic.

Create a loading screen that loads fonts and textures using an asset manager, displays a progress bar, and safely switches to the game screen after assets finish loading.

Implement a hud to display score and high score in a libgdx android game, update the display with delta time, and render using a dedicated viewport and font layout.

Learn to update the score when the snake collects coins, set a coin score of 20, and enforce world bounds so the snake and coins stay in view.

Pack gameplay and UI assets into a texture atlas, then create a JSON skin with button styles to drive the LibGDX Android game.

Render gameplay by applying the viewport and projection, then draw the background followed by coin, snake body parts, and head using atlas texture regions, reusing regions for efficiency.

Learn how to persist high scores in a LibGDX snake game using the preferences API, with a game manager singleton loading and saving high scores across Android and desktop platforms.

Build a LibGDX menu screen using scene2d, stage, and skins with a background and title image; add play and quit buttons to start the game or exit.

Generate sounds with sfxr, load asset descriptors, and play coin and body collision sounds via the asset manager and a collision listener.

We built a simple snake game, separating render logic from game logic and creating menus with a manager. We contrast component systems with object-oriented programming in the next lesson.