Construct 3 Course

Lesson 1 • Previewing and Exporting Basics

Teaches in-browser preview, debug mode, and basic export options. Learners can immediately test their work after every build session.

Lesson 2 • Layouts and Layers Fundamentals

Introduces layouts as game scenes and layers as organisational stacks within them. Learners structure a multi-layout project correctly from the start.

Lesson 3 • Setting Up Your First Project

Guides learners through creating a new project, configuring settings, and saving files. Directly prepares the workspace used throughout the course.

Lesson 4 • Navigating the Editor Interface

Explores every major panel: Layout Editor, Event Sheet, Project Bar, and Properties. Learners gain confident navigation before building anything.

Lesson 1 • Understanding Object Types

Differentiates Sprite, TiledBackground, Text, and other built-in object types. Choosing the right type is essential for efficient scene construction.

Lesson 2 • Sprite Animation Editor

Teaches creating, importing, and timing sprite animation frames. Animated sprites are used in every game project from this chapter onward.

Lesson 3 • Placing and Transforming Objects

Covers inserting objects, using the transform handles, and snapping tools. Precise placement skills underpin every layout built in later chapters.

Lesson 4 • Object Instances and Instance Variables

Explains the difference between object types and instances, and adds per-instance data. This concept is required for all event-driven logic ahead.

Lesson 1 • System Conditions and Actions

Covers the System object's built-in conditions and actions for timing, layout control, and global state. These are used in virtually every project.

Lesson 2 • Event Sheet Organisation

Applies groups, comments, includes, and naming conventions to keep sheets readable. Well-organised sheets are mandatory for team and large-scale projects.

Lesson 3 • Anatomy of an Event

Breaks down conditions, actions, and sub-events with concrete examples. Understanding event structure is the prerequisite for all logic chapters.

Lesson 4 • Input Handling

Implements keyboard, mouse, and touch input using dedicated input objects. Proper input handling is required before any interactive game can function.

Lesson 1 • Physics Behaviour Deep Dive

Configures the Box2D-based Physics behaviour for realistic collisions and forces. Physics objects interact with all other behaviours introduced in this section.

Lesson 2 • Scroll, Camera, and Anchor Behaviours

Uses ScrollTo, Anchor, and Bound-to-Layout behaviours to control the viewport. Camera control is required for any game larger than one screen.

Lesson 3 • Core Movement Behaviours

Covers 8-Direction, Platform, and Bullet behaviours with their key properties. These behaviours form the movement foundation for most 2D game genres.

Lesson 4 • Custom Behaviour Creation

Builds reusable custom behaviours using the Behaviour SDK and event-based logic. Custom behaviours extend the engine for project-specific mechanics.

Lesson 1 • Variable Types and Scope

Distinguishes global, local, and instance variables by scope and lifetime. Correct scope selection prevents data bugs in all subsequent projects.

Lesson 2 • Arrays for Structured Data

Creates and manipulates 1D, 2D, and 3D arrays for grids, inventories, and maps. Arrays are the primary data structure for tile-based and RPG systems.

Lesson 3 • Saving and Loading Game State

Implements save and load systems using LocalStorage and the Save/Load plugin. Learners build a complete persistent save system for a sample game.

Lesson 4 • Expressions and the Expression Editor

Builds numeric, string, and boolean expressions using the Expression Editor. Expressions power every dynamic value in conditions and actions.

Lesson 1 • Audio Integration and Management

Imports and plays music and sound effects using the Audio object with volume and tag control. Audio management is required for any shippable game project.

Lesson 2 • Shader Effects and Blend Modes

Applies built-in shader effects and blend modes to objects and layers for visual depth. Shaders are used in the advanced chapter for dynamic lighting.

Lesson 3 • Particle Systems and Effects

Configures the Particles object for explosions, smoke, and ambient effects. Particle systems add visual polish without significant performance cost.

Lesson 4 • Transitions and Screen Animations

Creates layout transitions and animated UI elements using Tweens and the Timeline editor. Smooth transitions elevate perceived game quality significantly.

Lesson 1 • Performance Optimisation Strategies

Profiles frame rate, reduces draw calls, and manages object counts for smooth gameplay. Optimisation skills are critical before any public release.

Lesson 2 • Multiplayer with Construct 3

Implements peer-to-peer multiplayer using the built-in Multiplayer object and signalling. Multiplayer architecture requires mastery of all prior event concepts.

Lesson 3 • Third-Party Plugin Integration

Installs and uses community and official plugins to extend engine capabilities. Plugin integration is required for features beyond the built-in object set.

Lesson 4 • State Machines in Events

Implements finite state machines using instance variables and event groups for enemy and player logic. State machines prevent spaghetti event sheets.

Lesson 1 • Mobile App Store Submission

Packages a Cordova build and walks through app store submission requirements. Learners produce a signed APK and IPA ready for store review.

Lesson 2 • Post-Launch Updates and Patching

Manages version increments, hotfixes, and player communication after launch. Ongoing maintenance skills ensure long-term game health and player retention.

Lesson 3 • Publishing to Web Platforms

Uploads an HTML5 build to itch.io, game portals, and self-hosted servers. Web publishing is the fastest path to a live, playable audience.

Lesson 4 • Export Targets Overview

Compares HTML5, NW.js, Cordova, and other export targets by platform and use case. Choosing the correct target determines the entire packaging workflow.