public override IPDGame.Choices Choice(IPDGame game)
{
lock (_choiceLock)
{
IPDGame.Choices pr;
int prt = game.T - 1;
if (_initialChoices.Count > 0)
{
return(_initialChoices.Dequeue());
}
else
{
pr = game.GetChoice(this, prt);
if (pr == IPDGame.Choices.C)
{
_totalCooperateScore += (int)game.GetPast(this, prt);
}
else
{
_totalDefectScore += (int)game.GetPast(this, prt);
}
if (_initialChoices.Count > 0)
{
return(_initialChoices.Dequeue());
}
else
{
return((_totalDefectScore > _totalCooperateScore) ? IPDGame.Choices.D : IPDGame.Choices.C);
}
}
}
}
public override IPDGame.Choices Choice(IPDGame game)
{
if (game.T == 0)
{
return(FIRST_CHOICE);
}
int i = 0;
for (int k = 1; k <= _phenome.InputSignalArray.Length / 2; k++)
{
IPDGame.Past p = game.GetPast(this, game.T - k);
//My choice (0 == C, 1 == D)
_phenome.InputSignalArray[i++] = (p == IPDGame.Past.R || p == IPDGame.Past.S) ? 0 : 1;
//Opponent choice
_phenome.InputSignalArray[i++] = (p == IPDGame.Past.T || p == IPDGame.Past.R) ? 0 : 1;
}
_phenome.Activate();
if (!_phenome.IsStateValid)
{ // Any black box that gets itself into an invalid state is unlikely to be
// any good, so lets just bail out here.
return(IPDGame.Choices.R);
}
return((_phenome.OutputSignalArray[0] > _phenome.OutputSignalArray[1]) ? IPDGame.Choices.C : IPDGame.Choices.D);
}
public override IPDGame.Choices Choice(IPDGame game)
{
lock (_choiceLock)
{
if (game.T == 0)
{
game.HasRandom = _hasRandom;
return(_start);
}
switch (game.GetPast(this, game.T - 1))
{
case IPDGame.Past.T:
return(CooperateProbability(_t));
case IPDGame.Past.R:
return(CooperateProbability(_r));
case IPDGame.Past.P:
return(CooperateProbability(_p));
case IPDGame.Past.S:
return(CooperateProbability(_s));
}
throw new Exception("How did we get here?");
}
}
public override int Evaluate(ref DecisionTree.Iterator iterator, IPDGame game)
{
if (_cond.Evaluate(iterator.Alpha, iterator.Beta))
{
iterator.Alpha += _alphaAdd;
return(_left);
}
else
{
iterator.Beta += _betaAdd;
return(_right);
}
}
public override IPDGame.Choices Choice(IPDGame game)
{
if (game.T == 0)
{
game.HasRandom = _hasRandom;
}
if (_iter >= _pattern.Length)
{
_iter = 0;
}
return(_pattern[_iter++]);
}
public override IPDGame.Choices Choice(IPDGame game)
{
lock (_choiceLock)
{
if (_initialChoices.Count > 0)
{
return(_initialChoices.Dequeue());
}
else
{
if (C_D_TFT == -1)
{
switch (_alternative)
{
case Probes.One:
default:
C_D_TFT = (C(game, 1) && C(game, 2)) ? 1 : 2; break;
case Probes.Two:
C_D_TFT = (!C(game, 1) && C(game, 2)) ? 0 : 2; break;
case Probes.Three:
C_D_TFT = (C(game, 1)) ? 1 : 2; break;
case Probes.Hard:
C_D_TFT = (C(game, 1) && C(game, 2)) ? 1 : 2; break;
}
}
if (C_D_TFT == 0)
{
return(IPDGame.Choices.C);
}
else if (C_D_TFT == 1)
{
return(IPDGame.Choices.D);
}
else
{
return(C(game, game.T - 1) ? IPDGame.Choices.C : IPDGame.Choices.D);
}
}
}
}
public override IPDGame.Choices Choice(IPDGame game)
{
lock (_choiceLock)
{
if (game.T == 0)
{
FillQueue(_initQ);
}
if (_q.Count == 0)
{
FillQueue(_tree.Run(game));
}
if (_q.Count == 0)
{
throw new Exception("Q is still empty?");
}
return(_q.Dequeue());
}
}
public override int Evaluate(ref DecisionTree.Iterator iterator, IPDGame game)
{
int t = game.T - _k - iterator.K;
if (t < 0)
{
return(DecisionTree.INVOKE_Q);
}
if (_x.Contains(game.GetPast(iterator.Player, t)))
{
iterator.Alpha += _alphaAdd;
return(_left);
}
else
{
iterator.Beta += _betaAdd;
return(_right);
}
}
public override IPDGame.Choices Choice(IPDGame game)
{
lock (_choiceLock)
{
if (_initialChoices.Count > 0)
{
return(_initialChoices.Dequeue());
}
else
{
if (game.GetPast(this, game.T - 1) == IPDGame.Past.S || game.GetPast(this, game.T - 1) == IPDGame.Past.P)
{
_totalPSScore++;
}
else
{
_totalTRScore++;
}
return((_totalPSScore >= _totalTRScore) ? IPDGame.Choices.D : IPDGame.Choices.C);
}
}
}
public IPDGame.Choices[] Run(IPDGame game)
{
int node = 0;
IPDGame.Choices[] result = null;
while (_tree.ContainsKey(node))
{
//Encountered a Assign Result node
if (_tree[node].HasResult)
{
result = _tree[node].Result.Evaluate(_iterator.Alpha, _iterator.Beta);
break;
}
node = _tree[node].Evaluate(ref _iterator, game); //Alpha, Beta are not changed if INVOKE_Q
//k - K < 0
if (node == INVOKE_Q)
{
result = _q.Evaluate(_iterator.Alpha, _iterator.Beta);
break;
}
}
if (result == null)
{
throw new System.Exception("Result returned a null value");
}
else if (result.Length == 0)
{
throw new System.Exception("Result returned an empty value");
}
else
{
return(result);
}
}
public virtual int Evaluate(ref DecisionTree.Iterator iterator, IPDGame game)
{
throw new Exception("This node has not implemented an Evaluate function.");
}
public override int Evaluate(ref DecisionTree.Iterator iterator, IPDGame game)
{
iterator.K++;
return(_jumpTo);
}
private bool C(IPDGame game, int time)
{
return(game.GetPast(this, time) == IPDGame.Past.R || game.GetPast(this, time) == IPDGame.Past.T);
}
