Add test harness and payoff display + calculation.

Author: alecpm

acsg.js

@@ -1,3 +1,6 @@
+/* jshint esversion: 6, asi: true */
+/* globals require */
+
 var util = require('util')
 var css = require('dom-css')
 var fs = require('fs')
@@ -43,6 +46,20 @@ function filenameFrom(data) {
   return experimentID + '-decompressed.json'
 }
 
+function sum(vector) {
+  return vector.reduce(( accumulator, currentValue ) => accumulator + currentValue, 0);
+}
+
+function softmax(vector, temperature=1){
+  /* The softmax activation function. */
+  var new_vector = vector.map(x => Math.pow(x, temperature));
+  if (sum(new_vector)) {
+      return new_vector.map(x => x / sum(new_vector));
+  } else {
+      return new_vector.map(_ => vector.length);
+  }
+}
+
 var acsg = {}  // Module namespace
 
 acsg.Browser = (function () {
@@ -56,6 +73,7 @@ acsg.Browser = (function () {
       var backgroundRngFunc = seedrandom(this.now())
       this.rBackground = new Rands(backgroundRngFunc)
       this.scoreboard = document.getElementById('score')
+      this.bonus = document.getElementById('dollars')
       this.clock = document.getElementById('clock')
       this.data = []
       this.background = []
@@ -87,8 +105,9 @@ acsg.Browser = (function () {
     return performance.now()
   }
 
-  Browser.prototype.updateScoreboard = function (score) {
-    this.scoreboard.innerHTML = score
+  Browser.prototype.updateScoreboard = function (ego) {
+    this.scoreboard.innerHTML = ego.score
+    this.bonus.innerHTML = ego.payoff.toFixed(2)
   }
 
   Browser.prototype.updateClock = function (t) {
@@ -229,7 +248,7 @@ acsg.CLI = (function () {
     // Noop
   }
 
-  CLI.prototype.updateScoreboard = function (score) {
+  CLI.prototype.updateScoreboard = function (ego) {
     // Noop
   }
 
@@ -409,6 +428,7 @@ acsg.Player = (function () {
     this.teamIdx = Math.floor(Math.random() * teamColors.length)
     this.color = config.color || teamColors[this.teamIdx]
     this.score = config.score || 0
+    this.payoff = 0
 
     return this
   }
@@ -557,6 +577,9 @@ acsg.Game = (function () {
       this.opts.BLOCK_SIZE = opts.BLOCK_SIZE || 15
       this.opts.BLOCK_PADDING = opts.BLOCK_PADDING || 1
       this.opts.BOT_STRATEGY = opts.BOT_STRATEGY || 'random'
+      this.opts.INTERGROUP_COMPETITION = opts.INTERGROUP_COMPETITION || 1
+      this.opts.INTRAGROUP_COMPETITION = opts.INTRAGROUP_COMPETITION || 1
+      this.opts.DOLLARS_PER_POINT = opts.DOLLARS_PER_POINT || 0.02
       this.UUID = uuidv4()
       this.replay = false
       this.humanActions = []
@@ -604,14 +627,19 @@ acsg.Game = (function () {
   }
 
   Game.prototype.serializeActions = function () {
-    return JSON.stringify({
+    var data = {
       'id': this.UUID,
       'data': {
         'actions': this.humanActions,
         'timestamps': this.humanActionTimestamps
       },
       'config': opts
-    })
+    }
+    if (this.opts.INCLUDE_HUMAN && this.world.players && this.world.players[0]) {
+      data.data.score = this.world.players[0].score
+      data.data.payoff = this.world.players[0].payoff.toFixed(2)
+    }
+    return JSON.stringify(data)
   }
 
   Game.prototype.serializeFullState = function () {
@@ -665,6 +693,58 @@ acsg.Game = (function () {
     }
   }
 
+  Game.prototype.computePayoffs = function () {
+    /* Compute payoffs from scores.
+
+    A player's payoff in the game can be expressed as the product of four
+    factors: the grand total number of points earned by all players, the
+    (softmax) proportion of the total points earned by the player's group,
+    the (softmax) proportion of the group's points earned by the player,
+    and the number of dollars per point.
+
+    Softmaxing the two proportions implements intragroup and intergroup
+    competition. When the parameters are 1, payoff is proportional to what
+    was scored and so there is no extrinsic competition. Increasing the
+    temperature introduces competition. For example, at 2, a pair of groups
+    that score in a 2:1 ratio will get payoff in a 4:1 ratio, and therefore
+    it pays to be in the highest-scoring group. The same logic applies to
+    intragroup competition: when the temperature is 2, a pair of players
+    within a group that score in a 2:1 ratio will get payoff in a 4:1
+    ratio, and therefore it pays to be a group's highest-scoring member. */
+    var group_info, group_scores, ingroup_players,
+        ingroup_scores, intra_proportions, inter_proportions,
+        p, i;
+    var player_groups = {}
+    var total_payoff = 0
+    var player = this.world.players[0]
+
+    for (i = 0; i < this.world.players.length; i++) {
+      p = this.world.players[i]
+      group_info = player_groups[p.teamIdx]
+      if (group_info === undefined) {
+        player_groups[p.teamIdx] = group_info = {players: [], scores: [], total: 0}
+      }
+      group_info.players.push(p)
+      group_info.scores.push(p.score)
+      group_info.total += p.score
+      total_payoff += p.score
+    }
+    group_scores = Object.values(player_groups).map(g => g.total);
+    group_info = player_groups[player.teamIdx];
+    ingroup_players = group_info.players
+    ingroup_scores = group_info.scores
+    intra_proportions = softmax(
+      ingroup_scores, this.opts.INTRAGROUP_COMPETITION
+    );
+    player.payoff = total_payoff * intra_proportions[0]
+
+    inter_proportions = softmax(
+        group_scores, this.opts.INTERGROUP_COMPETITION
+    );
+    player.payoff *= inter_proportions[player.teamIdx]
+    player.payoff *= this.opts.DOLLARS_PER_POINT
+  }
+
   Game.prototype.run = function (callback) {
     var self = this
     var callback = callback || function () { console.log('Game finished.') }
@@ -701,14 +781,17 @@ acsg.Game = (function () {
           // Carry out human action.
           lastHumanActionIdx += 1
           ego.move(self.humanActions[lastHumanActionIdx])
-          self.ui.updateScoreboard(ego.consume())
+          ego.consume()
+          self.ui.updateScoreboard(ego)
           self.world.recordStateAt(nextHumanT)
         }
+        self.computePayoffs()
       }
 
       self.ui.updateGrid(self.world)
       self.ui.updateClock(self.opts.DURATION - elapsedTime)
 
+      self.computePayoffs()
       if (lastBotActionIdx >= botMotion.botIds.length - 1) {
         if (!self.gameOver) {
           self.gameOver = true

acsg.test.js

@@ -0,0 +1,139 @@
+/* jshint esversion: 6 */
+/* globals require,test,expect,afterEach,beforeEach,jest,console */
+
+const rewire = require('rewire');
+const acsg = require('./acsg');
+// Access private functions for unit tests
+const acsgRewire = rewire('./acsg');
+var outputData = '';
+var storeLog = inputs => (outputData += inputs);
+console.log = jest.fn(storeLog);
+
+// Random seed
+beforeEach(() => {
+  outputData = '';
+});
+
+// Generate basic world
+function init_game(config) {
+  var game_config = {SEED: 2, INCLUDE_HUMAN: true, IS_CLI: true};
+  Object.assign(game_config, config);
+  var game = acsg.Game({config: game_config});
+  return game;
+}
+
+test('sum function', () => {
+  var sum = acsgRewire.__get__('sum');
+  expect(sum([1, 2, 3])).toEqual(6);
+  expect(sum([8, 9, 10])).toEqual(27);
+  expect(sum([])).toEqual(0);
+});
+
+test('softmax function', () => {
+  const softmax = acsgRewire.__get__('softmax');
+  expect(softmax([1, 2, 3])).toEqual([1/6, 1/3, 1/2]);
+  expect(softmax([0, 0, 0])).toEqual([3, 3, 3]);
+  expect(softmax([1, 2, 3], 2)).toEqual([1/14, 2/7, 9/14]);
+});
+
+test('player move changes position', () => {
+  var game = init_game();
+  // Create a player
+  var player = game.world.players[0];
+  // initial position is random, but deterministic based on seed
+  expect(player.position).toEqual([9, 15]);
+  // move() returns direction
+  expect(player.move('up')).toEqual('up');
+  expect(player.position).toEqual([8, 15]);
+  player.move('down');
+  expect(player.position).toEqual([9, 15]);
+  player.move('left');
+  expect(player.position).toEqual([9, 14]);
+  player.move('right');
+  expect(player.position).toEqual([9, 15]);
+  // Nonsense directions are logged, and do nothing;
+  player.move('nonsense');
+  expect(outputData).toEqual('Direction not recognized.');
+  expect(player.position).toEqual([9, 15]);
+});
+
+test('calculate straight payoff', () => {
+  var game = init_game({
+    NUM_PLAYERS: 2,
+    DOLLARS_PER_POINT: 0.05
+  });
+  var player = game.world.players[0];
+  // Payoff is a simple multiple of our score
+  player.score = 10;
+  expect(player.payoff).toEqual(0);
+  game.computePayoffs();
+  expect(player.payoff).toEqual(0.5);
+  player.score = 20;
+  game.computePayoffs();
+  expect(player.payoff).toEqual(1);
+  player.score = 0;
+  game.computePayoffs();
+  expect(player.payoff).toEqual(0);
+  // Other player scores don't matter
+  player.score = 20;
+  game.world.players[1].score = 50;
+  game.computePayoffs();
+  expect(player.payoff).toEqual(1);
+
+});
+
+test('calculate intragroup payoff', () => {
+  var game = init_game({
+    NUM_PLAYERS: 2,
+    DOLLARS_PER_POINT: 0.05,
+    INTRAGROUP_COMPETITION: 2
+  });
+  var player = game.world.players[0];
+  var bot1 = game.world.players[1];
+  expect(player.teamIdx).toEqual(0);
+  expect(bot1.teamIdx).toEqual(0);
+  // We get all the payoff if we get all the points
+  player.score = 20;
+  bot1.score = 0;
+  game.computePayoffs();
+  expect(player.payoff).toEqual(1);
+  // We get a payoff based on our portion of the in-group total
+  bot1.score = 10;
+  game.computePayoffs();
+  expect(player.payoff).toEqual(30 * 4/5 * 0.05);
+});
+
+test('calculate intergroup payoff', () => {
+  var game = init_game({
+    NUM_PLAYERS: 4,
+    DOLLARS_PER_POINT: 0.1,
+    INTERGROUP_COMPETITION: 2
+  });
+  var player = game.world.players[0];
+  var bot1 = game.world.players[1];
+  var bot2 = game.world.players[2];
+  var bot3 = game.world.players[3];
+  expect(player.teamIdx).toEqual(0);
+  expect(bot1.teamIdx).toEqual(0);
+  expect(bot2.teamIdx).toEqual(1);
+  expect(bot3.teamIdx).toEqual(1);
+  // Point distribution between groups determines payoff
+  player.score = 20;
+  bot1.score = 0;
+  bot2.score = 20;
+  bot3.score = 40;
+  game.computePayoffs();
+  expect(player.payoff).toEqual(80 * 1/10 * 0.1);
+  // Point distribution within our group changes the payoff
+  player.score = 10;
+  bot1.score = 10;
+  game.computePayoffs();
+  expect(player.payoff).toEqual(80 * 1/10 * 0.1 * 0.5);
+  // Point distribution in the out-group has no impact
+  player.score = 20;
+  bot1.score = 0;
+  bot2.score = 10;
+  bot3.score = 50;
+  game.computePayoffs();
+  expect(player.payoff).toEqual(80 * 1/10 * 0.1);
+});