Case Study · 04 / 05 Oct 2019 — Dec 2019

Flashlight

Role: Game Designer · Level Designer
Context: NYU Game Center (2019 Halloween)
Engine · Genre: Unity · Top-Down Survival Horror
Link: Itch Page ↗

Overview

Flashlight is a top-down survival horror game built in Unity. The central conceit is a mechanic that punishes sight — the flashlight attracts monsters, forcing players to weaponize darkness to survive.

Featured in the NYU Game Center 2019 Halloween Showcase. The dynamic field-of-view system — rendered mesh, real-time targeting, layered audio — is the beating heart of the project.

Contributions

Puzzle and level design — circular layouts with non-linear paths.
Dynamic field-of-view — mesh-based sight that detects and handles targets in real time.
Atmospheric audio implementation — ambience, interaction cues, monster vocals.

Chapter 01

Level Design

Abandoned house · top-down plan

Tight, looping spaces

Abandoned house — tight, confined spaces that force decisions. Circular layout — natural, non-linear paths that loop back on themselves.

Wires as visual guides and puzzle clues — follow the cable, find the answer.

Chapter 02

FOV Implementation

Cone mesh · real-time occlusion

Mesh-based sight

Initialization — view angle and mesh creation. Real-time visualization — sight area rendered as a dynamic mesh.

Target identification within the cone of view. Status updates whenever targets enter or leave visibility.

FieldOfView.cs

                using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class FieldOfView : MonoBehaviour
{
    public static bool on = false;
    public float viewRadius;
    [Range(0,360)]
    public float viewAngle;
    public float viewAngleAmount;
    public LayerMask targetMask;
    public LayerMask obstacleMask;
    [HideInInspector]
    public List<Transform> visibleTargets = new List<Transform>();
    public float meshResolution;
    public int edgeResolveIterations;
    public float edgeDstThreshold;
    public MeshFilter viewMeshFilter;
    public Transform monster;
    Mesh viewMesh;
    private void Start()
    {
        viewAngle = 0;
        viewMesh = new Mesh();
        viewMesh.name = "View Mesh";
        viewMeshFilter.mesh = viewMesh;
        StartCoroutine("FindTargetsWithDelay", .2f);
    }
    IEnumerator FindTargetsWithDelay(float delay)
    {
        while (true)
        {
            yield return new WaitForSeconds(delay);
            FindVisibleTargets();
        }
    }
    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.Mouse0))
        {
            if (on)
            {
                on = false;
                viewAngle = 0;
            }
            else if (!on)
            {
                on = true;
                viewAngle = viewAngleAmount;
            }
        }
        SetStayToFalse();
    }
    private void LateUpdate()
    {
        DrawFieldOfView();
    }
    void SetStayToFalse()
    {
        if (visibleTargets.Count > 0)
        {
            for (int i = 0; i < visibleTargets.Count; i++)
            {
                visibleTargets[i].gameObject.GetComponent<StoreEnemyTarget>().enemyTarget.GetComponent<EnemyTargetSetter>().activated = true;
            }
        }
    }
    void FindVisibleTargets()
    {
        visibleTargets.Clear();
        Collider2D[] targetsInViewRadius = Physics2D.OverlapCircleAll(transform.position, viewRadius, targetMask);
        for (int i = 0; i < targetsInViewRadius.Length; i++)
        {
            Transform target = targetsInViewRadius[i].transform;
            Vector3 dirToTarget = (target.position - transform.position).normalized;
            if (Vector3.Angle(transform.up, dirToTarget) < viewAngle / 2)
            {
                float dstToTarget = Vector3.Distance(transform.position, target.position);
                if (!Physics2D.Raycast(transform.position, dirToTarget, dstToTarget, obstacleMask))
                {
                    visibleTargets.Add(target);
                }
            }
        }
    }
    void DrawFieldOfView()
    {
        int stepCount = Mathf.RoundToInt(viewAngle * meshResolution);
        float stepAngleSize = viewAngle / stepCount;
        List<Vector3> viewPoints = new List<Vector3>();
        ViewCastInfo oldViewCast = new ViewCastInfo();
        for (int i = 0; i <= stepCount; i++)
        {
            float angle = transform.eulerAngles.y - viewAngle / 2 + stepAngleSize * i;
            ViewCastInfo newViewCast = ViewCast(angle);
            if (i > 0)
            {
                bool edgeDstThresholdExceeded = Mathf.Abs(oldViewCast.dst - newViewCast.dst) > edgeDstThreshold;
                if (oldViewCast.hit != newViewCast.hit || (oldViewCast.hit && newViewCast.hit && edgeDstThresholdExceeded))
                {
                    Edgeinfo edge = FindEdge(oldViewCast, newViewCast);
                    if (edge.pointA != Vector3.zero) { viewPoints.Add(edge.pointA); }
                    if (edge.pointB != Vector3.zero) { viewPoints.Add(edge.pointB); }
                }
            }
            viewPoints.Add(newViewCast.point);
            oldViewCast = newViewCast;
        }
        int vertexCount = viewPoints.Count + 1;
        Vector3[] vertices = new Vector3[vertexCount];
        int[] triangles = new int[(vertexCount - 2) * 3];
        vertices[0] = Vector3.zero;
        for (int i = 0; i < vertexCount - 1; i++)
        {
            vertices[i + 1] = transform.InverseTransformPoint(viewPoints[i]);
            if (i < vertexCount - 2)
            {
                triangles[i * 3] = 0;
                triangles[i * 3 + 1] = i + 1;
                triangles[i * 3 + 2] = i + 2;
            }
        }
        viewMesh.Clear();
        viewMesh.vertices = vertices;
        viewMesh.triangles = triangles;
        viewMesh.RecalculateNormals();
    }
    public struct ViewCastInfo
    {
        public bool hit;
        public Vector3 point;
        public float dst;
        public float angle;
        public ViewCastInfo(bool _hit, Vector3 _point, float _dst, float _angle)
        {
            hit = _hit; point = _point; dst = _dst; angle = _angle;
        }
    }
    public struct Edgeinfo
    {
        public Vector3 pointA;
        public Vector3 pointB;
        public Edgeinfo(Vector3 _pointA, Vector3 _pointB)
        {
            pointA = _pointA; pointB = _pointB;
        }
    }
}

              

                C#
                171 lines
              

Chapter 03

Audio Design

01 · Ambience

Background Depression

02 · Interaction Cues

Door closes

Light torch open

Locked

Player footstep

03 · Monster Vocals

Monster roar 1

Monster roar 2

Horror in the ear

Horror lives in the ear, not the eye. I layered ambience, interaction cues, and monster vocals so the soundscape could do most of the scaring.

Three channels stack on top of each other: the dread bed, the player's own sounds (door, torch, lock, footstep), and the monster's vocals — each tuned so players learn the creature through hearing before ever seeing it.

Next · 05 / 05 VAMP →

1	using System.Collections;
2	using System.Collections.Generic;
3	using UnityEngine;
4
5	public class FieldOfView : MonoBehaviour
6	{
7	public static bool on = false;
8	public float viewRadius;
9	[Range(0,360)]
10	public float viewAngle;
11	public float viewAngleAmount;
12	public LayerMask targetMask;
13	public LayerMask obstacleMask;
14	[HideInInspector]
15	public List<Transform> visibleTargets = new List<Transform>();
16	public float meshResolution;
17	public int edgeResolveIterations;
18	public float edgeDstThreshold;
19	public MeshFilter viewMeshFilter;
20	public Transform monster;
21
22	Mesh viewMesh;
23
24	private void Start()
25	{
26	viewAngle = 0;
27	viewMesh = new Mesh();
28	viewMesh.name = "View Mesh";
29	viewMeshFilter.mesh = viewMesh;
30	StartCoroutine("FindTargetsWithDelay", .2f);
31	}
32
33	IEnumerator FindTargetsWithDelay(float delay)
34	{
35	while (true)
36	{
37	yield return new WaitForSeconds(delay);
38	FindVisibleTargets();
39	}
40	}
41
42	private void Update()
43	{
44	if (Input.GetKeyDown(KeyCode.Mouse0))
45	{
46	if (on)
47	{
48	on = false;
49	viewAngle = 0;
50	}
51	else if (!on)
52	{
53	on = true;
54	viewAngle = viewAngleAmount;
55	}
56	}
57	SetStayToFalse();
58	}
59
60	private void LateUpdate()
61	{
62	DrawFieldOfView();
63	}
64
65	void SetStayToFalse()
66	{
67	if (visibleTargets.Count > 0)
68	{
69	for (int i = 0; i < visibleTargets.Count; i++)
70	{
71	visibleTargets[i].gameObject.GetComponent<StoreEnemyTarget>().enemyTarget.GetComponent<EnemyTargetSetter>().activated = true;
72	}
73	}
74	}
75
76	void FindVisibleTargets()
77	{
78	visibleTargets.Clear();
79	Collider2D[] targetsInViewRadius = Physics2D.OverlapCircleAll(transform.position, viewRadius, targetMask);
80
81	for (int i = 0; i < targetsInViewRadius.Length; i++)
82	{
83	Transform target = targetsInViewRadius[i].transform;
84	Vector3 dirToTarget = (target.position - transform.position).normalized;
85
86	if (Vector3.Angle(transform.up, dirToTarget) < viewAngle / 2)
87	{
88	float dstToTarget = Vector3.Distance(transform.position, target.position);
89
90	if (!Physics2D.Raycast(transform.position, dirToTarget, dstToTarget, obstacleMask))
91	{
92	visibleTargets.Add(target);
93	}
94	}
95	}
96	}
97
98	void DrawFieldOfView()
99	{
100	int stepCount = Mathf.RoundToInt(viewAngle * meshResolution);
101	float stepAngleSize = viewAngle / stepCount;
102	List<Vector3> viewPoints = new List<Vector3>();
103	ViewCastInfo oldViewCast = new ViewCastInfo();
104
105	for (int i = 0; i <= stepCount; i++)
106	{
107	float angle = transform.eulerAngles.y - viewAngle / 2 + stepAngleSize * i;
108	ViewCastInfo newViewCast = ViewCast(angle);
109
110	if (i > 0)
111	{
112	bool edgeDstThresholdExceeded = Mathf.Abs(oldViewCast.dst - newViewCast.dst) > edgeDstThreshold;
113
114	if (oldViewCast.hit != newViewCast.hit \|\| (oldViewCast.hit && newViewCast.hit && edgeDstThresholdExceeded))
115	{
116	Edgeinfo edge = FindEdge(oldViewCast, newViewCast);
117	if (edge.pointA != Vector3.zero) { viewPoints.Add(edge.pointA); }
118	if (edge.pointB != Vector3.zero) { viewPoints.Add(edge.pointB); }
119	}
120	}
121
122	viewPoints.Add(newViewCast.point);
123	oldViewCast = newViewCast;
124	}
125
126	int vertexCount = viewPoints.Count + 1;
127	Vector3[] vertices = new Vector3[vertexCount];
128	int[] triangles = new int[(vertexCount - 2) * 3];
129	vertices[0] = Vector3.zero;
130
131	for (int i = 0; i < vertexCount - 1; i++)
132	{
133	vertices[i + 1] = transform.InverseTransformPoint(viewPoints[i]);
134	if (i < vertexCount - 2)
135	{
136	triangles[i * 3] = 0;
137	triangles[i * 3 + 1] = i + 1;
138	triangles[i * 3 + 2] = i + 2;
139	}
140	}
141
142	viewMesh.Clear();
143	viewMesh.vertices = vertices;
144	viewMesh.triangles = triangles;
145	viewMesh.RecalculateNormals();
146	}
147
148	public struct ViewCastInfo
149	{
150	public bool hit;
151	public Vector3 point;
152	public float dst;
153	public float angle;
154
155	public ViewCastInfo(bool _hit, Vector3 _point, float _dst, float _angle)
156	{
157	hit = _hit; point = _point; dst = _dst; angle = _angle;
158	}
159	}
160
161	public struct Edgeinfo
162	{
163	public Vector3 pointA;
164	public Vector3 pointB;
165
166	public Edgeinfo(Vector3 _pointA, Vector3 _pointB)
167	{
168	pointA = _pointA; pointB = _pointB;
169	}
170	}
171	}