fxgl-stealth

name	fxgl-stealth
description	Build a stealth game in FXGL — implement a conical vision field for guards with configurable range and angle, line-of-sight raycasting blocked by wall entities, a three-state detection machine (unaware/suspicious/alerted), a detection meter that fills while in sight and decays out of sight, waypoint patrol routes that pause on detection, a noise system where player actions emit a radius heard by nearby guards, hiding spots (shadows/lockers) that suppress detection, non-lethal takedown mechanics, and an alarm system where alerted guards call for backup. Use this skill when building a stealth game, espionage game, guard-avoidance puzzle, or any game requiring line-of-sight and detection mechanics.
triggers	["stealth","guard","line of sight","detection","FOV cone","patrol","noise","hiding","shadow","alert","suspicious","takedown","vision cone"]
compatibility	Java 17+, FXGL 21.x
category	fxgl/game-types
tags	["fxgl","java","javafx","game-types","stealth"]
metadata	{"author":"fxgl-skills","version":"1.0","fxgl-version":"21.1"}
allowed-tools	["Read","Write","Edit","Bash"]

FXGL Stealth Game

Guard Component

public class GuardComponent extends Component {
    public enum DetectionState { PATROLLING, SUSPICIOUS, ALERTED, SEARCHING }

    private WaypointMoveComponent patrol;
    private DetectionState state = DetectionState.PATROLLING;

    private double detectionMeter  = 0;    // 0-1: fills when player in sight
    private double searchTimer     = 0;
    private Point2D lastKnownPos;

    // Config
    private static final double VISION_RANGE     = 300.0;
    private static final double VISION_HALF_ANGLE = 55.0;  // degrees each side of forward
    private static final double DETECTION_RATE   = 0.5;    // fill rate per second (normal)
    private static            ;   
           ;   

    
       {
           getGameWorld().getSingleton(EntityType.PLAYER);
           canSeePlayer(player);

         (state) {
             PATROLLING  -> updatePatrolling(tpf, canSee, player);
             SUSPICIOUS  -> updateSuspicious(tpf, canSee, player);
             ALERTED     -> updateAlerted(tpf, canSee, player);
             SEARCHING   -> updateSearching(tpf, canSee, player);
        }

        updateFOVVisual();
    }

       {
        
           entity.getCenter().distance(player.getCenter());
         (dist > VISION_RANGE)  ;

        
           player.getCenter().subtract(entity.getCenter());
             angleToVector(entity.getRotation());
                 facing.normalize().dotProduct(toPlayer.normalize());
               Math.toDegrees(Math.acos(Math.max(-, Math.min(, dot))));
         (angle > VISION_HALF_ANGLE)  ;

        
         !wallBlocksLOS(entity.getCenter(), player.getCenter());
    }

       {
        
           ()(from.distance(to) / (TILE / ));
         (   ; i < steps; i++) {
               () i / steps;
               from.getX() + (to.getX() - from.getX()) * t;
               from.getY() + (to.getY() - from.getY()) * t;
                (x, y);

               getGameWorld().getEntitiesByType(EntityType.WALL)
                    .stream()
                    .anyMatch(wall -> wall.getBoundingBoxComponent()
                                         .isWithin(point.getX(), point.getY()));
             (wallHit)  ;
        }
         ;
    }

       {
         (canSee) {
               player.getComponent(PlayerComponent.class);
               pc.isRunning() ? DETECTION_RATE *  : DETECTION_RATE;
            detectionMeter = Math.min(, detectionMeter + rate * tpf);
             (detectionMeter > ) transitionTo(DetectionState.SUSPICIOUS);
        }  {
            detectionMeter = Math.max(, detectionMeter - DECAY_RATE * tpf);
        }
    }

       {
         (canSee) {
            detectionMeter = Math.min(, detectionMeter + DETECTION_RATE *  * tpf);
             (detectionMeter >= ) transitionTo(DetectionState.ALERTED);
        }  {
            detectionMeter = Math.max(, detectionMeter - DECAY_RATE *  * tpf);
             (detectionMeter <= ) transitionTo(DetectionState.PATROLLING);
        }
    }

       {
         (canSee) {
            lastKnownPos = player.getCenter();
            chasePlayer(player);
        }  {
            transitionTo(DetectionState.SEARCHING);
        }
    }

       {
         (canSee) { transitionTo(DetectionState.ALERTED); ; }
        searchTimer += tpf;
         (searchTimer >= SEARCH_DURATION) {
            detectionMeter = ;
            searchTimer = ;
            transitionTo(DetectionState.PATROLLING);
        }  {
            
            patrol.moveTo(lastKnownPos);
        }
    }

       {
        state = newState;
         (newState) {
             PATROLLING -> patrol.resume();
             SUSPICIOUS -> patrol.pause();
             ALERTED    -> {
                patrol.pause();
                alertNearbyGuards();
                play();
            }
             SEARCHING  -> {
                searchTimer = ;
                patrol.moveTo(lastKnownPos);
            }
        }
    }

       {
           entity.getComponent(AStarMoveComponent.class);
        astar.moveToCell(
            ()(player.getX() / TILE),
            ()(player.getY() / TILE));
    }

       {
        getGameWorld().getEntitiesByType(EntityType.GUARD)
                .stream()
                .filter(g -> g.getCenter().distance(entity.getCenter()) < )
                .forEach(g -> g.getComponent(GuardComponent.class)
                               .transitionTo(DetectionState.ALERTED));
    }

       {
        
    }

     Point2D  {
           Math.toRadians(angleDegrees);
          (Math.cos(rad), Math.sin(rad));
    }
}