*"Do the cells only do whatever seems immediately most to their advantage (with a memory of the
previous turn), or do they employ strategies to encourage behaviour in their neighbours which is the
most likely to give satisfactory results (like TFT or Gradual)?"*

There is no such strategy involved. The behaviour of each individual cell is determined by its direct neighbours in each round. Note that every cell has 8 neighbours because the boundaries have been 'wrapped around' so the first row and the first column are bounded by the last in the 60*60 matrix. This is accomplished by the boundary array bc (n=60):

int[] setBoundary(int n) { int bc[] = new int[n+2]; for (int i=1; i<=n; i++) { bc[i]=i; } bc[0]=n; bc[n+1]=1; return bc; }

First the strategies (1 or 2) are determined randomly (using the p value from the input box) and stored in s (for all cells):

int[][] generate(int n, double p) { int s[][] = new int[n+1][n+1]; for (int i=1; i<=n; i++) { for (int j=1; j<=n; j++) { s[i][j] = 1; if (Math.random()<p) s[i][j] = 2; } } return s; }

Here is the payoff matrix:

pm[1][1]=1; pm[1][2]=0; pm[2][1]=b; pm[2][2]=0;

During each round the payoff is calculated for each individual cell (as a function of s and pm of course):

void calculate() { int i,j,k,l; double pa,hp; for (i=1; i<=n; i++) { for (j=1; j<=n; j++) { pa=0; for (k=-1; k<=1; k++) { for (l=-1; l<=1; l++) { pa += pm[s[i][j]][s[bc[i+k]][bc[j+l]]]; } } payoff[i][j] = pa; } }

Finally the new strategy sn is determined by the highest payoff hp:

for (i=1; i<=n; i++) { for (j=1; j<=n; j++) { hp = payoff[i][j]; sn[i][j] = s[i][j]; for (k=-1; k<=1; k++) { for (l=-1; l<=1; l++) { if (payoff[bc[i+k]][bc[j+l]] > hp) { hp = payoff[bc[i+k]][bc[j+l]]; sn[i][j] = s[bc[i+k]][bc[j+l]]; } } } } } }

*"What is 'delay'?"*

The delay just introduces a 'sleep', like this:

try {Thread.sleep(ap.delay);} catch(InterruptedException e){}

'Delay' can be increased if the applet runs too fast - f.i. some Java VM implementations cannot handle the multithreading used in this applet if the main thread isn't suspended by a certain delay (say 50 or 100 in the old Linux 'green thread' implementation).

1)*"I encountered a 'walking figure' with certain settings but i forgot to jot them down. have you
encountered this same phenomenon? If so, do you have the settings?"*

2)*"There's a marked bias for the lower-right corner -- when B=1.5, the result is a sort of
streaming pattern falling downward at 135° (with 12:00 being 0°, 135°~4:30 position), these
streams never go in any other direction. With B=2, there's a very distinct show of bias where the
resulting blocks of Red stream oscillating kite-tails to along the bottom left, bottom right, and upper
right corners -- again, they all point in the 4:30 direction."*

It has to do with undecidability: a decision is forced. The following pattern starts falling downward at 135° when b=1.5:

CCCCCCCCC CCCCCCCCC CCCCCCCCC CCCDDCCCC CCCCDDCCC CCCCCCCCC CCCCCCCCC CCCCCCCCC

These are the payoffs:

9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 8.0 7.0* 7.0 8.0 9.0 9.0 9.0 9.0 9.0 8.0 9.0 7.5 6.0 8.0 9.0 9.0 9.0 9.0 8.0 6.0 7.5 9.0 8.0 9.0 9.0 9.0 9.0 9.0 8.0 7.0 7.0# 8.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0

For both cells marked '*' and '#' the highest payoff is 9.0. Note that the evaluation starts in the upper left corner and ends in the lower right (135°):

for (i=1; i<n; i++) { for (j=1; j<n; j++) { hp = payoff[i][j]; sn[i][j] = s[i][j]; for (k=-1; k<1; k++) { for (l=-1; l<1; l++) { if (payoff[bc[i+k]][bc[j+l]] > hp) { hp = payoff[bc[i+k]][bc[j+l]]; sn[i][j] = s[bc[i+k]][bc[j+l]]; } } } } }

So if the 9.0 is encountered first, for '*' this is a cooperator's payoff while for '#' it is a defector's payoff:

9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 C9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 8.0 7.0* 7.0 8.0 9.0 9.0 9.0 9.0 9.0 8.0 9.0 7.5 6.0 8.0 9.0 9.0 9.0 9.0 8.0 6.0 7.5 D9.0 8.0 9.0 9.0 9.0 9.0 9.0 8.0 7.0 7.0# 8.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0

The highest payoff (hp) will be overruled only if a higher payoff ( > 9.0 ) is encountered during the evaluation loop, which is obviously not being the case. The new payoffs will be:

9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 8.0 7.0 7.0 8.0 9.0 9.0 9.0 9.0 9.0 7.0 7.5 6.0 6.0 8.0 9.0 9.0 9.0 9.0 7.0 6.0 3.0 4.5 6.0 8.0 9.0 9.0 9.0 8.0 6.0 6.0 6.0 9.0 8.0 9.0 9.0 9.0 9.0 8.0 7.0 6.0 7.0 8.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0 9.0

As you can see, the pattern starts tumbling down.