Yasaboy

Academic case study · CS6P05ES · Game development

Lost Boy Scout Adventure

Unity 2D intelligent-agent survival game. An AI scout manages hunger, water, and energy under partial observability — behaviour trees, perception, and memory — not a fixed cutscene script.

Download GameDownloadsOpen galleryGitHub

Download and play the latest Windows build. Platform: Windows. Executable: LostBoyScoutAdventure.exe.

Module

CS6P05ES Artificial Intelligence

Engine

Unity 6000.3.10f1

Language

C#

Engine

Unity 6

Editor 6000.3.10f1

Agent focus

Scout AI

Perception · BT · Memory

Predators

2

Wolf (L1) · Wolf+Lion (L2)

Outcomes

Multi

Exit · Rescue · Multiple lose paths

Overview

Lost Boy Scout Adventure (coursework title also uses Scout vs Wolf: Intelligent Agent Survival Game) is a Unity survival simulation focused on autonomous AI behaviour. The scout senses the environment, updates survival needs, and chooses actions based on current priorities.

Problem statement

Intelligent-agent coursework needs behaviour that can be observed, not a fixed animation path. The scout must sense threats and resources, manage competing survival needs, and produce different endings across runs under uncertainty.

  • Demonstrate perception, decision making, searching, memory, and status-based behaviour in Unity.
  • Keep sensing partial (vision/hearing) so the agent is not omniscient.
  • Make state changes visible for assessment through HUD labels, overlays, and alternative outcomes.

Trust boundaries

  • Academic Unity artefact for CS6P05ES — not a commercial game release.
  • Canonical repo is LostBoyScoutAdventures; LostBoyScoutAdventure is an earlier prototype.
  • No weapons/inventory RPG systems are claimed — survival stats, pickups, predators, exit/rescue.
  • No gameplay video is bundled in the public repositories.

Objectives

  • Implement an autonomous scout that updates behaviour during gameplay.
  • Implement state-based responses to internal and external events.
  • Implement perception via vision, hearing, and short-range resource detection.
  • Implement priority-driven decision making and searching for food, water, shelter, and exit.
  • Implement memory of resources/danger and support exit success, rescue success, and multiple lose conditions.
  • Include physics indicators (ranges, decay, speed modifiers, collisions) and complete documentation/test evidence.

Gameplay

Unity 2D top-down intelligent-agent survival simulation

Story

A boy scout is lost in a jungle map and must survive by managing hunger, water, and energy while avoiding predators and seeking exit escape or helicopter rescue.

Controls

  • Play (AI): scout decisions driven by behaviour-tree brain.
  • Manual Play: WASD / arrow keys; AI brain skipped while manual.
  • Pause: Esc / P. Main menu: Options, Help, Quit.

Characters

  • Scout (Player tag) — primary intelligent agent

Enemies

  • Wolf — Level 1
  • Lion — Level 2 additional predator

Collectibles

  • Food pickups
  • Water pickups

Systems

  • Shelter
  • Exit
  • Helicopter rescue circle
  • Day/night + rain presentation

Timeline

  1. 01

    AI coursework brief

    CS6P05ES Intelligent Agent artefact — demonstrate perception, decisions, and dynamic behaviour in Unity.

  2. 02

    Scout survival concept

    Hungry/thirsty scout in a changing jungle with predators, shelter, exit, and rescue outcomes.

  3. 03

    Early prototype

    LostBoyScoutAdventure snapshot with FSM-style scout/wolf scripts (not the finished artefact).

  4. 04

    Adventures build

    LostBoyScoutAdventures adds behaviour trees, perception, memory, lion, menus, and HUD overlays.

  5. 05

    Level scenarios

    Level 1 wolf scenario and Level 2 wolf+lion scenario for controlled predator evaluation.

  6. 06

    Documentation package

    Report, diagrams, screenshots, testing notes, and user manual for the approved individual submission.

Product deep dive

Main menu and modes

LOST BOY SCOUT — Adventure Survival opens with Play (AI), Manual Play, Options, Help, and Quit so assessors can choose autonomous or keyboard-driven evaluation.

Unity UIC#MainMenuPauseController
  • Unity productName is LostBoyScoutAdventure; coursework report title uses Scout vs Wolf wording.
  • Level selection supports wolf-only and wolf+lion predator scenarios.
  • Debug weather/resource buttons aid demonstration without changing default survival rules.

Behaviour-tree scout AI

The scout chooses actions from runtime status and sensed events through priority behaviour-tree logic rather than a fixed scripted sequence.

Behaviour TreesScoutPerceptionScoutMemory
  • ScoutBrain builds selector/sequence trees; ScoutAI mirrors readable StateLabel values.
  • Perception uses vision cones and hearing with night/rain modifiers.
  • Memory stores resource and danger points and supports behaviours such as returning to remembered food.

Predator scenarios

Level 1 focuses on the wolf; Level 2 adds a lion. Predators patrol, investigate, and chase, while the scout can enter flee behaviour when danger is detected.

WolfBrainLionAISteering
  • Vision overlays and action labels make predator and scout states assessable on screen.
  • Catch distance triggers lose outcomes such as killed by wolf/lion.
  • Cheat aids (for demos) are not presented as default difficulty.

Win and lose outcomes

Success paths include reaching the exit with safe stats or entering the helicopter rescue circle after the rescue timer unlocks. Lose paths cover starvation, dehydration, exhaustion, and predator capture.

GameManagerHelicopterRescueViewHUD
  • HUD tracks Day status plus Hunger, Water, and Energy bars.
  • Helicopter pickup prompts instruct moving into the green rescue circle.
  • Alternative endings keep runs replayable for intelligent-agent evaluation.

System design diagrams

Coursework diagrams cover scout state transitions, class structure, runtime game flow, and the P.E.A.S model used to frame the intelligent agent.

draw.ioUnity C#
  • State transition diagram links survival modes and conceptual transitions.
  • Class diagram highlights ScoutAI, ScoutBrain, predators, and GameManager relationships.
  • P.E.A.S summarises performance measures, environment, actuators, and sensors.

System design

Canonical implementation lives in LostBoyScoutAdventures. ScoutAI facades a ScoutBrain behaviour tree with perception and memory; predators use WolfAI/WolfBrain and LionAI; GameManager owns world cycle, rescue timing, and win/lose; menus and HUD coordinate presentation.

Agents

ScoutAI / ScoutBrain, WolfAI / WolfBrain, LionAI, SteeringAgent.

Sensing & memory

ScoutPerception (vision/hearing) and ScoutMemory with decay and discovery feedback.

World

GameManager day/night, rain, helicopter chance, exit/rescue triggers.

Presentation

Main/pause menus, survival HUD, vision cones, action labels, debug panels.

Technology stack

Unity 6000.3.10f1 (Unity 6)C#Behaviour trees2D top-down scenesPerception (vision / hearing)Memory systemSteering / movement helpersCanvas HUD & menus

Challenges

  • Competing survival goals

    Hunger, thirst, energy, predators, weather, shelter, exit, and rescue compete every tick — behaviour-tree priorities must stay readable and testable.

  • Partial observability

    Vision/hearing limits and night/rain modifiers prevent omniscient pathing and force memory-backed searching.

  • Assessable presentation

    State labels, vision cones, HUD, and menus must reveal AI reasoning without turning the artefact into a pure debug toy.

Solutions

  • Facade agents (ScoutAI/WolfAI) over behaviour-tree brains with mirrored state labels for screenshots and viva explanation.
  • Perception + memory modules instead of tag-omniscient FSM-only control in the finished Adventures build.
  • Separate Level 1/Level 2 predator setups and AI vs Manual play modes for controlled evaluation.

Engineering decisions

  • Unity 6 (6000.3.10f1) 2D top-down for visible agent behaviour.
  • Behaviour trees for scout/wolf decision making in the canonical Adventures repo.
  • Optional manual control sharing the same survival systems.
  • Document physics indicators (ranges, decay, collisions) without claiming NavMesh A* (listed as future work).

Development process

  1. 01Define intelligent-agent requirements and P.E.A.S framing.
  2. 02Prototype survival stats and predator chase, then upgrade to BT/perception/memory.
  3. 03Build menus, HUD, Level 1/2 scenarios, and demo overlays.
  4. 04Produce diagrams, testing evidence, user manual, and coursework report package.

Testing

  • Gameplay observation of AI mode, manual mode, predator responses, and win/lose paths.
  • Debug/HUD overlays used as assessment aids for active nodes and discovery events.
  • Coursework package includes diagrams, screenshots, and supporting manual evidence.
  • No public gameplay video is committed in the GitHub repositories.

Lessons learned

  • Visible state labels make behaviour-tree decisions explainable to assessors.
  • Memory + partial sensing produces more convincing agent behaviour than omniscient searches.
  • Demo cheats must stay clearly separated from default survival difficulty claims.

Future improvements

  • A* pathfinding around obstacles.
  • Richer adaptive memory scoring or reinforcement learning extensions.
  • Improved character animation and movement presentation.
  • More advanced predator tactics and cooperation.

Downloads

Windows build (coursework Appendix E), user manual, diagrams, and source. The playable package is hosted on Google Drive as documented in the report — not inventing a local .exe.

Download Game (.exe)Windows · DriveDownload and play the latest Windows build. Open the build folder and run LostBoyScoutAdventure.exe. Keep UnityPlayer.dll and the data folder beside the executable.Download ReportPDF · 5.7 MBFull CS6P05ES coursework PDF.Download User GuidePDFGame User Manual (Appendix F) — launch, controls, AI/manual modes, HUD, outcomes.Download ArchitecturePDFDesign diagrams extract: state transition, class diagram, flowchart, P.E.A.S.Packaged build evidencePDFAppendix E page documenting the Windows build folder and Drive link.Source CodeCanonical Unity project: LostBoyScoutAdventures.

After downloading the Windows package, keep LostBoyScoutAdventure.exe, UnityPlayer.dll, and the data folder together. Mirrored PDFs also live under /documents/lost-boy-scout/.

Conclusion

The artefact demonstrates perception, decision making, searching, memory, and status-based behaviour in a replayable Unity survival setting with alternative win and lose outcomes — a practical intelligent-agent submission backed by diagrams, screenshots, and the CS6P05ES report.

All projectsUniManage LMSSmart AAC