Tag: Stupid programmer tricks

Missed a week, due to life and commitments, so this is a double week, with a blob of promised telemetry source-code.

Story-compiler

The Story-Compiler is a nineteen-pass tangle. Basically, any time I need it to do more, and whatever-it-is doesn’t cleanly fit into any of the existing passes, I just add another pass.

This leads to some interesting precedence-of-operations issues. This pass should happen before these other passes, but… oh, it relies on this other pass to go earlier.

That may need a tidy up. Also, now that I’m expanding and replicating parts of the source on its way through the story-compiler, I’m pretty sure the way I’ve been tracking the start/end positions of scenes in the intermediate data-structures is starting to drift.

Not enough to break anything just yet, but I’m sure it will, as the compiler uses a lot of per-scene data. In short, I need either a better way of tracking which line of the intermediate story-data belongs to which scene, or a better way of inserting/deleting lines of the intermediate story-data.

The engine itself has no such troubles, being that it breaks everything out of the final compiled story into separated scenes and performances. I suppose I could actually tear the intermediate data into parts, and reassemble later, but that would make some tasks harder, rather than easier.

I think, for now, better tagging of intermediate lines is probably the way to go. Probably.

Syntax

I’m slowly replacing some of my original syntactical constructs with newer things. Actually, in the compiled story file, things are still pretty much the same, but I’m using the compiler phase to allow for a more sensible syntax for what were previously some historically awkward constructs.

The idea is to make everything a whole lot simpler. Here’s an example:

Scene 115
Meta
 Summary: Alice and Bob give either Christine or Danielle (whoever it worked out to in scene 100) a lift to the next town.
 Arc:The Mysterious Hitchhiker
 Follows:100
 Precedes:130
Roles
 Copyfrom:100
 // Set up aliases for cast we copied from scene 100
 alias:1:driver
 alias:2:passenger
 alias:3:hitcher
 role:4:name=Craybourne [alice]
 role:5:name=Drayper [bob]
Requirements
 None
Performance
{
passenger,hitcher:{Name:[driver]} put the car in gear, flipped on the indicators, and checked {herhis:[driver]} mirrors. {?role:[driver]:Drayper|He nervously glanced this way and that before finally pulling awkwardly out onto the road|There was only a moment's pause before she pulled the car smoothly onto the highway, and accelerated}.
...
}

Trust me, that’s a whole lot nicer.

Story

Work’s coming along well on the next stage of the story. It requires some parallel tech that I’m throwing together on-the-fly, as I need it. It’s slow, but steady, and there’s another big plot-twist, besides.

The nature of that twist is something I want to revisit before it is set in stone. Does it need a trigger warning? Does it go farther than I’m comfortable with for the overall tone of the story?

Possibly.

This actually gives me two options.

I could either make some adjustments to the scene so that it is a good deal less whatever-it-is (trying not to be spoilery is hard!). Or, I could do that and present it as an optional form of the story. Maybe stick some trigger-warnings on the options screen, and eliminate/vary characters or a couple narrative elements based on what you choose not to see.

The second one sounds more complicated, so I’ll probably end up at least writing the code for it eventually, even if I don’t take advantage of it myself.

For now, I might archive the problematic bit of narrative, and tweak it. I’ve got a softer version that should still fit the bill narratively.

Game Telemetry

At the IGDAM get-together last week (one of the life bits that ironically got in the way of getting the devblog done), I promised to post my telemetry code. Telemetry in your alphas/alpha-demos is important, I think. That’s around the time you want more data about how people actually are playing your game, but as an Indie, you can’t exactly afford any kind of structured playtest – but as long as you have a cheapie web-host that you can drop a script on, you can get game-telemetry, and thus feedback that will help inform your design and polish decisions.

The code here isn’t particularly arcane, and should build under both Visual Studio on Windows and G++ on Linux. Basically, if you know C++, then there’s nothing terribly difficult in this.

Telemetry.h:

#if ENABLE_TELEMETRY
#include <deque>
#include <string>
#include <clocale>
#include <locale>
#include <codecvt>
#include "SDL.h"
#ifdef _WIN32
#include "windows.h"
#else
typedef uint32_t Uint32;
#endif

class TelemetryEvent
{
public:
 typedef enum { none = 0, startup = 1, shutdown, like, dislike, loadstart, loadend, savestart, saveend, characterpick, footnote, loaderror, runtimerror, titlescreen,choice } code_t;
 TelemetryEvent(code_t n) { eventcode = n; timestamp = SDL_GetTicks(); }
 TelemetryEvent(code_t n, const std::wstring &str) { eventcode = n; timestamp = SDL_GetTicks(); data = str; }
 ~TelemetryEvent() = default;
 code_t eventcode = none;
 Uint32 timestamp = 0;
 std::wstring data;

 std::string to_string()
 {
 std::string result;

 result += std::to_string(eventcode);
 result += ",";
 result += std::to_string(timestamp);
 result += ",";
 std::string tmp(data.begin(), data.end());
 result += tmp;
 return result;
 }
};

class AppTelemetry
{
private:
 bool WS_init = false;
 std::deque<TelemetryEvent> events;
 void Transmit();
 bool enabled = true;
public:
 AppTelemetry();
 ~AppTelemetry();
 void SendEvent(const TelemetryEvent& te);
 void Poll();
 void Flush() { if (!enabled) return; while (events.size()) Poll(); }
 void Enable(bool b) { enabled = b; }
};

extern AppTelemetry TelemetryObject;

#endif

Telemetry.cpp:

#if ENABLE_TELEMETRY
#include "Telemetry.h"

#include <iostream>
#include <thread>
#include "EngineIO.h"
#ifdef _WIN32
#include "Winsock.h"
#pragma comment(lib,"ws2_32.lib")
#else
#include <arpa/inet.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <netinet/in.h>

typedef uint32_t Uint32;
typedef int SOCKET;
typedef sockaddr_in SOCKADDR_IN;
typedef sockaddr SOCKADDR;
static const SOCKET INVALID_SOCKET=-1;

void closesocket(SOCKET s)
{
 close(s);
}

#endif



AppTelemetry TelemetryObject;

#define TELEMETRY_HOST "www.example.com"
#define TELEMETRY_HEADER "GET /telemetryscript.py HTTP.1.1\nHost: " TELEMETRY_HOST "\nX-Xtelemetry: "
#define TELEMETRY_PORT 80

AppTelemetry::AppTelemetry()
{
#ifdef _WIN32
 WSADATA WsaDat;
 if (WSAStartup(MAKEWORD(2, 2), &WsaDat) != 0)
 { // failed

 }
 else
#endif
 WS_init = true;

}

AppTelemetry::~AppTelemetry()
{
#ifdef _WIN32
 if(WS_init)
 WSACleanup();
#endif
 WS_init = false;
}

void AppTelemetry::SendEvent(const TelemetryEvent& te)
{
 if (!enabled)
 return;
 events.push_back(te);
}

void AppTelemetry::Transmit()
{
 if (!enabled)
 return;
 if (events.size() == 0)
 return; // No work to do
 // Get the first event from the queue
 TelemetryEvent te(events.front());
 events.pop_front(); // And remove it from the queue

 SOCKET Socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 if (Socket == INVALID_SOCKET)
 return; // Nuts. Can't create the socket
 struct hostent *host;
 if ((host = gethostbyname(TELEMETRY_HOST)) == NULL)
 {
 closesocket(Socket);
 return; // Can't look up the name.
 }
 SOCKADDR_IN SockAddr;
 SockAddr.sin_port = htons(TELEMETRY_PORT);
 SockAddr.sin_family = AF_INET;
 SockAddr.sin_addr.s_addr = *((unsigned long*)host->h_addr);

 // Attempt to connect to server
#ifdef _WIN32
 // The Windows version of this function returns SOCKET_ERROR on failure.
 if (connect(Socket, (SOCKADDR*)(&SockAddr), sizeof(SockAddr)) == SOCKET_ERROR)
 {
 Output(DEBUGGING, "Winsock connect error "+std::to_string(WSAGetLastError()));
 closesocket(Socket);
 return; // Connection failed
 }
#else
 // Linux returns 0 on success
 if (connect(Socket, (SOCKADDR*)(&SockAddr), sizeof(SockAddr)) != 0)
 {
 closesocket(Socket);
 return; // Connection failed
 }
#endif

 // TODO: Send the data here.
 
 send(Socket, TELEMETRY_HEADER, (int)strlen(TELEMETRY_HEADER), 0);
 auto msg = te.to_string();
 send(Socket, msg.c_str(), (int)msg.length(),0);
 send(Socket, "\n\n", 2,0);

 // Shutdown our socket
 shutdown(Socket, 1);

 // Close our socket entirely
 closesocket(Socket);
}
void AppTelemetry::Poll()
{
 if (events.size())
 Transmit();
}



#endif

telemetryscript.py: (Sorry about the way indenting got eaten up here, but you can figure it out)

#!/usr/bin/python

import os
import codecs
import time

class FileLock:
 def __init__(self, filename):
 self.filename = filename
 self.fd = None
 self.pid = os.getpid()

 def acquire(self):
 try:
 self.fd = os.open(self.filename, os.O_CREAT|os.O_EXCL|os.O_RDWR)
 # Only needed to let readers know who's locked the file
 os.write(self.fd, "%d" % self.pid)
 return 1 # return ints so this can be used in older Pythons
 except OSError:
 self.fd = None
 return 0

 def release(self):
 if not self.fd:
 return 0
 try:
 os.close(self.fd)
 os.remove(self.filename)
 return 1
 except OSError:
 return 0

 def __del__(self):
 self.release()

def storetelemetry(ip,tel):
 f = codecs.open('/home/whatever/data/dtelemetry.txt', 'a','utf-8-sig')
 f.write(ip)
 f.write(':')
 f.write(tel);
 f.write('\n');
 f.close()

print "Content-Type: text/plain\n\n"
remote_ip=os.environ['REMOTE_ADDR']
telemetry=os.environ['HTTP_X_XTELEMETRY']
lock=FileLock('/home/whatever/data/lock000')
while not lock.acquire():
 time.sleep(1)
storetelemetry(remote_ip,telemetry)
lock.release()

I call it like this:

#if ENABLE_TELEMETRY
 TelemetryObject.SendEvent({ TelemetryEvent::characterpick,selected_character }); // send chosen character name.
#endif

Call TelemetryObject.Poll() in your mainloop somewhere, and TelemetryObject.Flush() before you exit, to make sure any telemetry messages have been sent.

The resulting file on your web-host (dtelemetry.txt) should be simple enough to parse and extract useful data from. It has a millisecond timestamp for each event, an event-code and whatever optional extra data gets sent along.

Caveat: The whole thing is single-threaded, so the act of generating an event can stall your game. You want to tweak it to run in a thread? Go for it. Just watch out, because I’m pretty sure that under Windows, your Winsock code needs to be initialised in the same thread that calls on it. The Linux code should be gold.