# Game

It's done enough!

Standalone PC/OSX builds are pending.

Kudos to Peter Queckenstedt (@scutanddestroy) for doing an amazing job on the Proctor, Hillary, and Trump.

### Post-Mortem:

​This has been a positive experience. I love games that actually have nontrivial interactions in them and completely open-ended text inputs. I'm a fan of interactive fiction, but hate that feeling when you're digging around and grasping for action words like some sort of textual pixel-hunt.

The language processing systems in DS2016 aren't particularly complicated, but they're more simple than I'd like. In the first week of the jam I started writing a recurrent neural network to parse and analyze the sentiment of the player's comments. I realized, perhaps too late, that there wasn't enough clean data for me to use to accurately gauge the sentiment and map it to social groups. Instead, I wrote a basic multinomial naive bayes classifier that takes a sentence, tokenizes it, and maps it to 'like' or 'dislike'. Each group has its own classifier and tokenizer, so I could program demographics with a base voting likelihood and give each of them a few sentences on the "agrees with" and "disagrees with" sides, then have them automatically parse and change their feelings towards the player.

A usability change that came in later than one would guess was as follows: I had originally grabbed the demographic with the largest emotional response to a comment and displayed them with the sentiment change. Unfortunately, this turned out to over-exaggerate one particularly noisy group. Another change, shortly thereafter, was masking the exact amount of the change. Instead of saying +1.05% opinion, it simply became "+Conservatives" or "-Hipsters". This was visually far easier to parse and I think helped the overall readability of the game.

There is still a call to add some more direct public opinion tracking in the game, letting players know in closer to real time how they're doing among the demographics. I may find it in myself to introduce that.

The last interesting aspect that I noticed during playtesting: I had slightly over-tuned the language models to my style of writing. Instead of opining on matters at any length, people were making enormous run-on sentences which appealed to every demographic at the same time. These statements, often self-contradictory, were not something I expected or handled well. I found the game to be rather difficult, but it looks like playtesters had a dandy time making the states go all blue.

It's time again for Little Awful Jam! The theme is 'Weird History'. Make a game about folk lore, something strange that happened in history, or some corruption of events. This is my game design doc.

### Game Design Doc

The Pitch: The idea on which I've settled is Debate Simulator 2016, where you play a presidential candidate stepping up to the podium to square off against our current commander-in-chief.

The Gameplay: The gameplay consists of prompts and free responses. Your goal is to appeal to your voting base and to excite them enough to go out and vote. Alternatively, you can go 100% offensive and do nothing but verbally tear down your opponent. Your feedback will consist of your approval rating and your citizen motivation. Don't motivate people and they won't get out and vote, even if they like you. Motivate people to vote and don't get them to like you and you're sure to lose.

The Challenge: Do you know your stuff? Can you overcome the Evangelical block? How do you tacitly approve of bodily autonomy without making it seem like you approve of bodily autonomy?

Free-form Ideas:

• Pick your alignment. Left-Democrat. Centrist-Democrat. Independent. Centrist-Republican. This will change the difficulty by having different demographic groups start with different opinions of you.
• End of game: show the election map and the polls. Use real demographic data to show how things played out.
• Generate realistic text for Donald Trump by randomly mashing together words.
• Simple NLP for the player to classify sentiment and subject, including prompt text for context.

Look and Feel: 2D single-stage pixel art with largely static sprites and a camera that pans between the player and the challenger. Aiming for 640x480 resolution with 2x upscaling. No fancy particles. Minimal sprite talking animation. Animated text.

Tools: Sadly, I won't be using Godot for this. Much as I love the engine, there is so much here that requires a more robust coding language that I need to do it in libGDX with Kotlin.

Project Progression:

• Skeleton libGDX game with Kotlin. 'Hello World'.
• Scene stack and placeholder sprites. Basic game loop.
• Demographic data and player input processing + scoring.
• Opponent responses + emotional meter.
• Minimum Viable Product

Godot is a really honkin' neat engine. If you haven't tried it, I strongly recommend playing around with it. Take a look at https://godotengine.org.

I found myself in a position where I needed to build a native library. Here's my experience doing that on Windows. I can't attest to the accuracy or repeatability of these steps, but I'm leaving them here so I can revisit them when I need to. Just remember: GDNative is a way to call into shared libraries from Godot. NativeScript is the other way -- native code that can call into Godot.

### Prerequisites and Setting Up

#### You will need:

• Microsoft Visual Studio
• Python 3 + pip (or scons installed)
• Git
• A really good reason to need to build a native library

Godot is built with Scons. The process is relatively painless compared to the dependency hell that you can get into when building other tools, but it's not without challenges. I'm going to assume that you've installed Microsoft Visual Studio and can run the following on the command line:

cl.exe

 (scons) D:\Source\TerminusExperiment\CPU_v1>cl Microsoft (R) C/C++ Optimizing Compiler Version 19.00.24215.1 for x64 Copyright (C) Microsoft Corporation. All rights reserved.

 

usage: cl [ option... ] filename... [ /link linkoption... ] 

If you don't see that, you'll probably need to search for a shortcut to "VS2015 x64 Native Tools Command Prompt". That will, in turn, include a script to call the following bat file: "%comspec% /k ""C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat"" amd64"

#### CHECKPOINT: Visual Studio is installed.

Next is Scons. I'm not going to go into any depth about installing and setting up Python on Windows, but I've had more luck using Chocolatey than Anaconda. Install Python 3, pip, and virtualenv.

Make a new virtual environment somewhere with python -m venv my_scons_venv (Mine is called just 'scons' and is stored in C:\Users\Jo\virtualenvs).

Activate the new virtualenv. If you're on Windows, that means calling C:\Users\Jo\virtualenvs\scons\Scripts\activate. (This is approximately equivalent to Linux or OSX's . ./scons/bin/activate)

Install scons in your virtual environment. pip install scons

#### CHECKPOINT: Scons is installed. You can build Godot.

Now we'll pull the Godot source. There may be a way to make do without this, but I've not had luck.

I keep my projects in D:\Source. I opened my command prompt and did git clone https://github.com/godotengine/godot.git

Get some coffee while the repo comes down.

Change into the Godot directory. Build Godot with scons platform=windows.

Wait.

You should see your executables in "D:\Source\godot\bin". Try double clicking on the tools.64.exe if it's built. Fun, eh?

### Building The CPP Shared Library

Go back to your source folder. For me, that's "D:\Source". Now we'll clone godot-cpp so we can build our .lib file. git clone https://github.com/GodotNativeTools/godot-cpp

We're going to edit the SConstruct file.

I set my "godot_headers_path" to godot_headers_path = ARGUMENTS.get("headers", os.getenv("GODOT_HEADERS", "D:\\Source\\godot\\modules\\gdnative\\include"))

Note that it might be necessary to use double backslashes because Windows uses the wrong slash direction for their paths. Note that godot_headers_path points into the Godot build we cloned and into the GDNative module's include folder.

Update the "godot_bin_path" to point to our executable. godot_bin_path = ARGUMENTS.get("godotbinpath", os.getenv("GODOT_BIN_PATH", "D:\\Source\\godot\\bin\\godot.windows.tools.64.exe"))

Invoke scons platform=windows generate-headers=yes.

There will be a short span while the lib is created. When it's all done, check your bin folder. You should see "godot_cpp_bindings.lib".

#### CHECKPOINT: You've got the godot_cpp_bindings library built

Make a new folder. I put it in my project directory, "D:\Source\Terminus\CPU_v1\". CPU_v1 will be my native module. My game involves doing some CPU emulation.

Into that directory, copy D:\Source\godot-cpp\include. Also make a folder called 'lib' and put "godot_cpp_bindings.lib" in it.

Your directory structure should look like this:

D:\Source\TerminusExperiment\CPU_v1
- include
|- core
| |- AABB.hpp
| \- ...
|- AcceptDialog.hpp
|- AnimatedSprite.hpp
\- ...
- lib
\- godot_cpp_bindings.lib
- src
\- init.cpp (THIS IS YOUR CPP FILE!  Get a sample one from [x].)


Finally, we can build our CPP file using this command in the root of CPU_v1: cl /Fosrc\init.obj /c src\init.cpp /TP /nologo -EHsc -D_DEBUG /MDd /I. /Iinclude /Iinclude\core /ID:\Source\godot\modules\gdnative\include

Make a good note of those trailing '/I's. The specify the include folders. If you get a message about "Missing whatever.h" then you've got one wrong.

/Fosrc\init.obj specifies the output object. /c src\init.cpp specifies our source file.

#### CHECKPOINT: We have our .obj file from our init.cpp!

Last step, we can link our two objects together. cl /LD lib\godot_cpp_bindings.lib src\init.obj /link /DLL /OUT:init.dll

This will take our lib and our source object and will produce init.dll -- something we can use in Godot's Native library.

Shout out to MathJax/ASCIIMath for being awesome.

### Motivation and Problem Statement

We're launching a ball with a great deal of force at a wall. We can describe our wall with four points in 3D space: a = [x, y, z], b = [x, y, z], and so on for c and d. Our ball travels along a straight line path called bbL. It's origin is p_0 and it's moving towards p_1.

There is some redundancy. I picked four points for our wall because it makes intuitive sense, but we're going to be applying this method on only three of those four points, the triangle Delta abc. If you feel the compulsion to run this on a square, you can easily extend the approach to two triangles.

Let's begin with describing our plane. There are a few different formulations of the plane in 3D. For our purposes, the 'normal + offset' configuration is the easiest. We'll figure out the normal (think a straight line pointing out of the wall) from our three points.

### A quick review of dot and cross

I'm going to assume that the idea of cross-product and dot product are familiar, but here's a very quick review in the interest of completeness.

a = (x, y, z)
b = (x, y, z)

a o. b = a_x * b_x + a_y * b_y + a_z * b_z

a ox b = [[a_y*b_z - a_z*b_y], [a_x*b_z - a_z*b_x], [a_x*b_y - a_y*b_x]]

Note that the dot product is a scalar and the cross product is a vector.

One other thing to realize: the dot product of orthogonal vectors is zero. The cross product of two vectors produces a vector that's orthogonal to both. If that's not clear, don't worry.

### The Normal

Let's get back to the wall. We've got a, b, and c and we want to figure out the normal. If these three points make up an infinite plane, then the normal will jut out of it straight towards us. Recall (or look at the notes above) that the cross product of two vectors makes an orthogonal vector. We can convert our three points to two vectors by picking one to be the start. Let's say our two new vectors are r = b-a and s = c-a. That means our normal, bbN is just r ox s! And since we picked a as our origin, our formula for the plane is (P - a) o. bbN = 0 for some point P. Put differently, if we have some point P and it's on the plane, when we plug it into that formula along with a and bbN we'll get zero.

### Enter: The Line

We mentioned before that our line bbL has a start point of p_0 and an end of p_1. This means if a point P is on the line, then there's some value t where P = p_0 + t*(p_1 - p_0). Now comes the fun part. We want to figure out where this line intersects with our plane (if it does). To do that, we'll plug in the formula for a point on our line into the formula for a point on our plane.

(P - a) o. bbN = 0 // Point on plane.
(((p_0 + t*(p_1 - p_0)) - a) o. bbN = 0 // Replace P with the formula.
(((p_0 + t*(p_1 - p_0)) o. bbN - a o. bbN = 0 // Distribute the dot.
(((p_0 + t*(p_1 - p_0)) o. bbN = a o. bbN // Add a o. bbN to both sides, effectively moving it to the right.
p_0 o. bbN + t*(p_1 - p_0) o. bbN = a o. bbN // Distribute again.
t*(p_1 - p_0) o. bbN = a o. bbN - p_0 o. bbN // Subtract p_0 o. bbN from both sides.
t*(p_1 - p_0) o. bbN = (a - p_0) o. bbN // Pull out the dot product.
t = ((a - p_0) o. bbN) / ((p_1 - p_0) o. bbN) // Divide by (p_1 - p_0) o. bbN on both sides.

t = (bbN o. (a - p_0))/(bbN o. (p_1 - p_0))

If the denominator is zero, there's no solution. This can happen if the plane and line segment are perpendicular. Otherwise, we can plug t back into our line equation to get some point on the plane!

### Inside the Triangle

We have a point P that's on the plane and the line, but is it inside the triangle defined by Deltaabc? There's a fairly easy way to check for that. If you've got a triangle, as we have, then any point in that triangle can be described as some combination of a + u*(b-a) + v*(c-a), where u and v are in the interval [0,1]. If u or v is less than zero, it means they're outside the triangle. If they're greater than one, it means they're outside the triangle. If their sum is greater than one, it means they're outside, too. So we just have to find some u and v for P = a + u*(b-a) + v*(c-a).

### Systems of Equations

It might not seem possible. We have two unknowns and only one equation. However, there's something we've overlooked. P = a + u*(b-a) + v*(c-a) actually has three equations. We've been using a shorthand for our points, but u and v are scalars. Really, we should be looking for a solution for this:

P = a + u*(b-a) + v*(c-a)

P - a = u*(b-a) + v*(c-a)

[[b_x - a_x, c_x - a_x], [b_y - a_y, c_y - a_y], [b_z - a_z, c_z - a_z]] * [[u],[v]] = [[P_x - a_x], [P_y - a_y], [P_z - a_z]]

BAM! Two unknowns, three equations. You might also recognize this to be of the form bbAx=b. You'd be correct. If there were three unknowns and three equations, we could have been fancy and used Cramer's Rule. It's not a hard thing to solve, however.

bbbAx = b
bbbA^TbbbAx = bbbA^Tb // Start by making bbbA a square matrix.
(bbbA^TbbbA)^-1 bbbA^TbbbA x = (bbbA^TbbbA)^-1 bbbA^T b // Since it's square, it probably has an inverse.
bbbI x = (bbbA^TbbbA)^-1 bbbA^T b // Cancel the inverse.
x = (bbbA^TbbbA)^-1 bbbA^T b // Simplify.

And now we've got x in terms that we know (or can calculate)!

### Inverse of a Square Matrix

(bbbA^TbbbA)^-1 looks like a mess, but it's not as bad as it seems. I'm going to multiply it out and simplify it again.

bbbA^T bbbA = [[b_x - a_x, b_y - a_y, b_z - a_z],[c_x - a_x, c_y - a_y, c_z - a_z]] * [[b_x - a_x, c_x - a_x], [b_y - a_y, c_y - a_y], [b_z - a_z, c_z - a_z]] =  an unholy mess.
To cut down on that, I'm going to let b-a = r and c-a = s. If we rewrite the above using that, we get something more manageable.

bbbA^T bbbA = [[r_x, r_y, r_z],[s_x, s_y, s_z]] * [[r_x, s_x], [r_y, s_y], [r_z, s_z]]

Since we're basically multiplying things component wise, we can reuse our code for dot product!

bbbA^T bbbA = [[r o. r, r o. s], [r o. s, s o. s]]

That's an easy to calculate 2x2 matrix. As an added bonus, there's a closed-form solution for the inverse of a 2D matrix. You can probably work it out yourself easily enough, but we've gone through a lot already, so here's the solution:

if bbbA = [[a, b], [c, d]] => bbbA^-1 = 1/(ad-bc) [[d, -b], [-c, a]]

So we calculate r o. r, r o. s, and s o. s and plug them into the inverse matrix. Then we multiply the inverse and bbbA^Tb et voila: we've got our values for u and v.

bbbA^T bbbA = [[r o. r, r o. s], [r o. s, s o. s]]

I'm running out of letters!

alpha = r o. r
beta = r o. s
gamma = r o. s
delta = s o. s

(bbbA^T bbbA)^-1 = 1/(alpha * delta- beta * gamma) * [[delta, -(beta)], [-(gamma), alpha]]

And in all its glory:

(bbbA^T bbbA)^-1 bbbA^T b = 1/(alpha * delta - beta * gamma) * [[delta, -(beta)], [-(gamma), alpha]] * [[r_x, r_y, r_z],[s_x, s_y, s_z]] * [[P_x - a_x], [P_y - a_y], [P_z - a_z]] = [[u],[v]]

Whew.

### Closing: Just Show Me The Code

The moment for which you've been waiting. Here's an EMScript6 implementation of the Point and Triangle objects.

A Gist is available on GitHub at https://gist.github.com/JosephCatrambone/578c22f6e507dc52420752013a45b92b.js or you can play with this interactively on JSFiddle: