Nowadays creating believable characters is a top trend in the video game industry. Recent projects present new design concepts and improvements in artificial intelligence that are oriented to this goal. The expected behaviour of computer-played characters becomes increasingly demanding: proactivity, autonomous decision-making, social interaction, natural communication, reasoning and knowledge management, etc. Our research project explores the possibility for one of these characters to investigate, solving an enigma while dealing with incomplete information and the lies of other characters. In this paper we propose how to manage trust issues when modelling suspicion in the artificial mind of a Columbo-like detective, considering that our desired gameplay is a murder mystery game in which the player plays the role of the culprit.
Computer simulations allow a high grade of realism; however, computer-controlled characters in virtual worlds still feel like mere automatons: the user gives an input and receives a response. Advances in intelligent behaviour are changing the user experience, improving these characters’ performance and expanding the scope of their potential uses. One aspect that refrain us from believing such characters are “alive” is that they seem completely “naive”: they will believe without doubts all the information received from other sources. Of course, in interactive storytelling this issue is mainly confronted with a script that the character will follow: if it has to suspect, it will suspect, if it has to lie, it will lie, etc. but there is no real intelligence behind those decisions. A system capable of managing suspicion would improve greatly the degree of realism of the characters, but such feature has not been sufficiently explored.
In this work we focus in the question of trust, intrinsic to human nature, and introduce a model for a computer-played character that suspect about others and try to detect when they are covering their actions or telling lies. In this model, the autonomous “investigator” works with incomplete information, managing uncertain knowledge and potentially false pieces of evidence. We also propose a videogame application designed to test our model. The application consists of an interactive version of the popular TV series from the NBC: Columbo, where the player controls the murderer instead of the main character of the story, Lieutenant Columbo, who is the homicide detective. The culprit is obvious to the player since the very beginning of the game, and the goal of this character is to deceive the detective for not getting caught (as in the original episodes, the format of the typical “whodunit” mystery is reversed to the “howcatchthem” paradigm or “inverted detective story”).
In order to frame our proposal, in Section 2 we review other models of deception and trust. Section 3 presents our model of suspicion for computer-controlled characters and Section 4 describes an example scenario of how our model would work using a murder mystery game as an application. Finally, in Section 5 we present and discuss our conclusions, foreseen the next steps of this project.
Modelling deception has been object of research from long ago. Jameson presented
IMP in 1983 [
Sometimes the character may work not only with incomplete information, but also
with information that is considered as “uncertain” (depending on the sincerity of the
characters that reveal it). In order to manage these features, intelligent characters have
to decide which information to trust. Research on trust and deception itself is a broad
concept with multiple aspects that have been explored in the literature, such as
selfdeception and how it affects decision-making [
Certainly, trust is a crucial aspect to deal when requesting services or information
from third parties [
Trusting a source of information does not only rely in judging over the data
received from that source, but we also have to take in account all the related sources.
Moreover, we also should take in account third parties’ information: for example, in
[
ScubAA [
In our model, allowing the character to build its own trust values, makes the information they hold to be incomplete and different for each character. This feature is beneficial from our point of view, because it allows introducing deceptive information in the system without being “caught”, testing the investigator’s ability to find the truth.
Finally, in order to generate trust in other parties or deceive them with our lies, we
have to relay in argumentation. In literature, different analysis about epistemology
and argumentation has been examined and described thoroughly, establishing
directions that allow modelling critical reasoning [
Our knowledge model is designed to allow computer-controlled characters to decide if they should believe (trust in) the information received from a third party. The decision-making or judgement about a concrete piece of information will be based on the previous data they have about it, and about the source from they received that information. This paper is focused on introducing the model, so we have deliberately postponed the analysis of the more technical aspects (i.e. the reasoning engine) for further research. In order to test our model, the characters will operate in a detective scenario, a great domain example where trust and deception are key features to have into account. In this scenario, the user plays the role of a murderer who has to mislead an important non-player character: the detective. The player’s goal will be to prevent the detective to discover the murderer’s identity (his/her own identity). The scenario contains also other suspicious characters, each one with its own information about the incident. The detective will obtain new information (from now on, Facts) about the scenario, talking with other characters and finding evidences, storing all this information in a knowledge base.
In order to decide what information should trust and how, the first challenge the detective confronts is determining the truth value of Facts. As we saw in the previous section, other models are based on lists of trust parameters, fuzzy truth values, or statistical probabilities. We decided to use a discrete system using a ternary value (“true”, “false” and “unknown”) for each Fact. The first time the detective gets informed about a Fact, he will create an entry in his knowledge base about it, and he will update its value depending of the additional information he finds about it. Not knowing certain information is not the same than knowing it is true or false (i.e. open world assumption), so we use the value “unknown” in order to mark those doubtful Facts and subsequently trying to discover their real value with abductive reasoning .
The next question is how to “quantify” the truth value of a Fact. We only have found simple methods in the literature for this decision-making process: usually it is enough to use a fixed probability number or comparing the number of agents supporting a fact with the number of agents denying it. However, if the system is that simple we may lose certain desirable characteristics as taking into account evidences that support the truth or falsehood about a fact, or remembering if a character previously lied to us before evaluating her statements, especially if those statements are related with the one about she lied.
Considering these requirements, our detective will have a list of truth values about
a Fact where they will store each evidence they obtain about it. Having a bigger
number of supporting evidence for a Fact (“true” values) will make him to believe the
statement, and on the other hand, having more contradictory evidence (“false” values)
will lead the agent to consider the statement as a lie. This is similar to the system used
in [
Once we have a model describing how the information will be stored and judged, we need a reasoning method in order to figure out the truth value of unknown Facts. Although it is not the main focus of this paper to present a reasoning implementation, it is necessary to describe such method in order to show how to deal with its characteristic features: explicitly unknown values and non-trustable sources. In our model, the automatic reasoner has the goal to clear “unknown” values by giving them “false” or “true” values by identifying if assigning those values generates a contradiction or a possible outcome. We propose using two joint techniques that resemble a detective work to achieve our goal.
The first one would be using an “established knowledge” database. Facts we will receive are checked using a common sense’s rules database: if some Fact contradicts a rule in that database we will know that the source is lying; for example, stating that a character was outside of a building while it was raining, but seeing that his clothes are dry. Also, we can do this Fact checking with our first person evidences: if we know a Fact for sure, any information that contradicts it would be false.
The second technique consists in trying to clear the “unknown” actively. If we want to know who the murderer is, but we have limited information including false evidence from the culprit, it’s very likely that once we obtain enough information from other characters we will have some “relative contradictions”, represented by having “true” and “false” values in the list of truth values obtained from different sources about the same fact. Upon finding a contradiction, the character will run two simulations, respectively binding the truth value for that fact to “true” and “false”, and propagating further consequences. If the resulting knowledge base of the simulation has a contradiction with another Fact we know for sure is true (values in our “established knowledge” database), we can discard that value.
We are currently analysing reasoning tools in order to apply the most suitable one
to work with our suspicion model. In order to model sophisticated scenarios, the
reasoner should have planning capabilities, and be able to work with hypothetic or
potential facts. For example, since our knowledge structure works with undetermined truth
values, a model based in Intuitionistic Logic would fit well. Using this technique, a
suitable framework would be the Hypothetical Logic of Proof [
Our scenario will be an inverted detective story based in the Columbo TV episodes, where the player has the role of the culprit in a murder case, and his goal is to deceive a computer-controlled detective (a sort of virtual Columbo) and lead him to arrest another suspect instead of the player.
The simulation will play as a series of rounds in which the detective will question the player and the other suspects. Obviously, the player knows the details of the murder and he will have the opportunity to hear what other characters say in order to gain additional information from them to be used for deceiving the detective. The player can, for example, create an alibi for himself (“I was with that person at the moment of the crime”), or blame a third party (“I saw that person entering in the victim room just before the crime”). If the player manages to plant enough false evidence, the detective will arrest the wrong character and the player will win the game. However, if the detective find contradictions in the player’s alibi or manages to extract the true testimony from the other suspects, he will soon discover the player as the real culprit, making him lose the game.
In order to illustrate these ideas, the next figures show how the knowledge of the detective evolves during a game session. The example is inspired in the first episode of the original Columbo series, “Murder by the Book” in which Jim Ferris, a famous writer, is killed by his colleague, Ken Franklin. As part of his alibi, Ken tries to incriminate the Mafia, dropping a false document in the crime scene and lying about the next book Jim was working on. The player plays the role of Ken, explaining his alibi to the detective, who will try to find something that contradicts Ken’s suggestions. The next paragraphs explain just a small part of the complete plot of the episode, enough to illustrate the basic ideas behind our model.
Firstly, the crime is introduced (Fig. 1) with a clear fact (represented by a white box), and some basic deductions (black arrows) performed by the automatic reasoner. This puts the detective in his way to find the murderer, that could be someone close to the victim, or not (red arrows with a white head represents disjoint Facts).
Fig. 1. The crime is introduced and basic deductions are performed Then, the interrogation starts (Fig. 2) and the detective asks Joanna, Jim’s wife, about the enemies of his husband. If Joanna tells the truth, which initially is “believable” (discontinuous line) because there are no contradictions, Jim has no enemies. That means the murderer could be Joanna herself or Ken, his closest friend. Considering the complete case, there are still many unknown Facts, so the interrogation continues (Fig. 3), this time asking Ken about his friend. As the real culprit, the player may try to deceive the detective lying about the existence of a secret project: Jim was writing a book about the Mafia. He could probably reinforce the idea with more Facts, explicitly lying about Jim and his “enemies”. This contradiction makes “Jim has enemies” an unknown Fact that the detective will investigate. Later on the game session, a false document is found in the crime scene (Fig. 4). As the person who put that document there, Ken has been waiting for this moment and its “dramatic effect”. A list of names of dangerous Mafia members is found in the desk of the victim. The reasoner of the computer-controlled detective finds plausible that the writer created that list, so it seems evident that Jim was really working on that book.
But at the end of the game session, looking for more clues to solve other parts of the mystery, more evidence appears: the detective notices that the document has been folded as if someone stored it in his pocket (Fig. 5). It does not make sense that Jim created that list and folded it before putting on his desk, so other person should have done it, possibly trying to incriminate the Mafia instead of the real murderer. So Ken’ story about the Mafia was a lie, and probably previous Facts coming from him should be considered “false”. Now the detective believes Ken is a liar and one of the main suspects: a good approach to the solution of the whole case.
In this paper we surveyed previous works on computational trust and deception and proposed a model for computer-controlled characters that suspects from others, not trusting any information received from third parties. Previous work on trust models relies on sources that generally do not lie, but in our case that assumption cannot be accepted. Our model is designed for situations with incomplete information and a constant need of judge what is likely to be true or false. Deciding who to trust is a key process in real life that can support and enrich a very wide range of games.
We used a ternary depiction for the truth value of facts and an automatic reasoner for inferring potential outcomes starting from the known facts. The model manages a list of potential truth values for each Fact, even coming from information given by a third party, selecting the value that appears the most from trustful sources. It also marks the other parties as trustful or not whenever it discards contradictory facts or accepts valid ones coming from them. If the model cannot decide the truth value of something (hence, it has the same number of supporting and refuting evidence), it will mark it as “unknown”. We described superficially how a reasoning engine could work using this model, trying to clear “unknown” values by reasoning over the potential outcomes that any of the truth values could generate. Such engine needs to be explored more in depth after a comparison of potential techniques, and will be the focus of our next steps. We also designed a game mechanism that is illustrated with an example scenario based in the first episode of the Columbo TV series for developing our model. In this gameplay, the player takes the role of the culprit in a murder case and a computer-controlled detective tries to discover who did it by looking for evidence and questioning suspects, including the player.
As the next steps of our research, we are currently working on a computational model that implements this example scenario as a simple text-based dialogue, allowing the user to play the culprit role with the computer acting as the detective. Also, we plan to test the scenario, containing the complete murder mystery, with real users taking the roles of the culprit and the detective in a “Wizard of Oz experiment” where we can analyse how they act and what kind of questions are asked in order to evade suspicion or discovering lies. With the results of this experiment, we will establish a behavioural baseline for comparing our model with the one someone in the role of a detective would have. Then we will re-enact the experiment, but this time using our application where the users only play the culprit role, and we will compare the behaviours of the human detective and the computational one.
Further research opens interesting paths: we want to analyse the nature of deception as well, so we want to expand our model allowing the rest of the non-player characters to decide when they should lie in order to cover their alibi, or hide private information. We think that creating a working model for trust and deception would be a useful contribution to interactive storytelling and video games, and to the Artificial Intelligence community as well, because it is a feature not fully explored yet.