public Assignment(Variable var,OverFloorType val)
{
this.variable = var;
this.value = val;
this.nConflicts = 0;
domainPrune = new Dictionary<Vector2, List<OverFloorType>> ();
}
/// <summary>
/// Instantiate a tile with data provided
/// </summary>
/// <param name="pos">Position to instantiate the object</param>
/// <param name="over">Type of object to be instantiated</param>
private void CreateTile(Vector3 pos, OverFloorType over)
{
var cell = matrix[(int)pos.x, (int)pos.y];
GameObject tile = (GameObject)GameObject.Instantiate(this.Tile, pos, Quaternion.identity);
cellInstances[cell.Id] = tile;
tile.transform.SetParent(boardHolder);
GameObject toInstantiate = null;
switch (over)
{
case OverFloorType.Mud:
toInstantiate = this.Mud;
break;
case OverFloorType.Wall:
toInstantiate = this.Wall;
break;
default:
break;
}
if (toInstantiate != null)
{
GameObject overObject = (GameObject)GameObject.Instantiate(toInstantiate, pos, Quaternion.identity);
overObject.transform.SetParent(tile.transform);
}
}
/// <summary>
/// Creates the assignment and prunes other variables
/// </summary>
/// <param name="var">Variable.</param>
/// <param name="val">Value.</param>
/// <returns>True if the assignment is legal</returns>
public bool AssignValue(Variable var, OverFloorType val, bool inference = true)
{
//Create a new assignment
Assignment assign = new Assignment(var, val);
//Get current domain before MAC3 to store posible values to prune
List <OverFloorType> domainBeformMAC = var.remDomain.ToList();
//Get variable prunes
var validAssignment = true;
if (inference)
{
validAssignment = Search.MAC3(ref assign, new CSP(this));
}
if (validAssignment)
{
//Prune all values that are not a variable
assign.domainPrune.Add(var.pos, domainBeformMAC.Where(r => r != val).ToList());
//Go over variable domain prunes to remove from variables
foreach (var varPrune in assign.domainPrune.Keys)
{
List <OverFloorType> valuesToPrune = assign.domainPrune[varPrune];
Variable varToPrune = vars.First(v => v.pos == varPrune);
foreach (var vPrune in valuesToPrune)
{
varToPrune.removeDomainElement(vPrune);
}
}
//Save the assignment
assignments.Add(assign);
}
return(validAssignment);
}
public Assignment(Variable var, OverFloorType val)
{
this.variable = var;
this.value = val;
this.nConflicts = 0;
domainPrune = new Dictionary <Vector2, List <OverFloorType> > ();
}
/// <summary>
/// Add a prune of a value to a variable
/// </summary>
/// <param name="var">Variable to be pruned</param>
/// <param name="val">Value that will be pruned</param>
public void AddDomainPrune(Vector2 var, OverFloorType val)
{
if (!domainPrune.ContainsKey(var))
{
domainPrune [var] = new List <OverFloorType> ();
}
domainPrune [var].Add(val);
}
/// <summary>
/// Generates a random number of tiles using CSP constraint validaton
/// </summary>
/// <param name="matrix">Cell matrix to be filled</param>
/// <returns>Cell matrix with random values generated</returns>
private Cell[,] GenerateRandomTiles(Cell[,] matrix)
{
//Initialize a new random generator
System.Random random = new System.Random();
//Get number of tiles
var totalNumberOfTiles = this.numTiles * this.numTiles;
var numberOfRandomTiles = totalNumberOfTiles * randomGeneratedTilesRate / 100;
//List with all possible values
List <OverFloorType> values = Enum.GetValues(typeof(OverFloorType)).OfType <OverFloorType>().Where(o => Convert.ToInt32(o) >= 0).ToList();
for (int i = 0; i < numberOfRandomTiles; i++)
{
bool generatedValue = false;
//Loop until a valid random generated value has been created for this turn
while (!generatedValue)
{
//Generate a random number for x and y
var x = random.Next(numTiles);
var y = random.Next(numTiles);
//Only assign value to unassigned
if (matrix[x, y].overFloor == OverFloorType.NONE)
{
//Generate a random value
Array overfloortypes = Enum.GetValues(typeof(OverFloorType));
OverFloorType randomType = OverFloorType.NONE;
while (randomType == OverFloorType.NONE)
{
randomType = (OverFloorType)overfloortypes.GetValue(random.Next(0, overfloortypes.Length));
}
//Assign the value
matrix[x, y].overFloor = randomType;
List <Variable> vars = ConvertMatrixToVars(matrix);
CSP problem = new CSP(vars, values, toleranceFW, toleranceFM);
if (problem.ValidateConstraints())
{
generatedValue = true;
Debug.Log(string.Format("Position assigned:[{0},{1}] Value: {2}", x.ToString(), y.ToString(), randomType.ToString()));
}
else
{
matrix[x, y].overFloor = OverFloorType.NONE;
}
}
}
}
return(matrix);
}
/// <summary>
/// Removes a value from the domain
/// </summary>
/// <param name="elem">Value to be removed</param>
public void removeDomainElement(OverFloorType elem)
{
remDomain.Remove (elem);
}
/// <summary>
/// Add a prune of a value to a variable
/// </summary>
/// <param name="var">Variable to be pruned</param>
/// <param name="val">Value that will be pruned</param>
public void AddDomainPrune(Vector2 var,OverFloorType val)
{
if (!domainPrune.ContainsKey (var))
domainPrune [var] = new List<OverFloorType> ();
domainPrune [var].Add (val);
}
/// <summary>
/// Add a value to the domain
/// </summary>
/// <param name="elem">Value to be added to the domain</param>
public void addDomainElement(OverFloorType elem)
{
remDomain.Add (elem);
}
public Variable(Vector2 posVar, OverFloorType? val, List<OverFloorType> remDomain)
{
this.pos = posVar;
this.val = val;
this.remDomain = new List<OverFloorType>();
remDomain.ForEach(d => this.remDomain.Add(d));
}
public Variable(Vector2 posVar,OverFloorType val)
{
this.pos = posVar;
this.val = val;
}
/// <summary>
/// Removes a available value from a variable
/// </summary>
/// <param name="var"></param>
/// <param name="value"></param>
public void RemoveDomainElementFromVariable(Variable var, OverFloorType value)
{
this.vars.First(v=>v.pos == var.pos).removeDomainElement(value);
}
/// <summary>
/// Removes a available value from a variable
/// </summary>
/// <param name="var"></param>
/// <param name="value"></param>
public void RemoveDomainElementFromVariable(Variable var, OverFloorType value)
{
this.vars.First(v => v.pos == var.pos).removeDomainElement(value);
}
/// <summary>
/// Creates the assignment and prunes other variables
/// </summary>
/// <param name="var">Variable.</param>
/// <param name="val">Value.</param>
/// <returns>True if the assignment is legal</returns>
public bool AssignValue(Variable var,OverFloorType val, bool inference = true)
{
//Create a new assignment
Assignment assign = new Assignment (var, val);
//Get current domain before MAC3 to store posible values to prune
List<OverFloorType> domainBeformMAC = var.remDomain.ToList();
//Get variable prunes
var validAssignment = true;
if (inference)
validAssignment = Search.MAC3(ref assign, new CSP(this) );
if (validAssignment)
{
//Prune all values that are not a variable
assign.domainPrune.Add(var.pos, domainBeformMAC.Where(r => r != val).ToList());
//Go over variable domain prunes to remove from variables
foreach (var varPrune in assign.domainPrune.Keys)
{
List<OverFloorType> valuesToPrune = assign.domainPrune[varPrune];
Variable varToPrune = vars.First(v => v.pos == varPrune);
foreach (var vPrune in valuesToPrune)
{
varToPrune.removeDomainElement(vPrune);
}
}
//Save the assignment
assignments.Add(assign);
}
return validAssignment;
}
/// <summary>
/// Instantiate a tile with data provided
/// </summary>
/// <param name="pos">Position to instantiate the object</param>
/// <param name="over">Type of object to be instantiated</param>
private void CreateTile(Vector3 pos,OverFloorType over)
{
var cell = matrix[(int)pos.x, (int)pos.y];
GameObject tile = (GameObject)GameObject.Instantiate (this.Tile, pos, Quaternion.identity);
cellInstances[cell.Id] = tile;
tile.transform.SetParent (boardHolder);
GameObject toInstantiate = null;
switch (over) {
case OverFloorType.Mud:
toInstantiate = this.Mud;
break;
case OverFloorType.Wall:
toInstantiate = this.Wall;
break;
default:
break;
}
if (toInstantiate != null) {
GameObject overObject = (GameObject)GameObject.Instantiate (toInstantiate, pos, Quaternion.identity);
overObject.transform.SetParent(tile.transform);
}
}
/// <summary>
/// Add a value to the domain
/// </summary>
/// <param name="elem">Value to be added to the domain</param>
public void addDomainElement(OverFloorType elem)
{
remDomain.Add(elem);
}
/// <summary>
/// Removes a value from the domain
/// </summary>
/// <param name="elem">Value to be removed</param>
public void removeDomainElement(OverFloorType elem)
{
remDomain.Remove(elem);
}
public Variable(Vector2 posVar, OverFloorType val)
{
this.pos = posVar;
this.val = val;
}
