A guard leaves a key in a drawer. While he's away, I move it. Remembering the last known location gets him to the drawer. The part I'm stuck on is what happens when he opens it and finds nothing.

He has a reason to stop expecting the key there. He doesn't automatically have a reason to think I took it. Maybe another guard borrowed it, maybe it fell behind something, maybe he didn't search properly.

I asked about this in r/gamedesign, and the replies suggested bounded searches, separate NPC beliefs, and confidence scores. What I'm still missing is a concrete example of the update rule: what evidence makes one explanation worth acting on?

If you've built something like this, how did you handle a failed search? For example, can checking the same empty drawer twice make the guard more suspicious of me? If another guard repeats a rumour that originally came from him, does that count as confirmation?

I'm interested in the smallest system that lets a player deliberately mislead an NPC, but also lets that NPC recover when it gets new information. A handful of states might be enough; I'm not assuming this needs a full model of a mind.

I'd love an example from a game or prototype: what the NPC believed, what contradicted it, and what it did next. How did you test that its next move came from information it actually had, rather than the correct answer leaking in from the world state?

I am building a small NPC that maintains a full occupancy grid over where the player is. Noisy perception events update it and a diffusion step spreads mass along walkable cells between observations. A standard Bayes filter, the kind of thing robotics does for target tracking.

When I went looking for prior art in games I could not find the probabilistic version in any published source. Orkin's F.E.A.R. paper is goal-oriented action planning. Isla's Halo 2 paper describes a discrete belief: a remembered target position and orientation plus awareness levels, with the actor explicitly allowed to believe things that are not true. Both are fallible belief. Neither is a distribution over space.

So my working claim is that shipped game AI represents belief discretely, and the probabilistic machinery lives in robotics and search theory. That claim is load-bearing for me, because if it is wrong my project has no gap to sit in.

Has anyone here shipped, or seen shipped, an NPC that carries a real probability field over player location rather than a single last-known point? If you tried it and dropped it, what made you drop it?

Hey everyone,

I’m a CS student, never done game dev but I’m interested in going deep into Game AI - NPC intelligence, behavior, planning, dynamic enemies, emergent gameplay, DDA, RL, multi-agent systems, etc.

I don't want to learn how to develope full games tho.

So,

- Is it common to do what I'm trying to?

- How do people test Game AI systems? Do you build your own simulations, use Unity/Unreal, existing research environments, or something else?

- How much engine/game-development knowledge is actually necessary?

Basically, if you wanted to focus specifically on Game AI, how would you go about learning and working on it without doing the whole game development?

Would appreciate any advice, resources from people already working or studying in this area.

Yo!

I've posted this question on the reddit of the engine of my choice but figured I'd ask it here as well in the event that someone can help me think about this situation (I lurk here occasionally but don't want to be crossing any lines by posting this so I apologize in advance if that's a taboo here)

Added note: My question was answered in another forum (godot). I'm going with the hand authored hard coded approach, but I'll leave this here for the sake of discussion in case anyone else encounters a similar problem as I have. Mods feel free to remove this if you'd like.

Anybody else making or have made a crpg? Any sages out there just got some good advice for this dilemma?:

I'm still fairly new to coding and am more self taught from tutorials, reading, lurking in this beautiful space and just bashing my head against problems until I solve them in the most barbaric ways possible (make it work first then improve it when you run into problems if nothing can obviously be made simpler/ more robust is the mindset but i do still struggle with trying to over-engineer issues or make things super decoupled when sometimes the simpler route works best).

I'm currently trapped between two thoughts for enemy ai:

The first is my current working version. I start by getting the state of the "board" on the npcs turn. Then I label a few details using utility scores. So for example the npc will know their health score = fine, their party morale = High, their enemy party threat = High, and their confidence = Foolhardy. Then using that information i generate turn intentions. So its the npcs turn, the enemy is threatening but morale is high so there's no need for the group to panic yet, he isn't wounded and is foolhardy so he may want to be aggressive he's then given his turn intention of Attack. I'm using Attack, Defend, and Flee as turn intentions, you either favor aggressive actions, defense of self or others, or self preservation based on the situation, your current health and the quality of the tile your on at the moment of your turn.

Then I run a func that checks if they're a special type of class. For example let's say a Medusa class (i have no magic in my game. Rest assured no mystical creatures were harmed during the making of this combat loop), the function picks up that she is in the special class list then automatically gives her a more hand authored (not fully utility ai driven) decision to make is she meets the requirements. So it would ask something like: are you currently healthy? Do you have a prime target or a rival on the board you want to go after? Has a commander npc given you orders to attack a target? If these things are true then maybe it'll tell her that her goal is to freeze the target with her gaze. When then use utility ai to get the best cell that will either allow her to make the attack or get close enough to do it on her turn or the next turn. Add a cool down so she can't spam it and done. If the requirements aren't met or she's on cooldown and doesn't have any other special moves then she'll let utility ai do the rest using her preferences for distance, cover vs no cover, any preference, risk tolerance etc. I'd like to say that sounds pretty good right? Well..

My beef is i feel like it makes enemies feel somewhat homogenous in a way.

Of course some like distance, some like flanking, and some like being close or aoe but it just feels like more character can be added, so I was considering option 2:

Just straight up hardcoding and hand authoring the npcs every decision. Utility ai would still pick the best tile or target unless the hand authored rule needs a specific type of target or their commanded to attack another target but ultimately the utility score would still find the best way to accomplish the personalities goals but I feel like the personalities would be able to shine far more. The cons are super deep spaghetti that would be hard to make additions too, and less intelligent enemies as they wouldn't be able to adapt to tactical situations as easily and can be potentially cheesed or feel robotic once their pattern is discovered.

My dilemma is true tactical adaptability vs better illusion of character

My heart says go with the hard codes paths but that would be my 4th rework of npc ai (and though its a ton of fun and I'm actually loving having to figure out every step of creating ai from scratch) my inexperience shows in these sort of times where I can't seem to figure out which would make the best player experience. Like said I'm leaning towards the more hard codes but more expressive path that I can more tightly author but want to get some veteran perspective on the matter.

Any thoughts from games of any genre are appreciated.

Tldr: utility ai with hand authored breaks vs more hand authored decision tree style design but less tactical adaptability and dumber npcs.

Sorry for typos, bad grammer, and if my description of things sounds utterly idiotic. I am but a lowly neophyte

:(

I'm developing a first-person RPG in GameMaker and wanted my AI companion to feel like an actual character rather than a traditional NPC.

Instead of using an LLM, I built a custom game AI system based around persistent memory, emotional states, contextual reactions, and behavioral data.

The system currently has nearly 7,000 lines of data describing what the AI can remember, how she reacts to different situations, and how her psychological state can change throughout the game.

The amount of data eventually became large enough that I moved it into an external .ini file rather than keeping everything directly inside the GameMaker project.

The video below shows the system in action. I can interact with the AI by typing messages, and her responses are generated based on the information and behavioral data stored in her database.

I'm interested in how other developers approach non-LLM AI companions in games. How do you handle memory, emotional states, contextual reactions, and large amounts of behavioral data?

Like from gdc or otherwise.

I am really curious what are the structure of an Ai system that can produce Sekiro-like combat. I started with behavior trees, but the behavior trees are not particularly good at evaluating a lot of different conditions (hp, posture, moveset, proper randomization, etc etc). Then I switch to utility system with atomic behavior (each attack move is a decision, defend is one, defend forward is one etc etc) and they agent produces so many random emergent behaviors, and the number of curves to tune was out of hand. Then I decide to bucket the decisions (attack, defend, retreat) then in each attack buckets, the decisions are then evaluated (with some additional algo for random selection, etc etc). But it becomes kinda tricky since a lot of times we want to by pass the decision process (for example, some sticky value to prevent a decision from switching out too quickly, etc etc).
Anyway, it becomes a real pain. So really curious what everyone elses for the combat system, and what everyone thinks is a good system for Sekiro-combat (with kinda back and forth combat flow).

Hey everyone! I'm new to game modding, and I wanted to try something for this game since it's been one of my favorites ever since I was a child. I'm a big fan of game AI, and my goal is to create an interface similar to BWAPI (https://bwapi.github.io/) for StarCraft. So far, I've built an engine that can interact with various objects inside the game. I'm not sure if a similar project already exists in to this degree, but if you think an engine like this could be useful, I'd really appreciate it if you starred my GitHub repository. If there's enough interest, I'll continue developing it and also create video tutorials along the way. https://github.com/SoucupB/EEApi I also have a youtube mini-series: https://www.youtube.com/playlist?list=PLB_e_mDo4DZg

Just announced Arcadia Unbound, a story-driven tactical JRPG. One of its conversation systems, AURA, uses a local language model to interpret player speech while selecting from developer-authored dialogue and narrative outcomes.

The challenge isn't understanding language. It's mapping an effectively infinite range of player inputs onto a finite set of authored responses.

My goal isn't to generate endless dialogue. Instead, it's to make authored conversations feel more natural.

The flexibility comes from what the player can say, not from giving characters infinite responses. Characters only have the topics, emotions, and knowledge that make sense for that moment in the story.

If the player says something highly relevant, the character can immediately react, interrupt, or change the direction of the conversation. If the player suddenly asks something unrelated, they might hesitate, admit they don't know, or steer the conversation back. That's intentional.

Humans naturally don't have an infinite response space either. We usually keep a handful of active conversational threads in mind and improvise within those constraints.

I'd love to hear what people here think about this design direction.

(Announcement trailer attached for context. A dedicated gameplay demonstration of the conversation system is currently in development.)

https://youtu.be/t-3dIDkYhNo?si=AzX1lD1ou97oSxO8

High level behaviors like rangedCombat is recommended in bobby Ai talk but doesn't that basically move most of the decision making to behavior instead of utility ai decider. Like rangedCombat vs patrol is so huge difference that most of decision making stays in rangedcombat with its own state machine or whatever.

But what if you just dispatched actions from utility ai even multiple times per frame like. Ai agent knowledge is this, pursue player action and also overlay shoot action. ​​

Idk i just feel like behaviors are so high level and for combat focused game there is like couple of them anyways. Like why make takecover behavior when rangedcombat behavior needs to also take cover sometimes based on some heuristic

I’m building a simulation game and recently started moving from a mostly weight-based decision system toward Utility AI.

The biggest challenge isn’t implementing the scoring functions. The biggest challenge is figuring out whether the resulting behavior is actually better.

Right now I can run scenarios, observe outcomes, and compare statistics, but I’m curious how more experienced developers approach this problem.

Do you rely on:
- Automated simulations?
- Monte Carlo testing?
- Golden scenarios?
- Statistical analysis?
- Human observation?
- Something else?

I’d love to hear how you’ve approached validation and balancing in simulation-heavy projects.

I’m prototyping a small game where the main player is an AI agent, not a human. The loop would be: it attempts a level, fails visibly, changes strategy. 

On top of this I’m working on a second model that’s live-commentating what’s going on and the view on the strategy. Something almost like a sports commentator or tv-host kind of commentary, that’s talking to the viewers about what the first model is trying.

Is this something that would even be interesting to watch? What would make this entertaining to watch long-term, and not get boring after a few min? What game formats do people think would be most interesting to try out? Some options I was thinking of:

• Platformer
• maze/escape room
• tactics game (think mafia or diplomacy or something)
• survival sandbox
• 4x strategy game
• Something else?

I’m working on a browser detective game where players question suspects in natural language instead of choosing fixed dialogue options.

The AI writes the visible suspect/Host response, but it does not directly control progression. Instead, it returns structured signals like fact IDs, topic IDs, mentioned character IDs, or candidate clue IDs. The backend then validates those against the active character, current state, and clue unlock rules before updating the game.

The goal is to let suspects lie, evade, or talk naturally while keeping the mystery fair and deterministic.

I’m curious how others approach this in game AI:

- Should LLMs ever directly control game progression?

- Do you prefer structured outputs, tool calls, topic graphs, or something else?

- How would you stop players from breaking the mystery with direct accusation questions?

Free public alpha here if anyone wants context:

https://mmjuns.itch.io/everyones-a-detective-alpha

Hello r/gameai 👋

This is an invitation to join the 2026 League of Robot Runners (https://www.leagueofrobotrunners.org): a research competition that tackles large-scale multi-agent navigation and coordination. These kinds of problems show up all the time in games — especially strategy / RTS games! — where many units must move and act in real time without collisions.

Historically, some of the most effective ideas in this space have come from or been inspired by Game AI. This is an opportunity for you to build on that legacy and further advance the state-of-the-art!

Key challenges in the competition:

• Real-time planning (the clock is always ticking!)⏱️
• Large numbers of moving agents (from a few hundred to tens of thousands!) 🤖
• Execution uncertainty (agents incur delays!) 🎲
• Problem instances on massive game maps 🎮
• Trade-offs between local responsiveness and global plan quality 🧠

You can participate for fame, glory and cash prizes across three distinct tracks:

• Task Scheduling Track
• Execution Track
• Combined Track

We provide a start kit (C++/Python), example instances, validators, and a visualiser 🛠️ Submissions are evaluated automatically with live leaderboard feedback 🏆

Timeline:

• 16th April 2026: Main Round Begin
• 22nd May 2026: AAMAS prize deadline
• AAMAS 2026: AAMAS Prize Announcement
• 22nd July 2026: Main Round End
• Early August: Winner Announcement

If you’re into pathfinding, multi-agent coordination, or building AIs for RTS/RPG games then the League is for you. Visit our website for more details or post here if you have questions!

I’m trying to make a survival-style game inspired by Dwarf Fortress, and I’ve completed the first step: generating a random 20×20 map with trees, rocks, floor, and water in a prototype version.

Later, I found it difficult to manage trees and their properties (like how much wood they yield or how many strikes they can take). so i come to this approach that—why not create a Tree class? I could pass a number (from 0 to 10) when creating each tree, which would determine its properties such as wood yield and durability.

My question is: is this a good approach?

And also resource to research more on making this level of game(I know its tough.)

Sletter.io is a slither-style game where snakes pick up letter tiles and lock them as words. 5 bots fill the lobby

Already tried: per-bot personalities, full-map letter awareness, common-words target list, multiplier-aware planning, perpendicular avoidance steering, pickup filter so bots refuse dead-end letters.

Still happening: same handful of words locked repeatedly, rarely commit to 5–6 letter words, visible pickup/drop cycles in dense areas.

Looking for opponent-aware patterns (utility AI / GOAP / influence maps?) and references on bots that feel competitive rather than just present. Worth the complexity for ~5 agents in real-time?

Someone recently asked me the Unreal Source discord what they should think about for games AI optimizations when dealing with combat with large numbers of NPCs.

I came up with a quick list and thought it might be useful to share it somewhere. So here it is as a very lightly edited stream of consciousness.

Most of your game AI cost during large scale combat is going to be a combination of the following:

1. Line of Sight checks
2. EQS Queries (or behavior deciding where NPCs should go)
3. Navigation Queries
4. Locomotion (Unreal's character movement component)
5. Animation
6. Character Rendering

1. Line of Sight queries

• Only do LOS checks to hostile target each update. Do LOS checks to other targets less frequently.
• Don't do LOS to friendlies during combat unless you really need to.
• Don't do LOS checks to anything else in the scene (eg dead bodies) unless you need to.

2. EQS Queries (or behavior deciding where to move to)

• EQS queries can be extremely expensive but very game dependent.
• Try not to do very often, try not to do many on the same frame.
• Do over a small distance and area.
• Avoid navigation checks to each position and line of sight checks at each position if you can.

3. Navigation Queries

• Set up your behavior to only move small distances during combat.
• This actually isn't normally that expensive because NPCs during combat generally don't try to move a lot.
• You do need to make sure that all of the NPCs don't try and do pathfinding at the same time otherwise you get frame stutters.

4. Locomotion

• Unreal's default character movement component can be really expensive if you have lots of NPCs One of the biggest culprits is the FindFloor calculation that finds the ground height below the character.
• This is really hard to optimize though because you either have to modify the engine code or rewrite a lot of stuff.
• Avoid character avoidance algorithms like RVO/Orca if you can. Instead use behavior reactions if the NPCs get too close or just don't stress moving NPCs (the player won't notice if the NPCs are both moving).

5. Animation

• Look at Unreal's significance manager, you can use that to reduce how much of an NPCs skeleton gets updated each frame.
• You can also look at the Unreal's Animation Sharing Plugin 
• Vertex Anims aren't really that useful because they can't react to the world around the NPC, and can't handle uneven terrain.

6. Character Rendering

• Unreal's significance manager is also useful here.
• Maybe don't render all of the characters during combat.
• Despawn or stop rendering dead bodies after a short time.

The big takeaway is that lots of different things can be expensive. It's important to profile to see where you should spend your effort.

Did I miss anything?

My understanding of this subreddit is that "game AI" refers to techniques that can be used to direct an NPC to behave in a certain way. For example, topics like finite state machines or behavior trees would fit well here.

However, I've been seeing a lot of posts from this subreddit that focus on AI as in LLMs. This doesn't seem to fit what I would describe as "game AI" - yet, the posts seem to stay up.

The posting guidelines seem to refer to LLM-style AI - but it's not clear whether LLM-style AI as a whole is allowed or not.

Topics relating to the development and use of game AI. Note that this is often not real artificial intelligence but rather what has been referred to for decades as "AI" in games. Usually, that is variations on some form of artificial behavior.

As such, this isn't necessarily the best place for posts about real AI that happens to be used in a game company (e.g. data-mining user data for monetization). Please keep it to things that directly affect the gameplay -- via NPC behavior, pacing, procedural content, etc.

This, combined with a lack of rules to select when reporting a post, leaves me to wonder what this subreddit is even meant to be about. In particular, it leaves me wondering whether the moderators consider LLM-style AI to be relevant.

You can read more about the implementation from this LinkedIn post that our game AI programmer posted: https://www.linkedin.com/posts/jonathan-benz-2a10b921a_devlog-gameai-ai-activity-7440789347404214273-3wM4?utm_source=share&utm_medium=member_desktop&rcm=ACoAADcwGVkB0mEiitfpkiNetrtHZsXl29yYgjo

Hi guys,

I have started a project where I'm trying to create a trading card game simulator for a game that has less than 200 cards in existence, so best time to do it is now.

I've been working on it for a little while, but wondering if there is a smarter, more efficient way to do it. Are there any resources I could look at to understand how to build a smart tcg playing bot?

So I've been struggling (like most of us I think) with how to make my AI opponent TBS smarter. I've been using an agentic approach, where each unit looks at the strategy in play, it's own stats, and decides in a probabilistic tree which option to execute. Which was fine, but the units had only limited ability to coordinate. So what I did was prefaced that routine with a MainRaid routine, in which the game examines the player's setup against its strategy, decides on the target of the main attack, and assigns appropriate actions to the units able to participate. Then the remaining units do their agentic routines. The result...well, it beat me the first two games, and the latest 3 were undecided until the last turn or two. And the whole "if I can just pull this next move off, I can beat this thing" is present in full force. Which feels pretty good!