Success?
Now that my project is complete, I can reflect on my achievements and evaluate my success based on my initial project proposal, comparing my original plan to the final outcome.
​
The central question guiding my project was: “How can I create believable hostile NPCs, which respond appropriately to a given situation?” This question shaped all my research and planning. Throughout the project, I continually assessed my progress against this objective.
​
However, this was not my initial proposal. Initially, I aimed to explore, “How can I create believable lifelike NPCs which mimic human nature?” This broader question included both hostile and friendly NPCs. Early on, I realised this scope was overly ambitious given the project’s timeframe and the new skills I needed to learn. Therefore, I narrowed my focus to hostile NPCs.
​
Reflecting on this decision, I am confident it was the right choice. Researching hostile NPCs alone took longer than anticipated, and my final product still lacks several initially planned features. Attempting to develop both hostile and friendly NPCs would have been unrealistic within the given timeframe.
​
Evaluating my revised question, “How can I create believable hostile NPCs, which respond appropriately to a given situation?”, I believe I have succeeded. My extensive research into advanced NPC examples informed my development process. By integrating proven mechanics from these examples, I ensured a high-quality outcome.
​
Feedback from peers and tutors consistently indicated that the AI performs as expected for realistic NPCs. While additional features, such as investigation mechanics, were suggested, these would enhance rather than define the project's success. I achieved my primary goal.
​
Initially, I intended to create a questionnaire to gather feedback on my AI's performance. However, due to time constraints, I could not produce the necessary demonstration videos. Instead, I showcased my in-engine product to peers and tutors, obtaining valuable feedback that confirmed the AI's logical behaviour, thereby affirming the project's success.
​
I am satisfied with the quality of my project proposal. Despite some issues during the project, I do not believe they stemmed from the proposal itself. The question was challenging yet achievable, allowing me to develop useful skills. Although revising my original proposal consumed time, it was ultimately beneficial, and I do not regret this decision.
​
My rationale was comprehensive, outlining why this project would be valuable and even referencing an external source to strengthen my argument. However, many initially planned mechanics were not included in the final product, mainly due to my research highlighting more valuable alternatives. For instance, I originally envisioned creating multiple NPCs with varied interactions (including with the environment), but this proved impractical within the project's timeframe. Instead, focusing on a single NPC reacting to the player allowed for a more in-depth exploration of its behaviours.
​
The simplicity of the scene where my NPC operates contrasts with my initial vision of more realistic environments. However, the minimalist setting sufficed for testing purposes, as my primary goal was to develop realistic NPC behaviours, not detailed environments.
​
My evaluation process was thorough, allowing for extensive reflection on my progress. The main shortcoming was the uncompleted questionnaire, but this has been addressed above.
​
Regarding my proposal’s sources, while they initially appeared valuable, I discovered more relevant resources during my actual research phase, reducing the reliance on the proposal’s original sources.
​
Although my tutors praised the detailed timeline in my proposal, I personally found it somewhat vague. It served as a preliminary framework, awaiting refinement post-research. Once my research concluded, I developed a more precise and realistic timeline.
​
In conclusion, while I regret not implementing some planned features, such as NPC interaction, the project succeeded in achieving its primary goal. The NPCs created are realistic and perform logically, as confirmed by feedback. Despite the omissions, the project was a success, fulfilling the intended objective of developing believable hostile NPCs.
Research & Planning
Before beginning my research, I had to outline what I needed to investigate. I decided to start with advanced examples of NPCs in games, as my limited knowledge in this area meant it would provide a solid foundation. Recognising that most NPCs use some form of pathfinding, I decided this would be the next area to research. Although I initially planned to cover Finite State Machines (FSMs), behaviour trees, and machine learning, I ultimately cut machine learning due to time constraints and its absence in my research on advanced NPCs. This streamlined approach covered the core of my planned research, enabling me to proceed with planning the creation of my AI. Although I was unable to plan the implementation of mechanics due to time constraints, I managed to outline what I wanted to create. This phase was completed within the three-week period outlined in my proposal. As part of my planning, I updated my timeline with a more accurate Gantt chart, thus retiring my timeline first introduced in my proposal.
​
When I began my research, I felt somewhat overwhelmed, largely due to the limited sources on NPCs in games. To get the project moving, I started with pathfinding within Unity.
Further Pathfinding Research
Numerous resources, such as Unity's official tutorial and relevant YouTube videos, helped me gain a solid understanding of pathfinding. Prior to this project, I had no experience with pathfinding, but my research enabled me to utilise it effectively for my project. Recognising the importance of pathfinding as the foundation for any game AI, this research was crucial.
Prototype of Pathfinding
Numerous resources, such as Unity's official tutorial and relevant YouTube videos, helped me gain a solid understanding of pathfinding. Prior to this project, I had no experience with pathfinding, but my research enabled me to utilise it effectively for my project. Recognising the importance of pathfinding as the foundation for any game AI, this research was crucial.
​
Next, I revisited my exploration of NPCs in general, as this was essential for the project's success. Given my limited knowledge of advanced NPCs, I required substantial research in this area. A lot of my planned mechanics for my own NPC were to be retrieved from these delves into existing case studies - only further stressing their importance. My tutor (Robert) recommended looking into the game "F.E.A.R", which consistently appeared in lists of advanced game AI. This confirmed its complexity and realism, making it a top priority for my research. F.E.A.R provided valuable insights into what makes an NPC advanced and how to create and plan such NPCs.
F.E.A.R NPC Behaviour Demonstration
This research opened up numerous other games with advanced AI. I chose to investigate Alien: Isolation, Left 4 Dead, Halo 2, and Half-Life. While Alien: Isolation offered advanced mechanics that helped to influence my project it did little else. It is a great example of how behaviour trees can be used within games, but ultimately I explored this path elsewhere.
Left 4 Dead's director AI was less relevant to my objectives. This is due to it being a director AI, a form of AI used to change the game world, rather than interact with the player; whilst it wasn't useful here it may be for future projects.
Left 4 Dead NPC Analysis
Halo 2 and Half-Life offered valuable research into the creation of their AI, utilising behaviour trees and FSMs respectively. Despite gaining a vague understanding, I remained undecided on which approach was best for my project. This wasn't all Halo 2 and Half Life provided however, they did offer further insight into what makes AI advanced within games.
Half Life NPC Analysis
Typical Halo 2 behaviour tree, demonstrating their ease to read and program.
Halo 2 NPC Analysis
To inform my decision, I delved deeper into FSMs using a tutorial series, gaining a complete and thorough understanding by the end. To further my understanding of the tutorial I prototyped along side. Unfortunately this took nearly a week to complete.
The First FSM Tutorial
The Second FSM Tutorial
The Third FSM Tutorial
The Fourth FSM Tutorial
This left little time for my planned research into behaviour trees. Fortunately, the Easter holidays provided an opportunity to catch up. For behaviour trees, I explored both coding and visual-based implementations. Starting with a coding-based tutorial helped me create a prototype behaviour tree, which I ultimately used for my NPC. I decided to start here as its where I felt most confident, especially after coming straight from coding FSMs.
The sequence node at the top dictates that all nodes present underneath are executed in order from left to right. Selector nodes indicate that certain actions are executed only if specific conditions are met. The nodes that terminate branches are known as leaf nodes, indicating that an action is being performed. If the tree is followed through entirely, it can loop, or a separate tree can begin to be explored.
Coding Behaviour Trees Tutorial
Visual scripting methods were explored next, but not tested or used due to their complexity and cost. If I were to use visual scripting there were two opportunities, starting with using Unreal Engine. Whilst Unreal Engine is a popular game engine I felt it'd be too much to learn on top of all my NPC research. I already had experience in Unity, so this came naturally to me. The other possible method was through "Behavior Designer - Behavior Trees for Everyone", this is a plug-in which can be used with Unity. Looking at its interface it did look very appealing, and effective. But there were two main drawbacks, namely the price tag (£76.45), it was rather expensive for a college project. Whilst I may have used it after college I ultimately deemed it not worth it. The other drawback was my simple preference for coding, I feel if I were to use visual scripting I'd be missing this element I enjoy as well as not learning in the area I planned to.
After weighing the pros and cons of all methods, I chose coding behaviour trees. While initially leaning towards FSMs due to their simplicity, behaviour trees proved to be easier and more suitable for my project. Visual scripting was discounted due to the lack of coding experience gained and the associated costs. The chosen method allowed me to learn and achieve the desired outcome, confirming it as the right decision. Utilising the free framework provided in the coding behaviour trees tutorial, made the right decision looking back on this project. Ensuring I learned ample in all areas planned, allowing me to create my NPC to the best of my ability.
​
With my research complete, I moved on to planning. I analysed my collected research, selecting mechanics that contributed to my initial question and were feasible within my skill set and timeframe. Although I wanted to explore how to create these mechanics, time constraints forced me to start practical work after only outlining what I wanted to create. This led to problems later, as I had to research solutions on the spot during development. I believe this problem arose due to spending so much time researching the different methods of programming AI, if I could've perhaps limited this research and dedicated some to how to create certain mechanics, I believe my project would've been pushed further. Not that it needed pushing further to be a success.
​
I planned to create a new timeline at this point, and using a free online tool, I created a Gantt chart per my tutor's recommendation.
This chart proved invaluable for tracking progress and adjusting plans as needed.
I followed this chart closely until I began to fall behind during my practical work, because of this I readjusted my planning creating an updated Gantt chart. My tutor also highlighted gaps in my planning, leading to the creation of a mood board and SWOT analysis. The mood board, while challenging to create, visually showcased NPC actions and their sources, enhancing the presentation of my research. The core reason the moodboard was so challenging to create was due to trying to illustrate actions (which typically happen over a period of time) within one single image. I found the solution which appeared to be using the game's logo which the mechanic was found it and then simply writing a description. Unfortunately the mood board didn't help me too much as I had to the core of my research gathered, but it should effectively demonstrate to my audience what I aimed to achieve.
Looking at the SWOT analysis, this initially felt quite barren. But looking back I filled it with all the details and information that I could. And this information did help me, highlighting opportunities I could take advantage of (such as using the Easter Holidays as catch-up time). As well as showcasing my weakness and threats, to which I could work to improve or avoid.
​
I believe my research and planning are the highest points of my project, as you can probably guess by how long this section is. A significant part of my time was dedicated to the research and understanding of what I was required to create in order to develop realistic NPCs. Whilst my planning is quite brief, at least in comparison to my research it still covered all necessary areas and was effectively used throughout my project. I believe I covered a majority of the areas needed, utilising a range of sources effectively, but not overly relying on them. Making educated decisions based on this research and my own judgement.
​
In conclusion, my research covered a wide range of areas, and I utilised a variety of sources effectively. The main shortfall was the lack of detailed research into how to create individual mechanics, which led to challenges during development. However, given the comprehensive nature of my research and the time constraints, finding additional time for this would have been difficult. Despite not implementing all planned features, my project was a success in achieving its primary goal: creating realistic NPCs that perform logically.
​Skills Developed during the Development
Whilst this project was influenced by multiple sources, all behaviours programmed for my NPC were created independently by myself, with minor assistance from tutors in some areas. The only aspect adapted from a pre-existing model is the scripts used to implement the logic of the behaviour trees, the patrol script and the FOV script.
Behaviour Tree Logic & Patrol Script
FOV Script
Regarding the behaviour tree logic, I chose to adapt pre-existing scripts to save time and, more importantly, because the complexity of the logic exceeded my current skill set. To progress my project beyond the initial creation of the logic, this adaptation was necessary.
​
Once the development commenced, several problems arose that required swift resolution. To address these issues, I utilised additional scripts, a necessary step to advance the project and achieve the goal of creating advanced NPCs. This approach was essential for the project's success.
​
This project served as my entry point into exploring NPCs within games. Before beginning production, I started by prototyping some key areas of development, starting with pathfinding, as this is prevalent in most games. Prototyping this feature allowed me to gain a comprehensive understanding of the topic, enabling me to implement it within my own NPC for this project and future endeavours.
​
Pathfinding was crucial; without it, my NPCs would be unable to traverse their environment, resulting in a failed project. To create realistic NPCs, they need to interact with a variety of variables. If they were unable to interact with the environment—perhaps the most significant variable—it would severely undermine my project's success.
Prototype of Pathfinding
Regarding the behaviour tree logic, I chose to adapt pre-existing scripts to save time and, more importantly, because the complexity of the logic exceeded my current skill set. To progress my project beyond the initial creation of the logic, this adaptation was necessary.
​
Once the development commenced, several problems arose that required swift resolution. To address these issues, I utilised additional scripts, a necessary step to advance the project and achieve the goal of creating advanced NPCs. This approach was essential for the project's success.
​
This project served as my entry point into exploring NPCs within games. Before beginning production, I started by prototyping some key areas of development, starting with pathfinding, as this is prevalent in most games. Prototyping this feature allowed me to gain a comprehensive understanding of the topic, enabling me to implement it within my own NPC for this project and future endeavours.
​
Pathfinding was crucial; without it, my NPCs would be unable to traverse their environment, resulting in a failed project. To create realistic NPCs, they need to interact with a variety of variables. If they were unable to interact with the environment—perhaps the most significant variable—it would severely undermine my project's success.
​
This was not the only area I prototyped; I also explored different methods to program AI. It was crucial to explore these areas as I was still uncertain about how I planned to create my AI. Additionally, I had no prior experience programming AIs, making this an area of weakness I needed to address.
​
I first started with Finite State Machines (FSMs), assuming they would be the simplest due to their status as the original method for AI programming. This assumption was somewhat confirmed during the prototyping process, which I achieved by following a tutorial series.
The First FSM Tutorial
The Second FSM Tutorial
The Third FSM Tutorial
The Fourth FSM Tutorial
Regarding the behaviour tree logic, I chose to adapt pre-existing scripts to save time and, more importantly, because the complexity of the logic exceeded my current skill set. To progress my project beyond the initial creation of the logic, this adaptation was necessary.
​
Once the development commenced, several problems arose that required swift resolution. To address these issues, I utilised additional scripts, a necessary step to advance the project and achieve the goal of creating advanced NPCs. This approach was essential for the project's success.
​
This project served as my entry point into exploring NPCs within games. Before beginning production, I started by prototyping some key areas of development, starting with pathfinding, as this is prevalent in most games. Prototyping this feature allowed me to gain a comprehensive understanding of the topic, enabling me to implement it within my own NPC for this project and future endeavours.
​
Pathfinding was crucial; without it, my NPCs would be unable to traverse their environment, resulting in a failed project. To create realistic NPCs, they need to interact with a variety of variables. If they were unable to interact with the environment—perhaps the most significant variable—it would severely undermine my project's success.
​
This was not the only area I prototyped; I also explored different methods to program AI. It was crucial to explore these areas as I was still uncertain about how I planned to create my AI. Additionally, I had no prior experience programming AIs, making this an area of weakness I needed to address.
​
I first started with Finite State Machines (FSMs), assuming they would be the simplest due to their status as the original method for AI programming. This assumption was somewhat confirmed during the prototyping process, which I achieved by following a tutorial series.
​
Initially, the logic was quite confusing to me, but as the series progressed, I slowly gained an understanding. Eventually, I felt quite confident not only in my ability to follow the code but also in my ability to use it for my own project. While following this tutorial, I gained a new skill as a side-effect: the author of the code I was following used debug statements very frequently. This highlighted to me the importance of these within scripts, and as a result, I have been making an effort to include them in my own work.
​
Following this, I moved on to behaviour trees, specifically coding them. I followed a tutorial that managed to strike a balance between being relatively short and informative.
Behaviour Tree Logic & Patrol Script
This was especially useful given my eagerness to move onto production. Similar to the Finite State Machine tutorial, this tutorial began as quite confusing. However, as I progressed with my prototyping, going line by line and trying to understand what it all meant, it eventually clicked. Consequently, it ended up being, to me, simpler to program compared to FSMs. I became so confident in my understanding and my ability to use this method that it became my chosen method for this project. While this wasn’t a visual scripting method, the coding pathway is simply an alternative to this. As a result, I believe I’ve also gained enough understanding to proficiently program in a visual scripting environment.
​
Now, reflecting on exactly what I created during my development and the skills I developed, I first started with the creation of a patrol state. This script, serving as my first solo development of a behaviour tree, furthered my understanding immensely of the logic. This allowed me to better use these techniques for further behaviours. Since this script was relatively simple (aside from the behaviour tree logic), not much else was required to be learned.
NPC Patrol Showcase
Next came the vision system, which required significant development. My initial proposed solution (which I'll delve into later) didn’t work, necessitating research for alternative solutions. Eventually, I found a successful solution through a video tutorial.
FOV Tutorial
This tutorial employed a method I was familiar with—raycasts—but I hadn't considered their application for this mechanic. The scripts used for this vision system contained complex logic, which was challenging for me to understand but not insurmountable. I was able to integrate it effectively with my behaviour tree, despite its complexity. One key element this script introduced me to was the ability to set a range for variables, a new feature for me. Additionally, it was accompanied by an editor script, which was another new and complex element. Editor scripts can be used to further enhance and aid whichever script they're attached to. I anticipate that understanding and utilizing editor scripts will benefit me in future projects. Another new element introduced was the ability to draw "handles," which aid in debugging and understanding the NPC's field of view for this project.
​
This script was integrated into my behaviour tree to create a player detection node. If the player was detected, the NPC's logic would transition to chasing the player, utilizing the pathfinding created earlier, thus highlighting its importance.
NPC Chase Showcase
This concluded my first week of production. In the second week, despite encountering struggles, I gained valuable understanding. I believe that overcoming these challenges was instrumental in deepening my comprehension of the subject matter. One significant aspect of my learning process involved revisiting my understanding of behaviour tree logic. Initially, I was unclear about the meaning of "RUNNING" once the node was left. However, through exploration, I realized that it signified the node's logic could continue even after the script moved on.
​
Another area I delved into was the differentiation between selector and sequence nodes, which turned out to be crucial for my project. Understanding this distinction was imperative for the functionality of my script. I discovered that their reactions to failures and successes differed significantly, which greatly aided the progress of my project. Given that behaviour trees are prevalent in the majority of modern games, this knowledge not only benefits this project but also my future career as a game developer.
​
Although it may seem that only a few skills were acquired, this is due to the complexity of the skills involved. Learning to program in both FSM and behaviour trees can be challenging, but I now possess knowledge in both areas, with a focus on behaviour trees. I am now capable of confidently programming an NPC with a behaviour tree, equipped with a thorough understanding of their logic. This skill will facilitate the creation of NPCs beyond this project, making the process more efficient.
Challenges Faced during the Development
Throughout this project, I encountered numerous challenges, many of which I successfully overcame. However, overcoming these challenges was far from easy.
​
One significant difficulty I encountered was the initial struggle to gather reference images. When researching NPC behaviours in games, I found that there were limited sources providing visual representations of these topics. This posed a considerable obstacle that needed to be addressed before I could effectively commence my project.
F.E.A.R NPC Behaviour Demonstration
While I'm still lacking a substantial amount of visual representation, I managed to find a video showcasing the AI in F.E.A.R. This video effectively demonstrates the complex behaviours of this AI, which I found quite satisfactory. However, my only concern is that this video is the sole showcase of such behaviours. As a final solution to address this issue, I opted to use game logos along with descriptions of the behaviours I found noteworthy.
This approach was adopted for my moodboard.
​
As previously mentioned, I encountered difficulties in finding sources for my research on advanced NPCs. Eventually, I came across a publisher who conducted comprehensive analyses of individual games and their NPCs.
Besides relying on the insights provided by the aforementioned publisher, my assigned tutor also directed me towards F.E.A.R. due to its iconic status regarding NPCs and their complexity.
​
As previously mentioned, I encountered some challenges in deciding how to program my NPCs. Consequently, I opted to delve more deeply into the various methods available.
The First FSM Tutorial
The Second FSM Tutorial
The Third FSM Tutorial
The Fourth FSM Tutorial
Behaviour Tree Logic & Patrol Script
I accomplished this by following a tutorial series for FSMs and a tutorial video for behaviour trees. These resources provided comprehensive coverage of the concepts needed to begin production, ultimately leading me to the decision to use behaviour trees. Reflecting on the completion of my project, I am confident that this was the correct decision. Behaviour trees are widely used for programming NPCs in the game industry, making this knowledge essential for anyone aspiring to join it. Moreover, based on the research I conducted, I believe I selected the right method in terms of ease of implementation. If I had chosen a different method, I might not have achieved as much progress.
​
However, I encountered a challenge when it came to showcasing scripts. Simply screenshotting them resulted in poor quality and often required multiple screenshots per script. I needed to find a method to improve the quality of my showcases.
Through consulting with ChatGPT, I discovered a website that generated clean and stylish images for free, effectively resolving this issue and greatly enhancing the aesthetics of my project.
​
Moving on to the challenges during production, I encountered several significant issues. The first of these was devising a method to implement patrol points for my NPC.
Behaviour Tree Logic & Patrol Script
At this juncture, I recollected that the scripting behaviour tree tutorial also included a patrol script, which I repurposed for my project. This solution efficiently addressed the issue and provided a satisfactory method for implementing a patrol state for my NPC. Moreover, this patrol script proved beneficial beyond its initial application, as it facilitated the creation of additional scripts, as will be elaborated upon later.
​
The subsequent challenge I confronted was rather substantial: devising a vision system for my NPC. This system was essential for enabling the NPC to detect the player, with the added complexity of ensuring that its vision would be obstructed by walls. Consequently, my initial plan of employing a game object to detect the player proved inadequate, at least in its simplicity.
FOV Tutorial
This challenge prompted me to seek out a tutorial, eventually settling on one that effectively resolved my issue while also imparting new skills, as previously mentioned.
​
Subsequently, the project encountered its most formidable obstacle: the implementation of the last known position system. This problem persisted for a week, with all attempts at resolution either yielding minimal progress or none at all. Initially, I suspected that the issue lay in the structure of my behaviour tree, prompting me to revisit behaviour tree logic, as previously described. This proved to be a beneficial endeavour. However, despite taking a step in the right direction by introducing an additional script to check if the player was no longer visible, I initially failed to recognize its efficacy and consequently reverted this change for much of my testing.
​
The primary issue with my script was that once the NPC's destination was changed to the last known position, it would immediately revert to patrolling even if the destination had not been reached. Although I identified this as the problem, I struggled to find a solution independently. Various attempted solutions, such as implementing a timer or checking if the NPC was still in motion, proved unsuccessful. Seeking assistance from AI chatbots, including ChatGPT and CoPilot, also failed to yield a solution.
​
At this juncture, I opted to seek guidance from my tutors. While Matthew acknowledged the issue with the structure of the behaviour tree, he was unable to provide a solution. Fortunately, Joshua was able to devise a working solution, which I subsequently implemented. Although minor issues initially arose with this solution, they were swiftly resolved without significant impact.
​
While the successful creation of this mechanic greatly enhanced the realism of my NPC, its development consumed more time than anticipated, resulting in the loss of a week's worth of development time for other mechanics. Despite considering abandoning this mechanic to focus on other features, I deemed it crucial for the believability of my NPC's player detection script. Consequently, I persevered in resolving the issue.
​
The considerable time invested in addressing this problem caused some stress, particularly as I encountered immediate difficulties when attempting to work on the investigation system. With limited time remaining for production and no immediate solution in sight, I opted to abandon this mechanic in favour of pursuing another task.
​
Turning my attention to the cover system, I initially attempted to modify the FOV script to detect viable cover options. However, it quickly became apparent that this approach was not feasible, necessitating the development of an entirely new script.
NPC Cover System Tutorial
Upon discovering a video tutorial that offered the necessary script, I realized that following and replicating it would consume an impractical amount of time. This realization underscored the significance of the time lost, compounding the pressure to find efficient solutions to remaining tasks. I believe a majority of the time lost is due to the significant amount of research I conducted, but this all felt essential. Because of this it is difficult to decide what I would change.
At this juncture, I made the prudent decision to devise a new plan, factoring in the time lost. This involved creating an updated Gantt Chart, albeit with some minor hiccups in the software that I swiftly resolved.
​
This strategic shift enabled me to focus on smaller, more manageable tasks, ensuring optimal utilization of the final week of production.
​
One such task was the implementation of the hearing system, which followed closely after the last known position system. Initially, I attempted to adapt a similar solution, but soon realized the need to draw from my enemy detection script. This adjustment proved pivotal in overcoming the challenge.
​
In addition to equipping my NPC with a hearing system, I also needed the player to generate sound. While this posed a challenge initially, my breakthrough came when I realized I could simply monitor the player's movement inputs. This successful implementation marked the culmination of my NPC's feature set.
​
As I prepared to showcase my work on my website, I recognized the importance of making my code accessible to a lay audience. To this end, I diligently commented all my scripts, a decision that proved effective in enhancing comprehension, despite some brevity noted by my tutor. Given the impending deadline, there is little I can do.
​
Reflecting on my project journey, I am pleased to affirm that I adhered closely to my initial plan, despite its eventual modifications. By remaining flexible yet focused, I successfully realized the objectives outlined in my proposal. This adaptive approach ensured that I navigated through challenges and adjustments while staying committed to the project's overarching goals.
​
Reflecting on the skills acquired throughout this project, I've observed notable enhancements in various areas. While my overall coding proficiency advanced subtly over the project's duration, the most significant improvements were evident in debugging and commenting practices. These seemingly minor aspects play a crucial role in code clarity and maintenance.
​
Specifically, delving into programming behaviour trees provided a substantial learning curve, culminating in a confident grasp of this methodology. This newfound proficiency empowers me to expand upon existing NPCs or embark on fresh projects with relative ease. Furthermore, while my exposure to Finite State Machines (FSMs) was more limited, I've garnered sufficient understanding to pursue further development in this area, albeit with the recognition that there's room for growth before creating NPCs from scratch using FSMs.
​
Beyond practical skills, this project fostered a deeper appreciation for thorough research methodologies. The comprehensive investigation conducted has underscored the immense value of diligent inquiry in project development. Additionally, I've honed my adaptability, exemplified by the agile adjustments made, as demonstrated in the creation of updated Gantt charts.
​
Regarding presentation, I've attained a new level of proficiency in articulating and showcasing project work. The layout adopted effectively communicates information in a clear and concise manner, contributing to a polished and professional presentation overall.
Presentation
As I have now finished my project, leaving only the presentation, I can begin considering the most effective methods to achieve this. Given that my work was carried out in Unity, resulting in a playable experience, there are numerous ways to present it. One viable option is to create an executable file and upload it to itch.io, thereby allowing it to be played by others.
However, as I haven’t created a game that employs enjoyable features, but rather a delve into realism which doesn’t often equate to fun, a video might be the best medium. With a video, I could clearly demonstrate the intended elements, ensuring that only the most significant aspects are highlighted.
High-Level Showcase Video
To maximise the impact of these videos, I could edit them into a more digestible format, similar to the League of Legends Champion Spotlights, as demonstrated by my assigned tutor. These "Champion Spotlights" use title screens to clearly illustrate what is being shown, and repeat key segments to ensure they are not missed. My tutor also emphasised the importance of pauses in such videos, to avoid missing important content at the start. These are all elements that I could effectively use to showcase my project at its best.
​​
The only issue with this method is that video editing is unfamiliar to me, and with only a week left, the approaching deadline raises concerns about my ability to produce these videos.
​
Considering the time constraints and my skill level, I believe it is best to use a combination of these methods. Uploading to itch.io is relatively easy and can be done in just a few minutes, allowing my project to be available there with minimal time investment. As this might not showcase my project to its fullest potential, I can also use unedited videos to demonstrate the specific aspects I wish to highlight. This way, I achieve a balance, but if time permits, I would still like to create these edited showcase videos.
NPC Patrol Showcase
NPC Chase Showcase
NPC Last Known Position Showcase
NPC Final Showcase
Another possible method to showcase my project is through images. However, as I have created a character that performs primarily through action, images alone would not suffice to effectively demonstrate my work. They would fail to convey the dynamic behaviours and interactions of the NPC. Even if text accompanied the images, it would not capture the full scope of the NPC's actions and decision-making processes. Therefore, while images could complement other presentation methods, they would not be adequate on their own to showcase my project comprehensively.
I encountered a similar issue when creating my moodboard—how to effectively depict actions using images. To address this, I employed accompanying descriptions. Given this, I believe it is best to adhere to videos and an executable file for showcasing my project.
This approach ensures a comprehensive presentation of my NPC's dynamic behaviours and interactions. The scripts underlying these actions are crucial for understanding the depth of my project.
I discovered a tool, Carbon, which facilitates the creation of clean, clear images of code through simple copying and pasting. Before using this tool, my screenshots were of poor quality, often blurry, and sometimes required multiple captures per script. This was suboptimal. With Carbon, I can effectively showcase my code, highlighting my understanding and the skills I utilised in developing my project.
​
To enhance the clarity of my code, I will comment on each line, explaining its function. This will benefit both myself and any viewers of the code. Due to the necessity of keeping the screenshots concise, comments will be brief. To ensure comprehensive explanations, I will add more detailed descriptions for sections of the script, making the code more accessible to non-programmers. Given the remaining time constraints, adding these descriptions will be a secondary task after completing this final evaluation.
​
Initially, I planned to gather feedback using a questionnaire to highlight the best parts of my project to an audience. Questions such as "Is this NPC responding in a realistic manner?" would have provided valuable insights and suggestions for improvement. Unfortunately, due to time constraints, this questionnaire was not developed. Nevertheless, I believe I obtained sufficient feedback through in-person showcases during lessons. However, a larger sample size could have been beneficial.
​
Through these methods, I can effectively demonstrate what I have created, enabling easy comparison to my initial project proposal. This will allow my audience to assess the believability of my NPC.
What I would do Differently Next Time
If I were to undertake this project again, or if I could revisit my original project, there are several aspects I would approach differently. Reflecting on my initial plan and time allocation, I believe I would have dedicated more time to research.
​
While I don't believe my project is deficient in research for achieving a high grade, I personally feel that additional research could have been more beneficial. During the development phase of my NPC, I had to research how to implement many mechanics on the spot, as this was not thoroughly addressed during the allocated research weeks. Initially, my plan was to focus extensively on understanding the core methods of programming AI. However, much of my time was consumed by this, leaving less time for investigating specific mechanics. Perhaps if I had condensed the period spent on core AI programming methods or allocated an additional week for research by reducing practical work time, I could have achieved more.
​
I also think that sourcing additional scripts, such as a combat script to enable more elaborate combat behaviours like shooting, could have further enhanced the hostile and aggressive nature of the NPC. To reinforce this illusion of aggression, sourced assets such as character models, animations, and voice lines would have improved the NPC's realism. Although these elements are not directly related to programming, they would have supported the overall project as indicated in my research.
​
A minor adjustment I would make is saving my presentation for the final week instead of the penultimate one. Writing the final evaluation has taken longer than anticipated, and if I had done this a week earlier, I could have received tutor feedback that would have aided its creation.
​
Throughout much of this project, time management was a significant challenge, resulting in several planned features not being completed. While I believe I accomplished enough to ensure the project’s success, the absence of certain features leaves me somewhat dissatisfied. The missing features I initially planned to include were: a cover system, NPC interaction, different NPC behaviours, combat positioning, combat mechanics, investigation capabilities, a decorated scene, edited videos to showcase my work, and a questionnaire to gather feedback. These features were not completed due to time constraints, and I am unsure how I could have created more time. Perhaps I simply overestimated what could be achieved within the allotted time.
​
In conclusion, this project has been a significant learning experience, revealing areas for improvement in both planning and execution. With better time management and a more balanced approach to research and development, I believe future projects can be even more successful. But this does not take away from the overwhelming success that this project was, I have made immense progress in my learning and knowledge that will only further my capabilities within the games industry.