public BoardPosition TakeTurn(IPlayerBoard board)
{
return(new BoardPosition(
randomGenerator.Next(3),
randomGenerator.Next(3)
));
}
private int ChooseBestStrategyValue(IPlayerBoard board)
{
var freeFields = board.GetFieldsByColor(FieldColor.White);
double maxStrategyValue = 0;
var chosenFieldValues = new List <int>();
foreach (var field in freeFields)
{
double off = GetOffensiveValue(field);
double def = GetDefensiveValue(field);
double strategyValue = GetOffensiveValue(field) * this.OffensiveFactor + GetDefensiveValue(field) * this.DefensiveFactor;
if (strategyValue > maxStrategyValue)
{
maxStrategyValue = strategyValue;
chosenFieldValues.Clear();
chosenFieldValues.Add(field.Value);
}
else if (strategyValue == maxStrategyValue)
{
chosenFieldValues.Add(field.Value);
}
}
return(chosenFieldValues[random.Next(chosenFieldValues.Count)]);
}
public override void InitializeGame(IPlayerBoard board, int size, int targetLength)
{
this.Size = size;
this.TargetLength = targetLength;
this.allSequences = APFinder.FindAllSequences(board, targetLength, size).ToList();
this.myAvailableSequences = this.allSequences.ToList();
this.opponentAvailableSequences = this.allSequences.ToList();
}
public ActionManager(IPlayerBoard board)
{
actionsStrategies = new Dictionary <ActionType, IAction>();
actionsStrategies.Add(ActionType.MOVE, new MoveAction(this));
actionsStrategies.Add(ActionType.LEFT, new LeftAction(this));
actionsStrategies.Add(ActionType.RIGHT, new RightAction(this));
Board = board;
}
public override int SelectFieldValue(IPlayerBoard board)
{
var emptyFields = board.GetEmptyFields().ToList();
var ind = rng.Next(emptyFields.Count);
if (!withComputer)
{
this.Sleep();
}
return(emptyFields[ind].Value);
}
public override int SelectFieldValue(IPlayerBoard board)
{
Console.WriteLine("Wybierz pole: ");
string selectedValue = Console.ReadLine();
if (int.TryParse(selectedValue, out int res))
{
return(res);
}
return(-1);
}
public BoardPosition TakeTurn(IPlayerBoard board)
{
// let's see if anyone's played at 0,0...
if (board.TokenAt(BoardPosition.At(0, 0)) == PlayerToken.None)
{
// No? Sweet! Let's play there.
return(BoardPosition.At(0, 0));
}
// Sod it, I'm going to play there anyway..
return(BoardPosition.At(0, 0));
}
public BoardPosition TakeTurn(IPlayerBoard board)
{
switch (randomGenerator.Next(3))
{
case 0: return(new BoardPosition(randomGenerator.Next(int.MinValue, int.MaxValue), randomGenerator.Next(int.MinValue, int.MaxValue)));
case 1: while (true)
{
}
;
case 2: throw new Exception("Random error!");
}
return(new BoardPosition(0, 0));
}
public override int SelectFieldValue(IPlayerBoard board)
{
myAvailableSequences.RemoveAll(seq => seq.Exists(field => field.FieldColor == this.OpponentColor));
int chosenValue = -1;
var winningSequence = myAvailableSequences.Find(sequence => sequence.FindAll(field => field.FieldColor == FieldColor.White).Count == 1);
if (winningSequence != null)
{
chosenValue = winningSequence.Find(field => field.FieldColor == FieldColor.White).Value;
}
if (chosenValue < 0)
{
var opponentWinningSequence = opponentAvailableSequences.Find(sequence => sequence.FindAll(field => field.FieldColor == FieldColor.White).Count == 1);
if (opponentWinningSequence != null)
{
chosenValue = opponentWinningSequence.Find(field => field.FieldColor == FieldColor.White).Value;
}
}
if (chosenValue < 0)
{
var promisingSequence = myAvailableSequences.Find(sequence => sequence.FindAll(field => field.FieldColor == FieldColor.White).Count == 2);
if (promisingSequence != null)
{
chosenValue = promisingSequence.FindAll(field => field.FieldColor == FieldColor.White).Select(field => field.Value).Min();
}
}
if (chosenValue < 0)
{
chosenValue = ChooseBestStrategyValue(board);
}
opponentAvailableSequences.RemoveAll(seq => seq.Exists(item => item.Value == chosenValue));
if (!withComputer)
{
this.Sleep();
}
return(chosenValue);
}
public BoardPosition TakeTurn(IPlayerBoard board)
{
return(BoardPosition.At(0, 0));
}
public ActionValidator(IPlayerBoard currentBoard)
{
this.board = currentBoard;
}
public static List <List <Field> > FindAllSequences(IPlayerBoard board, int targetLength, int size)
{
var allSequences = new List <List <Field> >();
var fields = board.GetFieldsSorted();
var sequence = new Stack <Field>();
int maxDiff = (fields.Last().Value - fields.First().Value) / (targetLength - 1);
bool sequenceWithDiffFound;
for (int i = 0; i < size; i++)
{
sequence.Push(fields[i]);
for (int j = i + 1; j < size; j++)
{
int diff = fields[j].Value - fields[i].Value;
sequenceWithDiffFound = false;
if (diff > maxDiff)
{
break; //No need to search further - difference is to big, we won't find AP of required length
}
sequence.Push(fields[j]);
int lastIndex = j;
for (int k = j + 1; k < size; k++)
{
if (fields[k].Value > fields[lastIndex].Value + diff)
{
break;
}
else if (fields[k].Value < fields[lastIndex].Value + diff)
{
continue;
}
else
{
//we found the next element of a sequence
sequence.Push(fields[k]);
lastIndex = k;
if (sequence.Count == targetLength)
{
allSequences.Add(sequence.ToList());
sequenceWithDiffFound = true;
break;
}
}
}
sequence.Clear();
sequence.Push(fields[i]);
if (sequenceWithDiffFound)
{
continue;
}
}
sequence.Clear();
}
return(allSequences);
}
public BoardPosition TakeTurn(IPlayerBoard board)
{
Console.WriteLine("************** I'm a ChattyBot, hear me ROAR! ************");
return(BoardPosition.At(2, 2));
}
public override void InitializeGame(IPlayerBoard board, int size, int targetLength)
{
}
public abstract int SelectFieldValue(IPlayerBoard board);
public abstract void InitializeGame(IPlayerBoard board, int size, int targetLength);
public BoardPosition TakeTurn(IPlayerBoard board)
{
throw new NotImplementedException();
}
public BoardPosition TakeTurn(IPlayerBoard board)
{
return(new BoardPosition(0, 0));
}
