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

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

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.