Game Development

Attach a PlayCanvas script to an entity and use its initialize and update methods for setup and per-frame behavior.

Declare and update number, Boolean, and string variables in JavaScript.

Use arithmetic, comparison, and logical expressions in an if/else statement to control game behavior.

Define and call a JavaScript function that accepts a parameter.

Access and modify a PlayCanvas entity or component from a script.

Store entity references in an array and iterate over them to update multiple game objects.

Expose a script attribute so a value can be tuned in the PlayCanvas editor.

Use console messages to locate and correct a basic syntax or reference error.

Map keyboard input to directional movement intent.

Normalize a movement vector to prevent faster diagonal movement.

Use elapsed frame time to produce frame-rate-independent movement.

Rotate a player avatar to face its movement direction.

Configure collision shapes and rigid-body types for a player and the environment.

Diagnose a collision problem by inspecting component settings and collider placement.

Position a fixed top-down camera to keep the player and nearby route visible.

Reset the player safely after leaving the playable area.

Use a trigger volume to detect when the player enters an interaction area.

Implement a collectible that increments a stored count.

Deactivate a collectible after the player acquires it.

Display current collection progress in a user-interface text element.

Unlock an exit only after the required items have been collected.

Implement a win condition that activates when the unlocked exit is reached.

Reset the prototype to its initial state for another playthrough.

Evaluate whether the prototype clearly communicates action, feedback, and goal.

Sketch a critical path and optional routes for a compact 3D level.

Place landmarks to help players orient themselves without a map.

Use sightlines to reveal destinations and upcoming challenges.

Gate a route so mechanics are encountered in an intentional sequence.

Place collectibles to create meaningful risk-and-reward choices.

Adjust route length and spacing to shape the level's pace.

Translate a level sketch into a playable greybox layout.

Conduct a walkthrough to identify navigation bottlenecks and misleading routes.

Define a three-stage difficulty progression for the prototype.

Script a moving hazard that travels between waypoints.

Reset the player to a safe position after contact with a hazard.

Represent playing, won, and lost conditions as explicit game states.

Implement a countdown timer that runs only during the playing state.

Transition to a loss state when the countdown expires.

Disable player input and active hazards after the prototype reaches an end state.

Tune exposed speed and timing values to make a challenge demanding but readable.

Choose feedback for an important event based on the information it must convey.

Add a looping visual animation that makes collectibles noticeable.

Trigger a particle effect when a collectible is acquired.

Add event-driven sound effects and balance their relative volume.

Create start, win, and loss interface panels that communicate controls, outcomes, and available actions.

Use contrast, size, and placement to establish visual hierarchy in the interface.

Tune movement responsiveness to match the intended player experience.

Apply a coherent visual style using a limited set of assets, colors, and lighting choices.

Write a short playtest protocol that targets specific design questions.

Observe a playtest without leading the player toward solutions.

Classify an observed problem as a defect, usability issue, or design issue.

Document a playtest issue with evidence, severity, and the conditions under which it occurred.

Measure completion time, failure count, and route choice during a playtest.

Prioritize improvements using expected player impact and implementation effort.

Form a design hypothesis and test it by changing one variable.

Compare before-and-after playtest evidence to decide whether to keep a change.

Test a release candidate in a browser outside the PlayCanvas editor using a functional and presentation checklist.

Interpret frame-rate and loading measurements to determine whether the prototype meets a simple performance target.

Record asset sources and licenses in a concise credits file.

Publish the prototype and verify that its public link works correctly.

Capture screenshots and a short gameplay video that communicate the core experience.

Write a portfolio case study describing the goal, constraints, iterations, and result.

Map evidence from the project and remaining skill gaps to common entry-level game-design competencies.