) => {
38 | setAnchorEl(event.currentTarget);
39 | };
40 |
41 | const handleClose = () => {
42 | setAnchorEl(undefined);
43 | };
44 |
45 | const open = Boolean(anchorEl);
46 |
47 | const id = open ? 'help' : undefined;
48 |
49 | return <>
50 |
73 | {getContent(props.entry, classes.popup)}
74 |
75 |
76 | }
77 |
78 | function getContent(entry: Entry, className: string): JSX.Element {
79 | switch (entry) {
80 | case 'positions':
81 | return
82 | The Interviewer must try to determine whether the Suspect is a human or a robot.
83 |
84 | The Suspect should try to convince the Interviewer that they are human, regardless of their true nature.
85 |
86 |
87 | case 'roles':
88 | return
89 | A human Suspect has nothing to hide, and no restrictions on their behaviour.
90 | A patient robot has a restriction, something they cannot mention.
91 | A violent robot has an obsession, and must complete tasks to fulfil this obsession and allow them to kill the Interviewer.
92 |
93 |
94 | case 'penalty':
95 | return
96 | The penalty is a suspicious action that robots may perform under stress during the interview.
97 |
98 | Patient robots must perform the penalty once for each time they violate their restriction.
99 | Violent robots may perform the penalty twice as part of their de-programming.
100 | Human suspects should avoid performing the penalty, as this may make the Investigator think that they are a robot.
101 |
102 |
103 | case 'packet':
104 | return
105 | An interview packet is a collection of question prompts and robot roles that relate to them.
106 | It forms the topic of the interview.
107 |
108 |
109 | case 'inducer':
110 | return
111 | The Interviewer asks the Suspect a question based on a simple diagram, and then administers the inducer. This reveals the Suspect's role to them.
112 | Robots will see the same diagram as the Interviewer, but need time to read the details of their role.
113 | Humans will need to solve more complicated diagram to answer the question.
114 |
115 |
116 | case 'background':
117 | return
118 | Backgrounds provide the Suspect with a biographical detail to help them improvise a character.
119 | The Investigator and the Suspect should act as if the background really is true.
120 |
121 |
122 | case 'questions':
123 | return
124 | The questions in an interview packet relate directly to the patient and violent robot roles in that packet.
125 | The Investigator can deviate as much as they like, but these questions should help draw out patterns of robot behavior.
126 |
127 |
128 | case 'timer':
129 | return
130 | The Interviewer has 5 minutes to question the Suspect. Once the time has elapsed, they may ask one final question.
131 | The Interviewer can conclude that the Suspect is a robot at any time, but must wait until the time has elapsed before they can conclude that the Suspect is a human.
132 |
133 | }
134 | }
--------------------------------------------------------------------------------
/RobotInterrogation/ClientApp/src/components/interviewParts/elements/Interference.css:
--------------------------------------------------------------------------------
1 | .interference {
2 | display: flex;
3 | justify-content: center;
4 | white-space: pre;
5 | padding: 1em;
6 | font-family: 'Courier New', Courier, monospace;
7 | text-align: center;
8 | line-height: 1em;
9 | }
10 |
11 | .interference table {
12 | border-collapse: collapse;
13 | }
14 |
15 | .interference--solution {
16 | font-size: 1.25em;
17 | }
18 |
19 | .interference__cell {
20 | border: solid transparent 1px;
21 | width: 1.25em;
22 | height: 1.25em;
23 | text-align: center;
24 | vertical-align: middle;
25 | }
26 |
27 | .interference__cell--northBorder {
28 | border-top-color: black;
29 | }
30 |
31 | .interference__cell--southBorder {
32 | border-bottom-color: black;
33 | }
34 |
35 | .interference__cell--eastBorder {
36 | border-right-color: black;
37 | }
38 |
39 | .interference__cell--westBorder {
40 | border-left-color: black;
41 | }
--------------------------------------------------------------------------------
/RobotInterrogation/ClientApp/src/components/interviewParts/elements/InterferencePattern.tsx:
--------------------------------------------------------------------------------
1 | import * as React from 'react';
2 | import './Interference.css';
3 | import { Direction } from 'src/components/interviewReducer';
4 |
5 | interface IProps {
6 | connections: Direction[][];
7 | content: string[][];
8 | }
9 |
10 | export const InterferencePattern: React.FunctionComponent = props => {
11 | const transposeContent = props.content[0].map((_, c) => props.content.map(row => row[c]));
12 |
13 | const rows = transposeContent.map((row, y) => {
14 | const cells = row.map((val, x) => {
15 | const classes = determineCellClasses(props.connections[x][y], x === 0, y === 0);
16 | return {val}
17 | });
18 |
19 | return (
20 | {cells}
21 | )
22 | });
23 |
24 | return (
25 |
26 |
27 |
28 | {rows}
29 |
30 |
31 |
= props => {
9 |
10 | const splitAt = Math.ceil(props.solution.length / 2);
11 |
12 | const firstHalf = props.solution
13 | .slice(0, splitAt);
14 |
15 | const secondHalf = props.solution
16 | .slice(splitAt)
17 | .reverse();
18 |
19 | if (secondHalf.length < firstHalf.length) {
20 | secondHalf.splice(1, 0, '');
21 | }
22 |
23 | const firstRow: JSX.Element[] = [];
24 | const midRow: JSX.Element[] = [];
25 | const lastRow: JSX.Element[] = [];
26 |
27 | for (let i = 0; i < firstHalf.length; i++) {
28 | firstRow.push({firstHalf[i]} );
29 | lastRow.push({secondHalf[i]} );
30 |
31 | if (i < firstHalf.length - 1) {
32 | firstRow.push(→ );
33 | lastRow.push(← );
34 | }
35 |
36 | if (i < firstHalf.length - 2) {
37 | midRow.push(
44 |
45 |
46 | {firstRow}
47 |
48 | ↑
49 | ↓
52 |
53 | {lastRow}
54 |
55 |
56 |
((props, ref) => {
67 | const classes = useStyles();
68 |
69 | const rootClasses = props.question.isPrimary
70 | ? `${classes.root} ${classes.rootPrimary}`
71 | : `${classes.root} ${classes.rootSecondary}`;
72 |
73 | const examples = props.question.examples.map((q, i) => {q} );
74 | const secondary = props.question.isPrimary
75 | ? undefined
76 | : while fulfilling another prompt
77 |
78 | const sortUp = props.sortUp
79 | ? ↑
84 | : undefined;
85 |
86 | const sortDown = props.sortDown
87 | ? ↓
92 | : undefined;
93 |
94 | return (
95 |
96 |
97 | Suspect must
98 | {secondary}
99 |
100 | {props.question.challenge}, e.g.
101 |
102 |
105 | to be human
106 | {sortUp}
107 | {sortDown}
108 |
109 |
110 |
111 | );
112 | })
113 |
--------------------------------------------------------------------------------
/RobotInterrogation/ClientApp/src/components/interviewParts/elements/P.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { Typography } from '@material-ui/core';
3 |
4 | export const P: React.FunctionComponent = props => {
5 | return (
6 |
7 | {props.children}
8 |
9 | )
10 | }
--------------------------------------------------------------------------------
/RobotInterrogation/ClientApp/src/components/interviewParts/elements/PacketDisplay.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { ValueDisplay } from './ValueDisplay';
3 | import { Help } from './Help';
4 |
5 | interface Props {
6 | packet: string;
7 | }
8 |
9 | export const PacketDisplay: React.FC = props => (
10 | Interview packet :
11 | )
--------------------------------------------------------------------------------
/RobotInterrogation/ClientApp/src/components/interviewParts/elements/Page.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { Container, makeStyles } from '@material-ui/core';
3 |
4 | const useStyles = makeStyles(theme => ({
5 | main: {
6 | position: 'relative',
7 | },
8 | }));
9 |
10 | export const Page: React.FunctionComponent = props => {
11 | const classes = useStyles();
12 |
13 | return (
14 |
15 | {props.children}
16 |
17 | )
18 | }
--------------------------------------------------------------------------------
/RobotInterrogation/ClientApp/src/components/interviewParts/elements/PositionHeader.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { InterviewPosition } from '../../interviewReducer';
3 | import { Typography } from '@material-ui/core';
4 |
5 | interface Props {
6 | position: InterviewPosition
7 | }
8 |
9 | export const PositionHeader: React.FC = props => {
10 | return {getText(props.position)}
11 | }
12 |
13 | function getText(position: InterviewPosition) {
14 | switch (position) {
15 | case InterviewPosition.Interviewer:
16 | return 'You are the interviewer';
17 | case InterviewPosition.Suspect:
18 | return 'You are the suspect';
19 | default:
20 | return 'You are a spectator';
21 | }
22 | }
23 |
--------------------------------------------------------------------------------
/RobotInterrogation/ClientApp/src/components/interviewParts/elements/SortableQuestions.tsx:
--------------------------------------------------------------------------------
1 | import * as React from 'react';
2 | import FlipMove from 'react-flip-move';
3 | import { IInterviewQuestion, InterviewQuestion } from './InterviewQuestion';
4 |
5 | interface IProps {
6 | questions: IInterviewQuestion[];
7 | sort: (questions: IInterviewQuestion[]) => void;
8 | }
9 |
10 | export const SortableQuestions: React.FunctionComponent = props => {
11 | const questions = props.questions.map((q, i) => {
12 | const sortUp = i === 0
13 | ? undefined
14 | : () => {
15 | const sorted = props.questions.slice();
16 | sorted.splice(i, 1);
17 | const sortQuestion = props.questions[i];
18 | sorted.splice(i - 1, 0, sortQuestion);
19 | props.sort(sorted);
20 | };
21 |
22 | const sortDown = i === props.questions.length - 1
23 | ? undefined
24 | : () => {
25 | const sorted = props.questions.slice();
26 | sorted.splice(i, 1);
27 | const sortQuestion = props.questions[i];
28 | sorted.splice(i + 1, 0, sortQuestion);
29 | props.sort(sorted);
30 | };
31 |
32 | return (
33 |
44 | {questions}
45 |
46 | )
47 | }
48 |
--------------------------------------------------------------------------------
/RobotInterrogation/ClientApp/src/components/interviewParts/elements/SuspectRole.tsx:
--------------------------------------------------------------------------------
1 | import * as React from 'react';
2 | import ReactMarkdown from 'react-markdown';
3 | import { makeStyles, Card, Typography, CardContent } from '@material-ui/core';
4 |
5 | export interface ISuspectRole {
6 | type: string;
7 | fault: string;
8 | traits: string,
9 | }
10 |
11 | interface IProps {
12 | role: ISuspectRole;
13 | }
14 |
15 | const useStyles = makeStyles(theme => ({
16 | root: {
17 | margin: '1em 0',
18 | },
19 | rootHuman: {
20 |
21 | },
22 | rootPatient: {
23 | backgroundColor: '#eee',
24 | },
25 | rootViolent: {
26 | backgroundColor: '#666',
27 | color: '#eee',
28 | },
29 | title: {
30 | textAlign: 'center',
31 | },
32 | traits: {
33 | display: 'flex',
34 | flexDirection: 'column',
35 | justifyContent: 'space-evenly',
36 | marginTop: '1em',
37 | '& ul': {
38 | margin: 0,
39 | },
40 | '& p': {
41 | margin: 0,
42 | }
43 | }
44 | }))
45 |
46 | export const SuspectRole: React.FunctionComponent = props => {
47 | const classes = useStyles();
48 |
49 | let displayName = props.role.type.replace('Robot', ' Robot');
50 | if (props.role.type !== "Human") {
51 | displayName += ` (${props.role.fault})`;
52 | }
53 |
54 | return (
55 |
56 |
57 | {displayName}
58 |
60 |
61 | )
62 | }
63 | function getRootClasses(props: React.PropsWithChildren, classes: Record<"root" | "rootHuman" | "rootPatient" | "rootViolent" | "title" | "traits", string>) {
64 | let rootClasses: string;
65 | switch (props.role.type) {
66 | case 'Human':
67 | rootClasses = `${classes.root} ${classes.rootHuman}`;
68 | break;
69 | case 'PatientRobot':
70 | rootClasses = `${classes.root} ${classes.rootPatient}`;
71 | break;
72 | case 'ViolentRobot':
73 | rootClasses = `${classes.root} ${classes.rootViolent}`;
74 | break;
75 | default:
76 | rootClasses = classes.root;
77 | break;
78 | }
79 | return rootClasses;
80 | }
81 |
82 |
--------------------------------------------------------------------------------
/RobotInterrogation/ClientApp/src/components/interviewParts/elements/ValueDisplay.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { Typography, makeStyles } from '@material-ui/core';
3 |
4 | const useStyles = makeStyles(theme => ({
5 | root: {
6 | textAlign: 'center',
7 | fontSize: '1.25em',
8 | },
9 | }));
10 |
11 | interface IProps {
12 | value: string;
13 | }
14 |
15 | export const ValueDisplay: React.FunctionComponent = props => {
16 | const classes = useStyles();
17 |
18 | return (
19 |
20 | {props.children}
21 |
22 | {props.value}
23 |
24 |
25 | )
26 | }
--------------------------------------------------------------------------------
/RobotInterrogation/ClientApp/src/components/interviewReducer.ts:
--------------------------------------------------------------------------------
1 | import { ISuspectRole } from './interviewParts/elements/SuspectRole';
2 | import { IInterviewQuestion } from './interviewParts/elements/InterviewQuestion';
3 |
4 | export enum InterviewStatus {
5 | NotConnected,
6 | Disconnected,
7 | InvalidSession,
8 | WaitingForOpponent,
9 |
10 | SelectingPositions,
11 | RoleConfirmed,
12 |
13 | PenaltySelection,
14 | PenaltyCalibration,
15 |
16 | PacketSelection,
17 |
18 | InducerPrompt,
19 | ShowingInducer,
20 |
21 | BackgroundSelection,
22 |
23 | ReadyToStart,
24 | InProgress,
25 |
26 | Finished,
27 | }
28 |
29 | export enum InterviewOutcome {
30 | Disconnected = 0,
31 | CorrectlyGuessedHuman,
32 | WronglyGuessedHuman,
33 | CorrectlyGuessedRobot,
34 | WronglyGuessedRobot,
35 | KilledInterviewer,
36 | }
37 |
38 | export enum InterviewPosition {
39 | Interviewer,
40 | Suspect,
41 | Spectator,
42 | None,
43 | }
44 |
45 | export enum Direction {
46 | None = 0,
47 | North = 1 << 0,
48 | South = 1 << 1,
49 | East = 1 << 2,
50 | West = 1 << 3,
51 | }
52 |
53 | export interface IPacket {
54 | name: string;
55 | difficulty: string;
56 | icon: string;
57 | }
58 |
59 | export interface IInterviewState {
60 | position: InterviewPosition;
61 | turn: InterviewPosition;
62 | status: InterviewStatus;
63 | outcome?: InterviewOutcome;
64 | choice: string[];
65 | packet: string;
66 | packets?: IPacket[];
67 | prompt: string;
68 | penalty: string;
69 | patternConnections?: Direction[][];
70 | patternContent?: string[][];
71 | patternSolution?: string[];
72 | questions: IInterviewQuestion[];
73 | suspectBackground: string;
74 | role?: ISuspectRole;
75 | duration: number;
76 | }
77 |
78 | export const initialState: IInterviewState = {
79 | choice: [],
80 | duration: 0,
81 | position: InterviewPosition.None,
82 | turn: InterviewPosition.Interviewer,
83 | packet: '',
84 | penalty: '',
85 | prompt: '',
86 | questions: [],
87 | status: InterviewStatus.NotConnected,
88 | suspectBackground: '',
89 | };
90 |
91 | export type InterviewAction = {
92 | type: 'set position';
93 | position: number;
94 | } | {
95 | type: 'swap position';
96 | } | {
97 | type: 'set waiting for opponent';
98 | } | {
99 | type: 'set selecting positions';
100 | } | {
101 | type: 'set penalty choice';
102 | options: string[]
103 | turn?: number
104 | } | {
105 | type: 'set penalty';
106 | penalty: string;
107 | } | {
108 | type: 'set packet choice';
109 | options: IPacket[];
110 | } | {
111 | type: 'set packet';
112 | packet: string;
113 | prompt: string;
114 | } | {
115 | type: 'prompt inducer';
116 | solution: string[];
117 | } | {
118 | type: 'spectator wait inducer';
119 | role: ISuspectRole;
120 | solution: string[];
121 | patternConnections?: number[][];
122 | patternContent?: string[][];
123 | } | {
124 | type: 'set role and pattern';
125 | role: ISuspectRole;
126 | patternConnections: Direction[][];
127 | patternContent: string[][];
128 | } | {
129 | type: 'set role and solution';
130 | role: ISuspectRole;
131 | solution: string[];
132 | } | {
133 | type: 'show inducer';
134 | } | {
135 | type: 'set questions';
136 | questions: IInterviewQuestion[];
137 | } | {
138 | type: 'set background choice';
139 | options: string[];
140 | } | {
141 | type: 'set background';
142 | background: string;
143 | } | {
144 | type: 'start timer';
145 | duration: number;
146 | } | {
147 | type: 'end game';
148 | outcome: InterviewOutcome;
149 | role: ISuspectRole;
150 | } | {
151 | type: 'disconnect';
152 | } | {
153 | type: 'invalid session';
154 | }
155 |
156 | export function interviewReducer(state: IInterviewState, action: InterviewAction): IInterviewState {
157 |
158 | switch (action.type) {
159 | case 'set position':
160 | return {
161 | ...state,
162 | position: action.position,
163 | };
164 |
165 | case 'swap position':
166 | return {
167 | ...state,
168 | position: [InterviewPosition.Suspect, InterviewPosition.Interviewer, InterviewPosition.Spectator][state.position],
169 | };
170 |
171 | case 'set waiting for opponent':
172 | return {
173 | ...state,
174 | status: InterviewStatus.WaitingForOpponent,
175 | };
176 |
177 | case 'set selecting positions':
178 | return {
179 | ...state,
180 | status: InterviewStatus.SelectingPositions,
181 |
182 | // clear any data from previous game
183 | choice: [],
184 | duration: 0,
185 | outcome: undefined,
186 | packet: '',
187 | packets: [],
188 | penalty: '',
189 | prompt: '',
190 | patternConnections: undefined,
191 | patternContent: undefined,
192 | patternSolution: undefined,
193 | questions: [],
194 | role: undefined,
195 | suspectBackground: '',
196 | };
197 |
198 | case 'set penalty choice':
199 | return {
200 | ...state,
201 | status: InterviewStatus.PenaltySelection,
202 | choice: action.options,
203 | turn: action.turn === undefined ? InterviewPosition.Interviewer : action.turn,
204 | };
205 |
206 | case 'set penalty':
207 | return {
208 | ...state,
209 | status: InterviewStatus.PenaltyCalibration,
210 | penalty: action.penalty,
211 | choice: [],
212 | };
213 |
214 | case 'set packet choice':
215 | return {
216 | ...state,
217 | status: InterviewStatus.PacketSelection,
218 | packets: action.options,
219 | };
220 |
221 | case 'set packet':
222 | return {
223 | ...state,
224 | packet: action.packet,
225 | prompt: action.prompt,
226 | choice: [],
227 | packets: [],
228 | };
229 |
230 | case 'prompt inducer':
231 | return {
232 | ...state,
233 | status: InterviewStatus.InducerPrompt,
234 | patternSolution: action.solution.length > 0 ? action.solution : undefined,
235 | };
236 |
237 | case 'spectator wait inducer':
238 | return {
239 | ...state,
240 | status: InterviewStatus.InducerPrompt,
241 | role: action.role,
242 | patternSolution: action.solution.length > 0 ? action.solution : undefined,
243 | patternConnections: action.patternConnections,
244 | patternContent: action.patternContent,
245 | };
246 |
247 | case 'set role and pattern':
248 | return {
249 | ...state,
250 | role: action.role,
251 | patternConnections: action.patternConnections,
252 | patternContent: action.patternContent,
253 | };
254 |
255 | case 'set role and solution':
256 | return {
257 | ...state,
258 | role: action.role,
259 | patternSolution: action.solution,
260 | };
261 |
262 | case 'set questions':
263 | return {
264 | ...state,
265 | questions: action.questions,
266 | };
267 |
268 | case 'show inducer':
269 | return {
270 | ...state,
271 | status: InterviewStatus.ShowingInducer,
272 | };
273 |
274 | case 'set background choice':
275 | return {
276 | ...state,
277 | status: InterviewStatus.BackgroundSelection,
278 | choice: action.options,
279 | };
280 |
281 | case 'set background':
282 | return {
283 | ...state,
284 | status: InterviewStatus.ReadyToStart,
285 | suspectBackground: action.background,
286 | };
287 |
288 | case 'start timer':
289 | return {
290 | ...state,
291 | status: InterviewStatus.InProgress,
292 | duration: action.duration,
293 | };
294 |
295 | case 'end game':
296 | return {
297 | ...state,
298 | status: InterviewStatus.Finished,
299 | outcome: action.outcome,
300 | role: action.role,
301 | };
302 |
303 | case 'disconnect':
304 | return {
305 | ...state,
306 | status: InterviewStatus.Disconnected,
307 | };
308 |
309 | case 'invalid session':
310 | return {
311 | ...state,
312 | status: InterviewStatus.InvalidSession,
313 | };
314 | }
315 | }
--------------------------------------------------------------------------------
/RobotInterrogation/ClientApp/src/index.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import ReactDOM from 'react-dom';
3 | import { BrowserRouter, Route, Switch } from 'react-router-dom';
4 | import { About } from './components/About';
5 | import { Home } from './components/Home';
6 | import { Host } from './components/Host';
7 | import { Interview } from './components/Interview';
8 |
9 | const baseUrl = document.getElementsByTagName('base')[0].getAttribute('href')!;
10 | ReactDOM.render(
11 | (
12 |
13 |
18 | ),
19 | document.getElementById('root')
20 | );
21 |
--------------------------------------------------------------------------------
/RobotInterrogation/ClientApp/src/react-app-env.d.ts:
--------------------------------------------------------------------------------
1 | /// ListPackets([FromServices] IOptions configuration)
22 | {
23 | return configuration.Value.Packets;
24 | }
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/RobotInterrogation/Hubs/InterviewHub.cs:
--------------------------------------------------------------------------------
1 | using Microsoft.AspNetCore.SignalR;
2 | using Microsoft.Extensions.Options;
3 | using RobotInterrogation.Models;
4 | using RobotInterrogation.Services;
5 | using System;
6 | using System.Collections.Concurrent;
7 | using System.Collections.Generic;
8 | using System.Threading.Tasks;
9 |
10 | namespace RobotInterrogation.Hubs
11 | {
12 | public interface IInterviewMessages
13 | {
14 | Task SetPosition(int position);
15 |
16 | Task SetWaitingForPlayer();
17 | Task SetPlayersPresent();
18 |
19 | Task SwapPositions();
20 |
21 | Task ShowPenaltyChoice(List options);
22 | Task WaitForPenaltyChoice();
23 | Task SetPenalty(string penalty);
24 |
25 | Task ShowPacketChoice(PacketInfo[] options);
26 | Task WaitForPacketChoice();
27 | Task SetPacket(string packetName, string packetPrompt);
28 |
29 | Task ShowInducerPrompt(List solution);
30 | Task WaitForInducer();
31 |
32 | Task SetRoleWithPattern(SuspectRole role, int[][] connections, string[][] contents);
33 | Task SetRoleWithSolution(SuspectRole role, List solution);
34 |
35 | Task SetQuestions(IList questions);
36 |
37 | Task ShowInducer();
38 |
39 | Task ShowSuspectBackgroundChoice(List notes);
40 | Task WaitForSuspectBackgroundChoice();
41 | Task SetSuspectBackground(string note);
42 |
43 | Task StartTimer(int duration);
44 |
45 | Task EndGame(int endType, SuspectRole role);
46 |
47 | Task SpectatorWaitForPenaltyChoice(List options, int turn);
48 | Task SpectatorWaitForInducer(SuspectRole role, List solution);
49 | Task SpectatorWaitForInducer(SuspectRole role, List solution, int[][] connections, string[][] contents);
50 | Task SpectatorWaitForSuspectBackgroundChoice(List notes);
51 | }
52 |
53 | public class InterviewHub : Hub
54 | {
55 | public InterviewHub(InterviewService service, IOptions configuration)
56 | {
57 | Service = service;
58 | Configuration = configuration.Value;
59 | }
60 |
61 | private static ConcurrentDictionary UserSessions = new ConcurrentDictionary();
62 | private string SessionID => UserSessions[Context.ConnectionId];
63 |
64 | private InterviewService Service { get; }
65 | private GameConfiguration Configuration { get; }
66 |
67 | public override async Task OnDisconnectedAsync(Exception exception)
68 | {
69 | var player = Service.GetPlayerByConnectionID(Context.ConnectionId);
70 | if (player.Position == PlayerPosition.Spectator)
71 | {
72 | Service.RemovePlayer(player);
73 | }
74 | else
75 | {
76 | await Clients
77 | .GroupExcept(SessionID, Context.ConnectionId)
78 | .EndGame((int)InterviewOutcome.Disconnected, null);
79 |
80 | Service.RemoveInterview(SessionID);
81 | UserSessions.TryRemove(Context.ConnectionId, out _);
82 | await base.OnDisconnectedAsync(exception);
83 | }
84 | }
85 |
86 | private void EnsureIsInterviewer(Interview interview)
87 | {
88 | if (Context.ConnectionId != Service.GetInterviewerConnectionID(interview))
89 | throw new Exception("Only the interviewer can issue this command for session " + SessionID);
90 | }
91 |
92 | private void EnsureIsSuspect(Interview interview)
93 | {
94 | if (Context.ConnectionId != Service.GetSuspectConnectionID(interview))
95 | throw new Exception("Only the suspect can issue this command for session " + SessionID);
96 | }
97 |
98 | public async Task Join(string session)
99 | {
100 | if (!Service.TryGetInterview(session, out Interview interview))
101 | return false;
102 |
103 | //if (interview.Status != InterviewStatus.WaitingForConnections)
104 | // return false;
105 |
106 | if (!Service.TryAddUser(interview, Context.ConnectionId))
107 | return false;
108 |
109 | UserSessions[Context.ConnectionId] = session;
110 | await Groups.AddToGroupAsync(Context.ConnectionId, session);
111 |
112 | var player = Service.GetPlayerByConnectionID(Context.ConnectionId);
113 |
114 | await Clients.Caller.SetPosition((int)player.Position);
115 |
116 | if (player.Position == PlayerPosition.Interviewer)
117 | {
118 | await Clients
119 | .Group(session)
120 | .SetWaitingForPlayer();
121 | }
122 | else if (player.Position == PlayerPosition.Suspect)
123 | {
124 | interview.Status = InterviewStatus.SelectingPositions;
125 |
126 | await Clients
127 | .Group(session)
128 | .SetPlayersPresent();
129 | } else //Spectator
130 | {
131 | var client = Clients.Client(Context.ConnectionId);
132 | switch (interview.Status)
133 | {
134 | case InterviewStatus.WaitingForConnections:
135 | await client.SetWaitingForPlayer();
136 | break;
137 | case InterviewStatus.SelectingPositions:
138 | await client.SetPlayersPresent();
139 | break;
140 | case InterviewStatus.SelectingPenalty_Interviewer:
141 | await client.SpectatorWaitForPenaltyChoice(interview.Penalties, (int)PlayerPosition.Interviewer);
142 | break;
143 | case InterviewStatus.SelectingPenalty_Suspect:
144 | await client.SpectatorWaitForPenaltyChoice(interview.Penalties, (int)PlayerPosition.Suspect);
145 | break;
146 | case InterviewStatus.CalibratingPenalty:
147 | await client.SetPenalty(interview.Penalties[0]);
148 | break;
149 | case InterviewStatus.SelectingPacket:
150 | await client.WaitForPacketChoice();
151 | break;
152 | case InterviewStatus.PromptingInducer:
153 | case InterviewStatus.SolvingInducer:
154 | if (interview.Role.Type == SuspectRoleType.Human)
155 | await client
156 | .SpectatorWaitForInducer(
157 | interview.Role,
158 | interview.InterferencePattern.SolutionSequence,
159 | interview.InterferencePattern.Connections.ToJaggedArray(val => (int)val),
160 | interview.InterferencePattern.CellContents.ToJaggedArray(val => val ?? string.Empty)
161 | );
162 | else
163 | await client
164 | .SpectatorWaitForInducer(
165 | interview.Role,
166 | interview.InterferencePattern.SolutionSequence
167 | );
168 | break;
169 | case InterviewStatus.SelectingSuspectBackground:
170 | await client.SpectatorWaitForSuspectBackgroundChoice(interview.SuspectBackgrounds);
171 | break;
172 | case InterviewStatus.ReadyToStart:
173 | await client.SetSuspectBackground(interview.SuspectBackgrounds[0]);
174 | break;
175 | case InterviewStatus.InProgress:
176 | await client.StartTimer(Configuration.Duration);
177 | break;
178 | case InterviewStatus.Finished:
179 | await client.EndGame((int)interview.Outcome, interview.Role);
180 | break;
181 | }
182 |
183 | }
184 |
185 | return true;
186 | }
187 |
188 | public async Task ConfirmPositions()
189 | {
190 | var interview = Service.GetInterviewWithStatus(SessionID, InterviewStatus.SelectingPositions);
191 |
192 | EnsureIsInterviewer(interview);
193 |
194 | interview.Status = InterviewStatus.SelectingPenalty_Interviewer;
195 |
196 | Service.AllocatePenalties(interview);
197 |
198 | await Clients
199 | .Client(Service.GetInterviewerConnectionID(interview))
200 | .ShowPenaltyChoice(interview.Penalties);
201 |
202 | await Clients
203 | .Client(Service.GetSuspectConnectionID(interview))
204 | .WaitForPenaltyChoice();
205 |
206 | await Clients
207 | .GroupExcept(SessionID, Service.GetInterviewerConnectionID(interview), Service.GetSuspectConnectionID(interview))
208 | .SpectatorWaitForPenaltyChoice(interview.Penalties, (int)PlayerPosition.Interviewer);
209 | }
210 |
211 | public async Task SwapPositions()
212 | {
213 | var interview = Service.GetInterviewWithStatus(SessionID, InterviewStatus.SelectingPositions);
214 |
215 | EnsureIsInterviewer(interview);
216 |
217 | var tmp = interview.InterviewerIndex;
218 | interview.InterviewerIndex = interview.SuspectIndex;
219 | interview.SuspectIndex = tmp;
220 |
221 | await Clients
222 | .Group(SessionID)
223 | .SwapPositions();
224 | }
225 |
226 | public async Task Select(int index)
227 | {
228 | var interview = Service.GetInterview(SessionID);
229 |
230 | switch (interview.Status)
231 | {
232 | case InterviewStatus.SelectingPenalty_Interviewer:
233 | await DiscardSinglePenalty(index, interview);
234 | break;
235 |
236 | case InterviewStatus.SelectingPenalty_Suspect:
237 | await AllocatePenalty(index, interview);
238 | break;
239 |
240 | case InterviewStatus.CalibratingPenalty:
241 | EnsureIsInterviewer(interview);
242 |
243 | interview.Status = InterviewStatus.SelectingPacket;
244 |
245 | await ShowPacketChoice(interview);
246 | break;
247 |
248 | case InterviewStatus.SelectingPacket:
249 | EnsureIsInterviewer(interview);
250 | await SetPacket(interview, index);
251 | Service.AllocateRole(interview);
252 | await ShowInducerPrompt(interview);
253 | interview.Status = InterviewStatus.PromptingInducer;
254 | break;
255 |
256 | case InterviewStatus.PromptingInducer:
257 | await SetSuspectRole(interview);
258 | await ShowQuestions(interview);
259 | interview.Status = InterviewStatus.SolvingInducer;
260 | break;
261 |
262 | case InterviewStatus.SolvingInducer:
263 | EnsureIsInterviewer(interview);
264 |
265 | await ShowSuspectBackgrounds(interview, index == 0);
266 | interview.Status = InterviewStatus.SelectingSuspectBackground;
267 | break;
268 |
269 | case InterviewStatus.SelectingSuspectBackground:
270 | EnsureIsSuspect(interview);
271 | await SetSuspectBackground(interview, index);
272 | interview.Status = InterviewStatus.ReadyToStart;
273 | break;
274 |
275 | default:
276 | throw new Exception("Invalid command for current status of session " + SessionID);
277 | }
278 | }
279 |
280 | private async Task SetPacket(Interview interview, int index)
281 | {
282 | Service.SetPacketAndInducer(interview, index);
283 |
284 | await Clients.Group(SessionID)
285 | .SetPacket(interview.Packet.Name, interview.Packet.Prompt);
286 | }
287 |
288 | private async Task SetSuspectRole(Interview interview)
289 | {
290 | var suspectClient = Clients
291 | .Client(Service.GetSuspectConnectionID(interview));
292 |
293 | var pattern = interview.InterferencePattern;
294 |
295 | if (interview.Role.Type == SuspectRoleType.Human)
296 | {
297 | await suspectClient
298 | .SetRoleWithPattern(
299 | interview.Role,
300 | pattern.Connections.ToJaggedArray(val => (int)val),
301 | pattern.CellContents.ToJaggedArray(val => val ?? string.Empty)
302 | );
303 |
304 | await suspectClient.ShowInducer();
305 | }
306 | else
307 | {
308 | await suspectClient
309 | .SetRoleWithSolution(interview.Role, pattern.SolutionSequence);
310 |
311 | await suspectClient.ShowInducer();
312 | }
313 | }
314 |
315 | private async Task ShowQuestions(Interview interview)
316 | {
317 | var interviewer = Clients
318 | .Client(Service.GetInterviewerConnectionID(interview));
319 |
320 | await interviewer
321 | .SetQuestions(interview.Packet.Questions);
322 |
323 | await interviewer.ShowInducer();
324 | }
325 |
326 | private async Task DiscardSinglePenalty(int index, Interview interview)
327 | {
328 | interview.Status = InterviewStatus.SelectingPenalty_Suspect;
329 |
330 | if (index < 0 || index >= interview.Penalties.Count)
331 | throw new IndexOutOfRangeException($"Interviewer penalty selection must be between 0 and {interview.Penalties.Count}, but is {index}");
332 |
333 | interview.Penalties.RemoveAt(index);
334 |
335 | await Clients
336 | .Client(Service.GetInterviewerConnectionID(interview))
337 | .WaitForPenaltyChoice();
338 |
339 | await Clients
340 | .Client(Service.GetSuspectConnectionID(interview))
341 | .ShowPenaltyChoice(interview.Penalties);
342 |
343 | await Clients
344 | .GroupExcept(SessionID, Service.GetInterviewerConnectionID(interview), Service.GetSuspectConnectionID(interview))
345 | .SpectatorWaitForPenaltyChoice(interview.Penalties, (int)PlayerPosition.Suspect);
346 | }
347 |
348 | private async Task AllocatePenalty(int index, Interview interview)
349 | {
350 | interview.Status = InterviewStatus.CalibratingPenalty;
351 |
352 | // the specified index is the one to keep
353 | int removeIndex = index == 0 ? 1 : 0;
354 | interview.Penalties.RemoveAt(removeIndex);
355 |
356 | await Clients
357 | .Group(SessionID)
358 | .SetPenalty(interview.Penalties[0]);
359 | }
360 |
361 | private async Task ShowPacketChoice(Interview interview)
362 | {
363 | var packets = Service.GetAllPackets();
364 |
365 | await Clients
366 | .Client(Service.GetInterviewerConnectionID(interview))
367 | .ShowPacketChoice(packets);
368 |
369 | await Clients
370 | .GroupExcept(SessionID, Service.GetInterviewerConnectionID(interview))
371 | .WaitForPacketChoice();
372 | }
373 |
374 | private async Task ShowInducerPrompt(Interview interview)
375 | {
376 | await Clients
377 | .Client(Service.GetInterviewerConnectionID(interview))
378 | .ShowInducerPrompt(interview.InterferencePattern.SolutionSequence);
379 |
380 | await Clients
381 | .Client(Service.GetSuspectConnectionID(interview))
382 | .WaitForInducer();
383 |
384 | if (interview.Role.Type == SuspectRoleType.Human)
385 | await Clients
386 | .GroupExcept(SessionID, Service.GetInterviewerConnectionID(interview), Service.GetSuspectConnectionID(interview))
387 | .SpectatorWaitForInducer(
388 | interview.Role,
389 | interview.InterferencePattern.SolutionSequence,
390 | interview.InterferencePattern.Connections.ToJaggedArray(val => (int)val),
391 | interview.InterferencePattern.CellContents.ToJaggedArray(val => val ?? string.Empty)
392 | );
393 | else
394 | await Clients
395 | .GroupExcept(SessionID, Service.GetInterviewerConnectionID(interview), Service.GetSuspectConnectionID(interview))
396 | .SpectatorWaitForInducer(
397 | interview.Role,
398 | interview.InterferencePattern.SolutionSequence
399 | );
400 | }
401 |
402 | private async Task ShowSuspectBackgrounds(Interview interview, bool suspectCanChoose)
403 | {
404 | Service.AllocateSuspectBackgrounds(interview, suspectCanChoose ? 3 : 1);
405 | interview.Status = InterviewStatus.SelectingSuspectBackground;
406 |
407 | await Clients
408 | .Client(Service.GetInterviewerConnectionID(interview))
409 | .WaitForSuspectBackgroundChoice();
410 |
411 | await Clients
412 | .Client(Service.GetSuspectConnectionID(interview))
413 | .ShowSuspectBackgroundChoice(interview.SuspectBackgrounds);
414 |
415 | await Clients
416 | .GroupExcept(SessionID, Service.GetInterviewerConnectionID(interview), Service.GetSuspectConnectionID(interview))
417 | .SpectatorWaitForSuspectBackgroundChoice(interview.SuspectBackgrounds);
418 | }
419 |
420 | private async Task SetSuspectBackground(Interview interview, int index)
421 | {
422 | var background = interview.SuspectBackgrounds[index];
423 | interview.SuspectBackgrounds.Clear();
424 | interview.SuspectBackgrounds.Add(background);
425 |
426 | await Clients
427 | .Group(SessionID)
428 | .SetSuspectBackground(interview.SuspectBackgrounds[0]);
429 | }
430 |
431 | public async Task StartInterview()
432 | {
433 | var interview = Service.GetInterviewWithStatus(SessionID, InterviewStatus.ReadyToStart);
434 | EnsureIsInterviewer(interview);
435 |
436 | await Clients
437 | .Group(SessionID)
438 | .StartTimer(Configuration.Duration);
439 |
440 | interview.Status = InterviewStatus.InProgress;
441 | interview.Started = DateTime.Now;
442 | }
443 |
444 | public async Task ConcludeInterview(bool isRobot)
445 | {
446 | var interview = Service.GetInterviewWithStatus(SessionID, InterviewStatus.InProgress);
447 | EnsureIsInterviewer(interview);
448 |
449 | // Cannot record the suspect as human before the time has elapsed.
450 | if (!isRobot && !Service.HasTimeElapsed(interview))
451 | return;
452 |
453 | var outcome = Service.GuessSuspectRole(interview, isRobot);
454 |
455 | await Clients
456 | .Group(SessionID)
457 | .EndGame((int)outcome, interview.Role);
458 | }
459 |
460 | public async Task KillInterviewer()
461 | {
462 | var interview = Service.GetInterviewWithStatus(SessionID, InterviewStatus.InProgress);
463 | EnsureIsSuspect(interview);
464 |
465 | Service.KillInterviewer(interview);
466 |
467 | await Clients
468 | .Group(SessionID)
469 | .EndGame((int)InterviewOutcome.KilledInterviewer, interview.Role);
470 | }
471 |
472 | public async Task NewInterview()
473 | {
474 | Service.ResetInterview(SessionID);
475 |
476 | await Clients
477 | .Group(SessionID)
478 | .SetPlayersPresent();
479 | }
480 | }
481 | }
482 |
--------------------------------------------------------------------------------
/RobotInterrogation/Models/GameConfiguration.cs:
--------------------------------------------------------------------------------
1 | namespace RobotInterrogation.Models
2 | {
3 | public class GameConfiguration
4 | {
5 | public int MaxPlayers { get; set; }
6 | public int Duration { get; set; }
7 | public string[] Penalties { get; set; }
8 | public string[] SuspectBackgrounds { get; set; }
9 | public Packet[] Packets { get; set; }
10 | public SuspectRole HumanRole { get; set; }
11 | }
12 | }
--------------------------------------------------------------------------------
/RobotInterrogation/Models/IDWordList.cs:
--------------------------------------------------------------------------------
1 | namespace RobotInterrogation.Models
2 | {
3 | public class IDGeneration
4 | {
5 | public int WordCount { get; set; }
6 | public string[] Words { get; set; }
7 | }
8 | }
--------------------------------------------------------------------------------
/RobotInterrogation/Models/InterferencePattern.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Drawing;
4 | using System.Linq;
5 | using System.Text;
6 |
7 | namespace RobotInterrogation.Models
8 | {
9 | public class InterferencePattern
10 | {
11 | public InterferencePattern(int width, int height)
12 | {
13 | Width = width;
14 | Height = height;
15 | Connections = new Direction[width, height];
16 | }
17 |
18 | public int Width { get; }
19 |
20 | public int Height { get; }
21 |
22 | public Direction[,] Connections { get; }
23 |
24 | [Flags]
25 | public enum Direction
26 | {
27 | None = 0,
28 | North = 1 << 0,
29 | South = 1 << 1,
30 | East = 1 << 2,
31 | West = 1 << 3,
32 | }
33 |
34 | public List Markers { get; } = new List();
35 |
36 | public List MarkerSequence { get; } = new List();
37 |
38 | public List SolutionSequence => MarkerSequence
39 | .Select(index => ((char)('A' + index)).ToString())
40 | .ToList();
41 |
42 | public List> Arrows = new List>();
43 |
44 | public string[,] CellContents
45 | {
46 | get
47 | {
48 | var results = new string[Width, Height];
49 |
50 | foreach (var arrow in Arrows)
51 | results[arrow.Item1.X, arrow.Item1.Y] = GetArrowForDirection(arrow.Item2).ToString();
52 |
53 | for (int index = 0; index < Markers.Count; index++)
54 | {
55 | var marker = Markers[index];
56 | results[marker.X, marker.Y] = GetSymbolForMarker(index).ToString();
57 | }
58 |
59 | return results;
60 | }
61 | }
62 |
63 | private static char GetArrowForDirection(Direction dir)
64 | {
65 | switch (dir)
66 | {
67 | case Direction.North:
68 | return '↑';
69 | case Direction.South:
70 | return '↓';
71 | case Direction.East:
72 | return '→';
73 | case Direction.West:
74 | return '←';
75 | default:
76 | return ' ';
77 | }
78 | }
79 |
80 | private static char GetSymbolForMarker(int index)
81 | {
82 | return (char)('A' + index);
83 | }
84 |
85 | #region serialization
86 | public override string ToString()
87 | {
88 | var output = new StringBuilder();
89 |
90 | for (int y = 0; y < Height; y++)
91 | {
92 | var rowTop = new StringBuilder();
93 | var rowMid = new StringBuilder();
94 |
95 | for (int x = 0; x < Width; x++)
96 | {
97 | var thisCell = Connections[x, y];
98 |
99 | var prevRowPrevCell = y == 0
100 | ? x > 0
101 | ? Direction.East | Direction.West
102 | : Direction.East | Direction.South
103 | : x > 0
104 | ? Connections[x - 1, y - 1]
105 | : Direction.North | Direction.South;
106 |
107 | rowTop.Append(DetermineCornerCharacter(prevRowPrevCell, thisCell));
108 | rowTop.Append(DetermineVerticalCharacter(thisCell));
109 |
110 | rowMid.Append(DetermineHorizontalCharacter(thisCell));
111 | rowMid.Append(DetermineContentCharacter(x, y));
112 | }
113 |
114 | var aboveLastCell = y > 0
115 | ? Connections[Width - 1, y - 1]
116 | : Direction.East | Direction.West;
117 |
118 | rowTop.Append(DetermineCornerCharacter(aboveLastCell, Direction.North | Direction.South));
119 | rowMid.Append(DetermineHorizontalCharacter(Direction.North | Direction.South));
120 |
121 | output.AppendLine(rowTop.ToString());
122 | output.AppendLine(rowMid.ToString());
123 | }
124 |
125 | {
126 | var rowTop = new StringBuilder();
127 |
128 | int y = Height - 1;
129 | for (int x = 0; x < Width; x++)
130 | {
131 | var prevRowPrevCell = x > 0
132 | ? Connections[x - 1, y]
133 | : Direction.North | Direction.South;
134 |
135 | var fakeRow = Direction.East | Direction.West;
136 |
137 | rowTop.Append(DetermineCornerCharacter(prevRowPrevCell, fakeRow));
138 | rowTop.Append(DetermineVerticalCharacter(fakeRow));
139 | }
140 |
141 | rowTop.Append(DetermineCornerCharacter(Direction.None, Direction.North | Direction.West));
142 |
143 | output.AppendLine(rowTop.ToString());
144 | }
145 |
146 | return output.ToString();
147 | }
148 |
149 | private static char DetermineVerticalCharacter(Direction connections)
150 | {
151 | return connections.HasFlag(Direction.North)
152 | ? ' '
153 | : '─';
154 | }
155 |
156 | private static char DetermineHorizontalCharacter(Direction connections)
157 | {
158 | return connections.HasFlag(Direction.West)
159 | ? ' '
160 | : '│';
161 | }
162 |
163 | private static char DetermineCornerCharacter(Direction topLeft, Direction bottomRight)
164 | {
165 | if (topLeft.HasFlag(Direction.East))
166 | if (topLeft.HasFlag(Direction.South))
167 | {
168 | if (bottomRight.HasFlag(Direction.West))
169 | {
170 | if (bottomRight.HasFlag(Direction.North))
171 | return ' ';
172 | else
173 | return '─'; // right-only-dash?
174 | }
175 | else if (bottomRight.HasFlag(Direction.North))
176 | return '│'; // down-only dash?
177 | else
178 | return '┌';
179 | }
180 | else
181 | {
182 | if (bottomRight.HasFlag(Direction.West))
183 | {
184 | /*
185 | if (bottomRight.HasFlag(Direction.North))
186 | return '─'; // left-only dash?
187 | else
188 | */
189 | return '─';
190 | }
191 | else if (bottomRight.HasFlag(Direction.North))
192 | return '┐';
193 | else
194 | return '┬';
195 | }
196 | else if (topLeft.HasFlag(Direction.South))
197 | {
198 | if (bottomRight.HasFlag(Direction.West))
199 | {
200 | if (bottomRight.HasFlag(Direction.North))
201 | return '│'; // up-only dash?
202 | else
203 | return '└';
204 | }
205 | else if (bottomRight.HasFlag(Direction.North))
206 | return '│';
207 | else
208 | return '├';
209 | }
210 | else
211 | {
212 | if (bottomRight.HasFlag(Direction.West))
213 | {
214 | if (bottomRight.HasFlag(Direction.North))
215 | return '┘';
216 | else
217 | return '┴';
218 | }
219 | else if (bottomRight.HasFlag(Direction.North))
220 | return '┤';
221 | else
222 | return '┼';
223 | }
224 | }
225 | private char DetermineContentCharacter(int x, int y)
226 | {
227 | var point = new Point(x, y);
228 |
229 | var index = Markers.IndexOf(point);
230 | if (index != -1)
231 | return GetSymbolForMarker(index);
232 |
233 | var matchingArrow = Arrows.FirstOrDefault(arr => arr.Item1 == point);
234 |
235 | if (matchingArrow != null)
236 | return GetArrowForDirection(matchingArrow.Item2);
237 |
238 | return ' ';
239 | }
240 | #endregion serialization
241 | }
242 | }
243 |
--------------------------------------------------------------------------------
/RobotInterrogation/Models/Interview.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 |
4 | namespace RobotInterrogation.Models
5 | {
6 | public class Interview
7 | {
8 | public string InterviewID { get; set; }
9 |
10 | public InterviewStatus Status { get; set; } = InterviewStatus.WaitingForConnections;
11 |
12 | public InterviewOutcome? Outcome { get; set; }
13 |
14 | public DateTime? Started { get; set; }
15 |
16 | public List Players { get; } = new List();
17 |
18 | public int InterviewerIndex { get; set; } = -1;
19 |
20 | public int SuspectIndex { get; set; } = -1;
21 |
22 | public List Penalties { get; } = new List();
23 |
24 | public List SuspectBackgrounds { get; } = new List();
25 |
26 | public Packet Packet { get; set; }
27 |
28 | public SuspectRole Role { get; set; }
29 |
30 | public string Prompt { get; set; }
31 |
32 | public InterferencePattern InterferencePattern { get; set; }
33 |
34 | public List PrimaryQuestions { get; } = new List();
35 |
36 | public List SecondaryQuestions { get; } = new List();
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/RobotInterrogation/Models/InterviewOutcome.cs:
--------------------------------------------------------------------------------
1 | namespace RobotInterrogation.Models
2 | {
3 | public enum InterviewOutcome
4 | {
5 | Disconnected = 0,
6 | CorrectlyGuessedHuman,
7 | WronglyGuessedHuman,
8 | CorrectlyGuessedRobot,
9 | WronglyGuessedRobot,
10 | KilledInterviewer,
11 | }
12 | }
--------------------------------------------------------------------------------
/RobotInterrogation/Models/InterviewStatus.cs:
--------------------------------------------------------------------------------
1 | namespace RobotInterrogation.Models
2 | {
3 | public enum InterviewStatus
4 | {
5 | WaitingForConnections,
6 | SelectingPositions,
7 |
8 | SelectingPenalty_Interviewer,
9 | SelectingPenalty_Suspect,
10 | CalibratingPenalty,
11 |
12 | SelectingPacket,
13 |
14 | PromptingInducer,
15 | SolvingInducer,
16 |
17 | SelectingSuspectBackground,
18 |
19 | ReadyToStart,
20 |
21 | InProgress,
22 |
23 | Finished,
24 | }
25 | }
--------------------------------------------------------------------------------
/RobotInterrogation/Models/Packet.cs:
--------------------------------------------------------------------------------
1 | namespace RobotInterrogation.Models
2 | {
3 | public class PacketInfo
4 | {
5 | public string Name { get; set; }
6 |
7 | public string Difficulty { get; set; }
8 |
9 | public string Icon { get; set; }
10 | }
11 |
12 | public class Packet : PacketInfo
13 | {
14 | public string Prompt { get; set; }
15 |
16 | public Question[] Questions { get; set; }
17 |
18 | public SuspectRole[] Roles { get; set; }
19 | }
20 | }
--------------------------------------------------------------------------------
/RobotInterrogation/Models/Player.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Threading.Tasks;
5 |
6 | namespace RobotInterrogation.Models
7 | {
8 | public class Player
9 | {
10 | public string ConnectionID { get; set; }
11 |
12 | public string InterviewID { get; set; }
13 |
14 | public string Name { get; set; }
15 |
16 | public PlayerPosition Position { get; set; }
17 | }
18 | }
19 |
--------------------------------------------------------------------------------
/RobotInterrogation/Models/PlayerPosition.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Threading.Tasks;
5 |
6 | namespace RobotInterrogation.Models
7 | {
8 | public enum PlayerPosition
9 | {
10 | Interviewer,
11 | Suspect,
12 | Spectator
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/RobotInterrogation/Models/Question.cs:
--------------------------------------------------------------------------------
1 | namespace RobotInterrogation.Models
2 | {
3 | public class Question
4 | {
5 | public bool IsPrimary { get; set; }
6 | public string Challenge { get; set; }
7 | public string[] Examples { get; set; }
8 | }
9 | }
--------------------------------------------------------------------------------
/RobotInterrogation/Models/SuspectRole.cs:
--------------------------------------------------------------------------------
1 | namespace RobotInterrogation.Models
2 | {
3 | public class SuspectRole
4 | {
5 | public SuspectRoleType Type { get; set; }
6 | public string Fault { get; set; }
7 | public string Traits { get; set; }
8 | }
9 | }
--------------------------------------------------------------------------------
/RobotInterrogation/Models/SuspectRoleType.cs:
--------------------------------------------------------------------------------
1 | namespace RobotInterrogation.Models
2 | {
3 | public enum SuspectRoleType
4 | {
5 | Human = 0,
6 | PatientRobot,
7 | ViolentRobot,
8 | }
9 | }
--------------------------------------------------------------------------------
/RobotInterrogation/Pages/Error.cshtml:
--------------------------------------------------------------------------------
1 | @page
2 | @model ErrorModel
3 | @{
4 | ViewData["Title"] = "Error";
5 | }
6 |
7 | Error.
8 | An error occurred while processing your request.
9 |
10 | @if (Model.ShowRequestId)
11 | {
12 |
13 | Request ID: @Model.RequestId
14 |
15 | }
16 |
17 | Development Mode
18 |
19 | Swapping to the Development environment displays detailed information about the error that occurred.
20 |
21 |
22 | The Development environment shouldn't be enabled for deployed applications.
23 | It can result in displaying sensitive information from exceptions to end users.
24 | For local debugging, enable the Development environment by setting the ASPNETCORE_ENVIRONMENT environment variable to Development
25 | and restarting the app.
26 |
27 |
--------------------------------------------------------------------------------
/RobotInterrogation/Pages/Error.cshtml.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Diagnostics;
4 | using System.Linq;
5 | using System.Threading.Tasks;
6 | using Microsoft.AspNetCore.Mvc;
7 | using Microsoft.AspNetCore.Mvc.RazorPages;
8 | using Microsoft.Extensions.Logging;
9 |
10 | namespace RobotInterrogation.Pages
11 | {
12 | [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
13 | public class ErrorModel : PageModel
14 | {
15 | private readonly ILogger _logger;
16 |
17 | public ErrorModel(ILogger logger)
18 | {
19 | _logger = logger;
20 | }
21 |
22 | public string RequestId { get; set; }
23 |
24 | public bool ShowRequestId => !string.IsNullOrEmpty(RequestId);
25 |
26 | public void OnGet()
27 | {
28 | RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier;
29 | }
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/RobotInterrogation/Pages/_ViewImports.cshtml:
--------------------------------------------------------------------------------
1 | @using RobotInterrogation
2 | @namespace RobotInterrogation.Pages
3 | @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
4 |
--------------------------------------------------------------------------------
/RobotInterrogation/Program.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Threading.Tasks;
5 | using Microsoft.AspNetCore.Hosting;
6 | using Microsoft.Extensions.Configuration;
7 | using Microsoft.Extensions.Hosting;
8 | using Microsoft.Extensions.Logging;
9 | using RobotInterrogation.Services;
10 |
11 | namespace RobotInterrogation
12 | {
13 | public class Program
14 | {
15 | public static void Main(string[] args)
16 | {
17 | CreateHostBuilder(args).Build().Run();
18 | }
19 |
20 | public static IHostBuilder CreateHostBuilder(string[] args) =>
21 | Host.CreateDefaultBuilder(args)
22 | .ConfigureLogging(logging =>
23 | logging.AddFilter(InterviewService.LogName, LogLevel.Information)
24 | )
25 | .ConfigureWebHostDefaults(webBuilder =>
26 | {
27 | webBuilder.UseStartup();
28 | });
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/RobotInterrogation/Properties/launchSettings.json:
--------------------------------------------------------------------------------
1 | {
2 | "iisSettings": {
3 | "windowsAuthentication": false,
4 | "anonymousAuthentication": true,
5 | "iisExpress": {
6 | "applicationUrl": "http://localhost:58663/",
7 | "sslPort": 44376
8 | }
9 | },
10 | "profiles": {
11 | "IIS Express": {
12 | "commandName": "IISExpress",
13 | "launchBrowser": true,
14 | "environmentVariables": {
15 | "ASPNETCORE_ENVIRONMENT": "Development"
16 | }
17 | },
18 | "RobotInterrogation": {
19 | "commandName": "Project",
20 | "launchBrowser": true,
21 | "environmentVariables": {
22 | "ASPNETCORE_ENVIRONMENT": "Development"
23 | },
24 | "applicationUrl": "https://localhost:5001;http://localhost:5000"
25 | }
26 | }
27 | }
--------------------------------------------------------------------------------
/RobotInterrogation/RobotInterrogation.csproj:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | net5.0
5 | true
6 | Latest
7 | AspNetCoreModuleV2
8 | true
9 | false
10 | ClientApp\
11 | $(DefaultItemExcludes);$(SpaRoot)node_modules\**
12 |
13 |
14 |
15 |
17 |
18 |
19 |
20 |
24 |
25 |
26 |
27 |
28 |
30 |
34 |
35 |
36 |
37 |
42 |
44 | %(DistFiles.Identity)
45 | PreserveNewest
46 | true
47 |
48 |
49 |
50 |
51 |
52 |
--------------------------------------------------------------------------------
/RobotInterrogation/Services/ExtensionMethods.cs:
--------------------------------------------------------------------------------
1 | using System;
2 |
3 | namespace RobotInterrogation.Services
4 | {
5 | public static class ExtensionMethods
6 | {
7 | public static T[][] ToJaggedArray(this T[,] twoDimensionalArray)
8 | {
9 | return ToJaggedArray(twoDimensionalArray, val => val);
10 | }
11 |
12 | public static TResult[][] ToJaggedArray(this TSource[,] twoDimensionalArray, Func convertValue)
13 | {
14 | int rowsFirstIndex = twoDimensionalArray.GetLowerBound(0);
15 | int rowsLastIndex = twoDimensionalArray.GetUpperBound(0);
16 | int numberOfRows = rowsLastIndex + 1;
17 |
18 | int columnsFirstIndex = twoDimensionalArray.GetLowerBound(1);
19 | int columnsLastIndex = twoDimensionalArray.GetUpperBound(1);
20 | int numberOfColumns = columnsLastIndex + 1;
21 |
22 | TResult[][] jaggedArray = new TResult[numberOfRows][];
23 | for (int i = rowsFirstIndex; i <= rowsLastIndex; i++)
24 | {
25 | jaggedArray[i] = new TResult[numberOfColumns];
26 |
27 | for (int j = columnsFirstIndex; j <= columnsLastIndex; j++)
28 | {
29 | jaggedArray[i][j] = convertValue(twoDimensionalArray[i, j]);
30 | }
31 | }
32 | return jaggedArray;
33 | }
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/RobotInterrogation/Services/InterferenceService.cs:
--------------------------------------------------------------------------------
1 | using RobotInterrogation.Models;
2 | using System;
3 | using System.Collections.Generic;
4 | using System.Drawing;
5 | using System.Linq;
6 |
7 | namespace RobotInterrogation.Services
8 | {
9 | public class InterferenceService
10 | {
11 | public InterferencePattern Generate(Random random, int simpleWidth = 7, int simpleHeight = 4, int numMarkers = 6)
12 | {
13 | // Generate a simple maze pattern.
14 | var simplePattern = GenerateSimple(random, simpleWidth, simpleHeight);
15 |
16 | // Convert each cell of the maze into 2x2 cell squares, and add lines down the middle of each squares.
17 | var pattern = DoubleUp(simplePattern);
18 |
19 | // Place more than the required number of markers, initially.
20 | List markerPositions = PlaceMarkers(random, pattern.Width, pattern.Height, numMarkers * 4);
21 |
22 | // Determine the path through the maze.
23 | var markerData = SolveSequence(random, markerPositions, pattern.Connections);
24 |
25 | // Remove markers from this path that are too close together, leaving us with numMarkers.
26 | RemoveClosestMarkers(markerData, numMarkers);
27 |
28 | // Save the marker positions, in "display" order.
29 | pattern.Markers.AddRange
30 | (
31 | markerData
32 | .OrderBy(step => step.SortOrder)
33 | .Select(step => step.Cell)
34 | );
35 |
36 | // Now save the solution.
37 | pattern.MarkerSequence.AddRange
38 | (
39 | markerData.Select(step => step.SortOrder)
40 | );
41 |
42 | // For each marker, decide which arrow to keep, and add it to the pattern.
43 | foreach (var marker in markerData)
44 | {
45 | var subsequentCell = marker.SubsequentCell;
46 | var connections = pattern.Connections[subsequentCell.X, subsequentCell.Y];
47 |
48 | // If there's space to continue in the subsequent direction, use that cell for the arrow.
49 | // Otherwise use the previous cell, which points at the marker cell.
50 | if (connections.HasFlag(marker.SubsequentCellDirection))
51 | pattern.Arrows.Add(new Tuple(subsequentCell, marker.SubsequentCellDirection));
52 | else
53 | pattern.Arrows.Add(new Tuple(marker.PreviousCell, marker.PreviousCellDirection));
54 | }
55 |
56 | return pattern;
57 | }
58 |
59 | private struct Coord
60 | {
61 | public Coord(int x, int y, InterferencePattern.Direction direction, InterferencePattern.Direction opposite)
62 | {
63 | Direction = direction;
64 | OppositeDirection = opposite;
65 | X = x;
66 | Y = y;
67 | }
68 |
69 | public InterferencePattern.Direction Direction { get; }
70 |
71 | public InterferencePattern.Direction OppositeDirection { get; }
72 |
73 | public int X { get; }
74 |
75 | public int Y { get; }
76 | }
77 |
78 | private List CardinalOffsets { get; } = new List
79 | {
80 | new Coord(1, 0, InterferencePattern.Direction.East, InterferencePattern.Direction.West),
81 | new Coord(-1, 0, InterferencePattern.Direction.West, InterferencePattern.Direction.East),
82 | new Coord(0, 1, InterferencePattern.Direction.South, InterferencePattern.Direction.North),
83 | new Coord(0, -1, InterferencePattern.Direction.North, InterferencePattern.Direction.South),
84 | };
85 |
86 | private InterferencePattern GenerateSimple(Random random, int width, int height)
87 | {
88 | var pattern = new InterferencePattern(width, height);
89 | GeneratePassagesFrom(0, 0, pattern, random);
90 | return pattern;
91 | }
92 |
93 | private void GeneratePassagesFrom(int startX, int startY, InterferencePattern pattern, Random random)
94 | {
95 | var directions = new List(CardinalOffsets);
96 | Shuffle(directions, random);
97 |
98 | foreach (var direction in directions)
99 | {
100 | int nextX = startX + direction.X;
101 | if (nextX < 0 || nextX >= pattern.Width)
102 | continue;
103 |
104 | int nextY = startY + direction.Y;
105 | if (nextY < 0 || nextY >= pattern.Height)
106 | continue;
107 |
108 | if (pattern.Connections[nextX, nextY] != InterferencePattern.Direction.None)
109 | continue;
110 |
111 | pattern.Connections[startX, startY] |= direction.Direction;
112 | pattern.Connections[nextX, nextY] |= direction.OppositeDirection;
113 |
114 | GeneratePassagesFrom(nextX, nextY, pattern, random);
115 | }
116 | }
117 |
118 | private InterferencePattern DoubleUp(InterferencePattern source)
119 | {
120 | var result = new InterferencePattern(source.Width * 2, source.Height * 2);
121 |
122 | for (int sourceX = 0; sourceX < source.Width; sourceX++)
123 | for (int sourceY = 0; sourceY < source.Height; sourceY++)
124 | {
125 | var destX = sourceX * 2;
126 | var destY = sourceY * 2;
127 |
128 | // Expand each source cell into 2x2 cells in the destination, filling the interior walls wherever there's an external connection.
129 | var sourceConnections = source.Connections[sourceX, sourceY];
130 |
131 | bool midNorthOpen = !sourceConnections.HasFlag(InterferencePattern.Direction.North);
132 | bool midSouthOpen = !sourceConnections.HasFlag(InterferencePattern.Direction.South);
133 | bool midEastOpen = !sourceConnections.HasFlag(InterferencePattern.Direction.East);
134 | bool midWestOpen = !sourceConnections.HasFlag(InterferencePattern.Direction.West);
135 |
136 | var northWest = sourceConnections & (InterferencePattern.Direction.North | InterferencePattern.Direction.West);
137 | if (midNorthOpen)
138 | northWest |= InterferencePattern.Direction.East;
139 | if (midWestOpen)
140 | northWest |= InterferencePattern.Direction.South;
141 | result.Connections[destX, destY] = northWest;
142 |
143 | var northEast = sourceConnections & (InterferencePattern.Direction.North | InterferencePattern.Direction.East);
144 | if (midNorthOpen)
145 | northEast |= InterferencePattern.Direction.West;
146 | if (midEastOpen)
147 | northEast |= InterferencePattern.Direction.South;
148 | result.Connections[destX + 1, destY] = northEast;
149 |
150 | var southWest = sourceConnections & (InterferencePattern.Direction.South | InterferencePattern.Direction.West);
151 | if (midSouthOpen)
152 | southWest |= InterferencePattern.Direction.East;
153 | if (midWestOpen)
154 | southWest |= InterferencePattern.Direction.North;
155 | result.Connections[destX, destY + 1] = southWest;
156 |
157 | var southEast = sourceConnections & (InterferencePattern.Direction.South | InterferencePattern.Direction.East);
158 | if (midSouthOpen)
159 | southEast |= InterferencePattern.Direction.West;
160 | if (midEastOpen)
161 | southEast |= InterferencePattern.Direction.North;
162 | result.Connections[destX + 1, destY + 1] = southEast;
163 | }
164 |
165 | return result;
166 | }
167 |
168 | private void Shuffle(IList list, Random random)
169 | {
170 | int n = list.Count;
171 | while (n > 1)
172 | {
173 | n--;
174 | int k = random.Next(n + 1);
175 | T value = list[k];
176 | list[k] = list[n];
177 | list[n] = value;
178 | }
179 | }
180 |
181 | private List PlaceMarkers(Random random, int width, int height, int numMarkers)
182 | {
183 | var results = new List();
184 |
185 | for (int i = 0; i < numMarkers; i++)
186 | {
187 | Point point;
188 |
189 | do
190 | {
191 | point = new Point(random.Next(width), random.Next(height));
192 | } while (results.Contains(point));
193 |
194 | results.Add(point);
195 | }
196 |
197 | return results;
198 | }
199 |
200 | private class SequenceMarker
201 | {
202 | public int SortOrder { get; set; }
203 |
204 | public Point Cell { get; set; }
205 | public int StepsToNextMarker { get; set; }
206 |
207 | public Point PreviousCell { get; set; }
208 | public Point SubsequentCell { get; set; }
209 |
210 | public InterferencePattern.Direction PreviousCellDirection { get; set; }
211 | public InterferencePattern.Direction SubsequentCellDirection { get; set; }
212 | }
213 |
214 | private List SolveSequence(Random random, List markers, InterferencePattern.Direction[,] connections)
215 | {
216 | var directions = new List(CardinalOffsets);
217 | Shuffle(directions, random);
218 |
219 | var results = new List();
220 | var startPosition = markers.First();
221 | var currentPosition = startPosition;
222 | var prevPosition = startPosition;
223 | var prevDirection = InterferencePattern.Direction.None;
224 |
225 | var stepsToNextMarker = 0;
226 |
227 | SequenceMarker prevMarker = new SequenceMarker
228 | {
229 | SortOrder = 0,
230 | Cell = currentPosition,
231 | };
232 |
233 | do
234 | {
235 | stepsToNextMarker++;
236 |
237 | // Find a direction we can move in that isn't back to where we came from.
238 | var currentConnections = connections[currentPosition.X, currentPosition.Y];
239 | var direction = directions.First
240 | (
241 | direction => currentConnections.HasFlag(direction.Direction)
242 | && direction.OppositeDirection != prevDirection
243 | );
244 |
245 | prevPosition = currentPosition;
246 | currentPosition.Offset(direction.X, direction.Y);
247 | prevDirection = direction.Direction;
248 |
249 | if (prevMarker.SubsequentCellDirection == InterferencePattern.Direction.None)
250 | {
251 | prevMarker.SubsequentCell = currentPosition;
252 | prevMarker.SubsequentCellDirection = prevDirection;
253 | }
254 |
255 | var markerId = markers.IndexOf(currentPosition);
256 | if (markerId != -1)
257 | {
258 | var test = markers[markerId];
259 |
260 | // We've reached a new marker, so add it to the results.
261 | prevMarker = new SequenceMarker
262 | {
263 | SortOrder = markerId,
264 | Cell = currentPosition,
265 | PreviousCell = prevPosition,
266 | PreviousCellDirection = prevDirection,
267 | };
268 |
269 | results.Add(prevMarker);
270 |
271 | // Update the previous marker with its # steps.
272 | prevMarker.StepsToNextMarker = stepsToNextMarker;
273 | stepsToNextMarker = 0;
274 | }
275 | } while (currentPosition != startPosition);
276 |
277 | var firstStep = results.First();
278 | firstStep.PreviousCell = prevPosition;
279 | firstStep.PreviousCellDirection = prevDirection;
280 |
281 | return results;
282 | }
283 |
284 | private void RemoveClosestMarkers(List markerData, int targetNumMarkers)
285 | {
286 | // Remove the marker with the shortest StepsToNextMarker, until we have targetNumMarkers.
287 | while (markerData.Count > targetNumMarkers)
288 | {
289 | int removeIndex = FindMinIndex(markerData, out int removeLength);
290 |
291 | int prevIndex = removeIndex == 0
292 | ? markerData.Count - 1
293 | : removeIndex - 1;
294 |
295 | // The removed item's "steps to next" gets added onto the previous step.
296 | markerData[prevIndex].StepsToNextMarker += removeLength;
297 |
298 | var removeMarker = markerData[removeIndex];
299 | markerData.RemoveAt(removeIndex);
300 |
301 | foreach (var step in markerData.Where(step => step.SortOrder > removeMarker.SortOrder))
302 | step.SortOrder--;
303 | }
304 | }
305 |
306 | private int FindMinIndex(List values, out int minValue)
307 | {
308 | int index = 0;
309 | minValue = int.MaxValue;
310 |
311 | for (int i = 0; i < values.Count; i++)
312 | {
313 | var value = values[i].StepsToNextMarker;
314 | if (value < minValue)
315 | {
316 | index = i;
317 | minValue = value;
318 | }
319 | }
320 |
321 | return index;
322 | }
323 | }
324 | }
325 |
--------------------------------------------------------------------------------
/RobotInterrogation/Services/InterviewService.cs:
--------------------------------------------------------------------------------
1 | using Microsoft.Extensions.Logging;
2 | using Microsoft.Extensions.Options;
3 | using RobotInterrogation.Models;
4 | using System;
5 | using System.Collections.Concurrent;
6 | using System.Collections.Generic;
7 | using System.Linq;
8 | using System.Text.Json;
9 | using System.Text.Json.Serialization;
10 |
11 | namespace RobotInterrogation.Services
12 | {
13 | public class InterviewService
14 | {
15 | private static ConcurrentDictionary Players = new ConcurrentDictionary();
16 | private static ConcurrentDictionary Interviews = new ConcurrentDictionary();
17 |
18 | private static Random IdGenerator = new Random();
19 |
20 | private GameConfiguration Configuration { get; }
21 | private IDGeneration IDs { get; }
22 | private InterferenceService InterferenceService { get; }
23 | private ILogger Logger { get; }
24 |
25 | public const string LogName = "Interviews";
26 |
27 | public InterviewService(IOptions configuration, IOptions idWords, InterferenceService interferenceService, ILoggerFactory logger)
28 | {
29 | Configuration = configuration.Value;
30 | IDs = idWords.Value;
31 | InterferenceService = interferenceService;
32 | Logger = logger.CreateLogger(LogName);
33 | }
34 |
35 | public string GetNewInterviewID()
36 | {
37 | lock (IdGenerator)
38 | {
39 | var interview = new Interview();
40 | interview.InterviewID = GenerateID();
41 | Interviews[interview.InterviewID.ToLower()] = interview;
42 | return interview.InterviewID;
43 | }
44 | }
45 |
46 | private string GenerateID()
47 | {
48 | if (IDs.WordCount <= 0)
49 | return string.Empty;
50 |
51 | string id;
52 | do
53 | {
54 | int[] iWords = new int[IDs.WordCount];
55 |
56 | for (int i = 0; i < IDs.WordCount; i++)
57 | {
58 | do
59 | {
60 | int iWord = IdGenerator.Next(IDs.Words.Length);
61 |
62 | bool reused = iWords
63 | .Take(i)
64 | .Any(jWord => jWord == iWord);
65 |
66 | if (reused)
67 | continue;
68 |
69 | iWords[i] = iWord;
70 | break;
71 | } while (true);
72 | }
73 |
74 | id = string.Join("", iWords.Select(i => IDs.Words[i]));
75 | } while (Interviews.ContainsKey(id.ToLower()));
76 |
77 | return id;
78 | }
79 |
80 | public string GetInterviewerConnectionID(Interview interview)
81 | {
82 | return interview.Players[interview.InterviewerIndex].ConnectionID;
83 | }
84 |
85 | public string GetSuspectConnectionID(Interview interview)
86 | {
87 | return interview.Players[interview.SuspectIndex].ConnectionID;
88 | }
89 |
90 | public Player GetPlayerByConnectionID(string connectionID)
91 | {
92 | return Players[connectionID];
93 | }
94 |
95 | public bool TryAddUser(Interview interview, string connectionID)
96 | {
97 | if (interview.Players.Count >= Configuration.MaxPlayers)
98 | return false;
99 |
100 | var player = new Player();
101 | player.ConnectionID = connectionID;
102 | Players[connectionID] = player;
103 | interview.Players.Add(player);
104 |
105 | if (interview.InterviewerIndex == -1)
106 | {
107 | player.Position = PlayerPosition.Interviewer;
108 | interview.InterviewerIndex = interview.Players.Count - 1;
109 | } else if (interview.SuspectIndex == -1)
110 | {
111 | player.Position = PlayerPosition.Suspect;
112 | interview.SuspectIndex = interview.Players.Count - 1;
113 | } else
114 | {
115 | player.Position = PlayerPosition.Spectator;
116 | }
117 |
118 | player.InterviewID = interview.InterviewID;
119 |
120 | return true;
121 | }
122 |
123 | public void RemovePlayer(Player player)
124 | {
125 | GetInterview(player.InterviewID).Players.Remove(player);
126 | Players.Remove(player.ConnectionID, out Player p);
127 | }
128 |
129 | public void RemoveInterview(string interviewID)
130 | {
131 | Interview interview;
132 | if (!Interviews.TryRemove(interviewID.ToLower(), out interview))
133 | {
134 | foreach(Player player in interview.Players)
135 | Players.TryRemove(player.ConnectionID, out Player p);
136 | return;
137 | }
138 |
139 | if (interview.Status == InterviewStatus.InProgress)
140 | {
141 | LogInterview(interview);
142 | }
143 | }
144 |
145 | public bool TryGetInterview(string interviewID, out Interview interview)
146 | {
147 | return Interviews.TryGetValue(interviewID.ToLower(), out interview);
148 | }
149 |
150 | public Interview GetInterview(string interviewID)
151 | {
152 | if (!Interviews.TryGetValue(interviewID.ToLower(), out Interview interview))
153 | throw new Exception($"Invalid interview ID: {interviewID}");
154 |
155 | return interview;
156 | }
157 |
158 | public Interview GetInterviewWithStatus(string interviewID, InterviewStatus status)
159 | {
160 | var interview = GetInterview(interviewID);
161 |
162 | if (interview.Status != status)
163 | throw new Exception($"Interview doesn't have the required status {status} - it is actually {interview.Status}");
164 |
165 | return interview;
166 | }
167 |
168 | public bool HasTimeElapsed(Interview interview)
169 | {
170 | if (!interview.Started.HasValue)
171 | return false;
172 |
173 | return interview.Started.Value + TimeSpan.FromSeconds(Configuration.Duration)
174 | <= DateTime.Now;
175 | }
176 |
177 | private void AllocateRandomValues(IList source, IList destination, int targetNum)
178 | {
179 | destination.Clear();
180 |
181 | var random = new Random();
182 |
183 | while (destination.Count < targetNum)
184 | {
185 | int iSelection = random.Next(source.Count);
186 | T selection = source[iSelection];
187 |
188 | if (destination.Contains(selection))
189 | continue;
190 |
191 | destination.Add(selection);
192 | }
193 | }
194 |
195 | public void AllocatePenalties(Interview interview)
196 | {
197 | AllocateRandomValues(Configuration.Penalties, interview.Penalties, 3);
198 | }
199 |
200 | public PacketInfo[] GetAllPackets()
201 | {
202 | return Configuration.Packets;
203 | }
204 |
205 | public Packet GetPacket(int index)
206 | {
207 | return Configuration.Packets[index];
208 | }
209 |
210 | public void AllocateRole(Interview interview)
211 | {
212 | var possibleRoles = new List(interview.Packet.Roles);
213 |
214 | // Always have a 50% chance of being human.
215 | possibleRoles.AddRange(
216 | interview.Packet.Roles.Select(role => Configuration.HumanRole)
217 | );
218 |
219 | var roles = new List();
220 |
221 | AllocateRandomValues(possibleRoles, roles, 1);
222 |
223 | interview.Role = roles.First();
224 | }
225 |
226 | public void SetPacketAndInducer(Interview interview, int packetIndex)
227 | {
228 | interview.Packet = GetPacket(packetIndex);
229 | interview.InterferencePattern = InterferenceService.Generate(new Random());
230 | }
231 |
232 | public void AllocateSuspectBackgrounds(Interview interview, int numOptions)
233 | {
234 | AllocateRandomValues(Configuration.SuspectBackgrounds, interview.SuspectBackgrounds, numOptions);
235 | }
236 |
237 | public InterviewOutcome GuessSuspectRole(Interview interview, bool guessIsRobot)
238 | {
239 | var actualRole = interview.Role.Type;
240 |
241 | InterviewOutcome outcome;
242 |
243 | if (guessIsRobot)
244 | {
245 | outcome = actualRole == SuspectRoleType.Human
246 | ? InterviewOutcome.WronglyGuessedRobot
247 | : InterviewOutcome.CorrectlyGuessedRobot;
248 | }
249 | else
250 | {
251 | outcome = actualRole == SuspectRoleType.Human
252 | ? InterviewOutcome.CorrectlyGuessedHuman
253 | : InterviewOutcome.WronglyGuessedHuman;
254 | }
255 |
256 | interview.Status = InterviewStatus.Finished;
257 | interview.Outcome = outcome;
258 |
259 | LogInterview(interview);
260 |
261 | return outcome;
262 | }
263 |
264 | public void KillInterviewer(Interview interview)
265 | {
266 | if (interview.Role.Type != SuspectRoleType.ViolentRobot)
267 | {
268 | throw new Exception("Suspect is not a violent robot, so cannot kill interviewer");
269 | }
270 |
271 | interview.Status = InterviewStatus.Finished;
272 | interview.Outcome = InterviewOutcome.KilledInterviewer;
273 |
274 | LogInterview(interview);
275 | }
276 |
277 | public Interview ResetInterview(string interviewID)
278 | {
279 | var oldInterview = GetInterviewWithStatus(interviewID, InterviewStatus.Finished);
280 |
281 | var newInterview = new Interview();
282 | Interviews[interviewID.ToLower()] = newInterview;
283 |
284 | newInterview.InterviewID = interviewID;
285 | newInterview.Status = InterviewStatus.SelectingPositions;
286 | newInterview.Players.AddRange(oldInterview.Players);
287 | newInterview.InterviewerIndex = oldInterview.InterviewerIndex;
288 | newInterview.SuspectIndex = oldInterview.SuspectIndex;
289 |
290 | return newInterview;
291 | }
292 |
293 | private void LogInterview(Interview interview)
294 | {
295 | var duration = interview.Started.HasValue
296 | ? DateTime.Now - interview.Started.Value
297 | : TimeSpan.Zero;
298 |
299 | var interviewData = new
300 | {
301 | interview.Status,
302 | interview.Outcome,
303 | Duration = duration,
304 | Packet = interview.Packet.Name,
305 | InterferencePattern = interview.InterferencePattern.ToString(),
306 | InterferenceSolution = interview.InterferencePattern.SolutionSequence,
307 | SuspectBackground = interview.SuspectBackgrounds.First(),
308 | SuspectType = interview.Role.Type,
309 | SuspectFault = interview.Role.Fault,
310 | SuspectTraits = interview.Role.Traits,
311 | };
312 |
313 | var options = new JsonSerializerOptions();
314 | options.Converters.Add(new JsonStringEnumConverter());
315 | var strData = JsonSerializer.Serialize(interviewData, options);
316 |
317 | Logger.LogInformation(
318 | "Interview completed at {Time}: {Data}",
319 | DateTime.Now,
320 | strData
321 | );
322 | }
323 | }
324 | }
325 |
--------------------------------------------------------------------------------
/RobotInterrogation/Startup.cs:
--------------------------------------------------------------------------------
1 | using Microsoft.AspNetCore.Builder;
2 | using Microsoft.AspNetCore.Hosting;
3 | using Microsoft.AspNetCore.HttpsPolicy;
4 | using Microsoft.AspNetCore.SpaServices.ReactDevelopmentServer;
5 | using Microsoft.Extensions.Configuration;
6 | using Microsoft.Extensions.DependencyInjection;
7 | using Microsoft.Extensions.Hosting;
8 | using RobotInterrogation.Hubs;
9 | using RobotInterrogation.Models;
10 | using RobotInterrogation.Services;
11 | using System.Text.Json.Serialization;
12 |
13 | namespace RobotInterrogation
14 | {
15 | public class Startup
16 | {
17 | public Startup(IConfiguration configuration)
18 | {
19 | Configuration = configuration;
20 | }
21 |
22 | public IConfiguration Configuration { get; }
23 |
24 | // This method gets called by the runtime. Use this method to add services to the container.
25 | public void ConfigureServices(IServiceCollection services)
26 | {
27 | services.AddMvc()
28 | .AddJsonOptions(options => options.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter()));
29 |
30 | // In production, the React files will be served from this directory
31 | services.AddSpaStaticFiles(configuration =>
32 | {
33 | configuration.RootPath = "ClientApp/build";
34 | });
35 |
36 | services.Configure(options => Configuration.GetSection("GameConfiguration").Bind(options));
37 | services.Configure(options => Configuration.GetSection("IDGeneration").Bind(options));
38 |
39 | services.AddScoped();
40 | services.AddScoped();
41 |
42 | services.AddSignalR()
43 | .AddJsonProtocol(options => options.PayloadSerializerOptions.Converters.Add(new JsonStringEnumConverter()));
44 | }
45 |
46 | // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
47 | public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
48 | {
49 | if (env.IsDevelopment())
50 | {
51 | app.UseDeveloperExceptionPage();
52 | }
53 | else
54 | {
55 | app.UseExceptionHandler("/Error");
56 | app.UseHsts();
57 | }
58 |
59 | app.UseHttpsRedirection();
60 | app.UseStaticFiles();
61 | app.UseSpaStaticFiles();
62 |
63 | app.UseRouting();
64 |
65 | app.UseEndpoints(endpoints =>
66 | {
67 | endpoints.MapHub("/hub/Interview");
68 |
69 | endpoints.MapControllerRoute(
70 | name: "default",
71 | pattern: "{controller}/{action=Index}/{id?}");
72 | });
73 |
74 | app.UseSpa(spa =>
75 | {
76 | spa.Options.SourcePath = "ClientApp";
77 |
78 | if (env.IsDevelopment())
79 | {
80 | spa.UseReactDevelopmentServer(npmScript: "start");
81 | }
82 | });
83 | }
84 | }
85 | }
86 |
--------------------------------------------------------------------------------
/RobotInterrogation/appsettings.Development.json:
--------------------------------------------------------------------------------
1 | {
2 | "Logging": {
3 | "LogLevel": {
4 | "Default": "Debug",
5 | "System": "Information",
6 | "Microsoft": "Information"
7 | }
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/Tests/InterferenceServiceTests.cs:
--------------------------------------------------------------------------------
1 | using RobotInterrogation.Services;
2 | using System;
3 | using System.Linq;
4 | using Xunit;
5 |
6 | namespace Tests
7 | {
8 | public class InterferenceServiceTests
9 | {
10 | [Theory]
11 | [InlineData(1, 7, 4, 8)]
12 | [InlineData(2, 4, 8, 4)]
13 | [InlineData(3, 7, 4, 6)]
14 |
15 | public void GeneratePattern_ExpectedDimensions(int seed, int width, int height, int numMarkers)
16 | {
17 | var random = new Random(seed);
18 | var service = new InterferenceService();
19 |
20 | var pattern = service.Generate(random, width, height, numMarkers);
21 | Assert.NotNull(pattern);
22 |
23 | var display = pattern.ToString();
24 | Assert.NotNull(display);
25 |
26 | var displayLines = display.Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
27 | Assert.Equal(height * 4 + 2, displayLines.Length);
28 | Assert.Equal(string.Empty, displayLines.Last());
29 |
30 | foreach (var line in displayLines.Take(displayLines.Length - 1))
31 | {
32 | Assert.Equal(width * 4 + 1, line.Length);
33 | }
34 |
35 | Assert.Equal(numMarkers, pattern.MarkerSequence.Count);
36 | Assert.Equal(numMarkers, pattern.SolutionSequence.Count);
37 | Assert.Equal(numMarkers, pattern.Arrows.Count);
38 | }
39 |
40 | [Theory]
41 | [InlineData(1, "EFACBD", @"
42 | ┌───┬───────────┐
43 | │ │ │
44 | │ │ │ ────┬───┐ │
45 | │↑│ │ │ │ │
46 | │ │ ├──── │ │ │ │
47 | │B│ │ │ │C│ │
48 | │ │ │ ┌───┘ │ │ │
49 | │ │ │ │ │↑│ │
50 | │ │ │ │ ┌───┤ │ │
51 | │ │ │ │A │ │ │
52 | │ └───┘ │ │ │ │ │
53 | │ │↑│ │ │D│
54 | ├───────┘ │ │ │ │
55 | │ │ │↓│
56 | │ ┌───────┴───┘ │
57 | │ │ │
58 | │ │ ────┬───────┤
59 | │ │ │ E│
60 | │ └───┐ │ ┌───┐ │
61 | │ │ │ │ │↓│
62 | ├───┐ │ │ │ │ │ │
63 | │ │ │ │ │ │ │ │
64 | │ │ │ │ │ │ │ │ │
65 | │ │ │ │ │ │ │ │
66 | │ │ │ │ │ │ └───┤
67 | │ │ │ │ │ │ │
68 | │ │ │ │ │ └───┐ │
69 | │↑│ │ │ │ │ │
70 | │ │ │ │ └──── │ │
71 | │F│ │ │ │
72 | │ └───┴───────┘ │
73 | │ │
74 | └───────────────┘
75 | ")]
76 | [InlineData(2, "BFEDAC", @"
77 | ┌───┬───────────┐
78 | │ │ │
79 | │ │ │ ┌───────┐ │
80 | │ │ │ │ │ │
81 | │ │ │ │ ────┐ │ │
82 | │ │ │ │A → │ │ │
83 | │ │ │ ├───┐ │ │ │
84 | │ │ │ │ │ │ │
85 | │ │ │ │ │ │ └───┤
86 | │ │ │ │ │ │ │
87 | │ │ │ │ │ └───┐ │
88 | │ │ │ │ ← D│ │
89 | │ │ ├───┴───┐ │ │
90 | │ │ │ │ │ │
91 | │ │ │ ┌───┐ │ │ │
92 | │ │E│ │ │ │ │ │
93 | │ │ │ │ │ │ │ │ │
94 | │ │↓│ │ │F│ │ │
95 | │ │ │ │ │ └───┤ │
96 | │ │ │ │ │↑ │↓│
97 | │ │ │ │ ├──── │ │
98 | │ │ │ │ │C│
99 | │ └───┘ │ ┌───┘ │
100 | │ │ │ │
101 | ├───────┤ │ ────┤
102 | │ → B │ │ │
103 | │ ┌──── │ └───┐ │
104 | │ │ │ │ │
105 | │ │ ────┴──── │ │
106 | │ │ │ │
107 | │ └───────────┘ │
108 | │ │
109 | └───────────────┘
110 | ")]
111 | [InlineData(3, "CEBADF", @"
112 | ┌───────┬───────┐
113 | │ │ │
114 | │ ────┐ │ ────┐ │
115 | │ │↑│ │ │
116 | ├───┐ │ └──── │ │
117 | │ │ │A │ │
118 | │ │ │ └───────┤ │
119 | │ │ │ │ │
120 | │ │ └───┬──── │ │
121 | │ │ │ │↑│
122 | │ ├───┐ │ ┌───┘ │
123 | │ │ D│ │ │ B│
124 | │ │ │ │ │ │ ────┤
125 | │F│ │↓│ │ │ │
126 | │ │ │ │ │ └───┐ │
127 | │↓│ │ │ │ │
128 | │ │ └───┴──── │ │
129 | │ │ │ │
130 | │ ├───────────┘ │
131 | │ │ │
132 | │ │ ────────┬───┤
133 | │ │ ← E │ │
134 | │ └───────┐ │ │ │
135 | │ │ │ │ │
136 | ├──────── │ │ │ │
137 | │ │ │ │ │
138 | │ ┌───────┘ │ │ │
139 | │ │ → C │ │ │
140 | │ │ ────────┘ │ │
141 | │ │ │ │
142 | │ └───────────┘ │
143 | │ │
144 | └───────────────┘
145 | ")]
146 | public void GeneratePattern_SpecificResults(int seed, string expectedSequence, string expectedLayout)
147 | {
148 | var random = new Random(seed);
149 | var service = new InterferenceService();
150 |
151 | var pattern = service.Generate(random, 4, 8, 6);
152 | Assert.NotNull(pattern);
153 |
154 | var display = pattern.ToString();
155 | Assert.NotNull(display);
156 |
157 | string actualSequence = string.Join(string.Empty, pattern.SolutionSequence);
158 | Assert.Equal(expectedSequence, actualSequence);
159 |
160 | Assert.Equal(expectedLayout.Trim(), display.Trim());
161 | }
162 | }
163 | }
164 |
--------------------------------------------------------------------------------
/Tests/Tests.csproj:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | net5.0
5 |
6 | false
7 |
8 |
9 |
10 |
13 | all
14 | runtime; build; native; contentfiles; analyzers; buildtransitive
15 |
16 |
17 | all
18 | runtime; build; native; contentfiles; analyzers; buildtransitive
19 |
20 |
21 |
22 |
23 |
25 |
26 |
27 |
--------------------------------------------------------------------------------