Construct 3 Course

Lesson 1 • Previewing and Exporting Basics

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

Lesson 2 • Layouts and Layers Fundamentals

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

Lesson 3 • Setting Up Your First Project

Guides students 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. Students 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 Organization

Applies groups, comments, includes, and naming conventions to keep sheets readable. Well-organized 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 Behavior Deep Dive

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

Lesson 2 • Scroll, Camera, and Anchor Behaviors

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

Lesson 3 • Core Movement Behaviors

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

Lesson 4 • Custom Behavior Creation

Builds reusable custom behaviors using the Behavior SDK and event-based logic. Custom behaviors 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. Students 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 Optimization Strategies

Profiles frame rate, reduces draw calls, and manages object counts for smooth gameplay. Optimization 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 signaling. 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. Students 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.