Learn Java Creating Android Games Using the LibGDX library

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 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.

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.

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.

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 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.

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.

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.

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.

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.

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.

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 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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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 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.

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.

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.

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.

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.

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.

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

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.