public override void Update(Ship vessel, GridValue[,] array)
{
int length = vessel.Length;
Position shipPosition = vessel.GetPosition;
if (shipPosition.X + length > array.GetUpperBound(0))
{
throw new InvalidShipPlacementException(
string.Format("Horizontal ship won't fit on the board, attempted to add: {0}",
shipPosition.ToString()));
}
for (var x = shipPosition.X; x < (length + shipPosition.X); x++)
{
if (array[x, shipPosition.Y] != GridValue.EmptyCellValue)
{
throw new InvalidShipPlacementException(string.Format("There is already a ship here:{0}",
array[x, shipPosition.Y]));
}
}
for (var x = shipPosition.X; x < (length + shipPosition.X); x++)
{
array[x, shipPosition.Y] = vessel.GridValue;
}
}
public override void Update(Ship vessel, GridValue[,] array)
{
var shipPosition = vessel.GetPosition;
int Length = vessel.Length;
if (shipPosition.Y + Length > array.GetUpperBound(1))
{
throw new InvalidShipPlacementException(
string.Format("Vertical ship won't fit on the board, attempted to add: {0}",
shipPosition.ToString()));
}
int row = shipPosition.X;
for (int y = shipPosition.Y; y < (Length + shipPosition.Y); y++)
{
if (array[row, y] != GridValue.EmptyCellValue)
{
throw new InvalidShipPlacementException(string.Format("There is already a ship here:{0}",
array[row, y]));
}
}
for (int y = shipPosition.Y; y < (Length + shipPosition.Y); y++)
{
array[row, y] = vessel.GridValue;
}
}
//Code d'initialisation
public SudokuSolver(int x, int y)
{
// only initialize in the constructor, no calls
SudokuGrid = new GridValue[x, y]; // the array exists now in mem, but each entry is pointing to null
for (int i = 0; i < x; i++)
{
for (int j = 0; j < y; j++)
{
SudokuGrid[i, j] = new GridValue();
}
}
}
private GridValue[,] SudokuGridCreator(out GridValue[,] SudokuGrid)
{
SudokuGrid = new GridValue[9, 9];
for (int i = 0; i < 9; i++)
{
for (int j = 0; j < 9; j++)
{
SudokuGrid[i, j] = new GridValue();
}
}
return SudokuGrid;
}
public Board(int width, int height)
{
_height = height;
_width = width;
array = new GridValue[_width, _height];
foreach (var x in Enumerable.Range(0, _width))
{
foreach (var y in Enumerable.Range(0, _height))
{
array[x, y] = GridValue.EmptyCellValue;
}
}
}
GridValue[,] ObviousSolving(GridValue[,] SudokuGrid, int i, int j)
{
if (SudokuGrid[i, j].PossibleValues.Count == 1)
{
SudokuGrid[i, j].Value = SudokuGrid[i, j].PossibleValues[0];
SudokuGrid[i, j].AlreadySolved = true;
//On supprime la possibité de contenir d'autres nombres
for (int value = 1; value < 10; value++)
{
if (SudokuGrid[i, j].Value != value)
{
SudokuGrid[i, j].PossibleValues.Remove(value);
}
}
}
return(SudokuGrid);
}
GridValue[,] ColumnDetection(GridValue[,] SudokuGrid, int i, int j)
{
for (int k = 0; k < 9; k++)
{
//On vérifie si la case en question a déjà été résolue
if (SudokuGrid[i, k].AlreadySolved == true)
{
//Si oui, on vérifie si la valeur qu'elle contient a déjà été supprimé auparavant
if (SudokuGrid[i, j].PossibleValues.Contains(SudokuGrid[i, k].Value))
{
//Si la valeur n'a pas été supprimé, on la supprime
SudokuGrid[i, j].PossibleValues.Remove(SudokuGrid[i, k].Value);
}
}
}
return(SudokuGrid);
}
GridValue[,] RowSolving(GridValue[,] SudokuGrid, int i, int j)
{
for (int possibleAnswer = 1; possibleAnswer < 10; possibleAnswer++)
{
bool canBeThis = true;
for (int k = 0; k < 9; k++)
{
if (SudokuGrid[k, j].AlreadySolved == false)
{
if (SudokuGrid[i, j].PossibleValues.Contains(possibleAnswer))
{
if (SudokuGrid[k, j].PossibleValues.Contains(possibleAnswer))
{
canBeThis = false;
}
}
else
{
canBeThis = false;
}
}
}
if (canBeThis == true)
{
SudokuGrid[i, j].AlreadySolved = true;
SudokuGrid[i, j].Value = possibleAnswer;
//On supprime la possibité de contenir d'autres nombres
for (int value = 1; value < 10; value++)
{
if (SudokuGrid[i, j].Value != value)
{
SudokuGrid[i, j].PossibleValues.Remove(value);
}
}
break;
}
else
{
SudokuGrid[i, j].Value = 0;
}
}
return(SudokuGrid);
}
private static GridValue[,] FillGrid(GridValue[,] grid, DirectionPath path, GridValue a, GridValue b, Vector2Int portPosition, int[,] gridDistance = null)
{
int x = portPosition.x;
int y = portPosition.y;
int distance = 0;
foreach (var wire in path.Nodes)
{
var displacement = NodeToDeplacement(wire.Direction, wire.Distance);
if (IsHorizontal(wire.Direction))
{
for (int i = 0; i < wire.Distance; i++)
{
grid[x, y] = ValueToPutOnGrid(grid[x, y], x, y, a, b);
if (gridDistance != null && gridDistance[x, y] == 0)
{
gridDistance[x, y] = distance;
}
x += displacement;
distance++;
}
}
else
{
for (int i = 0; i < wire.Distance; i++)
{
grid[x, y] = ValueToPutOnGrid(grid[x, y], x, y, a, b);
if (gridDistance != null && gridDistance[x, y] == 0)
{
gridDistance[x, y] = distance;
}
y += displacement;
distance++;
}
}
}
return(grid);
}
private void SudokuDisplay(GridValue[,] Sudoku)
{
Console.WriteLine("Tous les 0 représentent des valeurs non assignées");
Console.WriteLine("┏━━━┯━━━┯━━━┳━━━┯━━━┯━━━┳━━━┯━━━┯━━━┓");
Console.WriteLine("┃ " + Sudoku[0, 0].Value + " │ " + Sudoku[1, 0].Value + " │ " + Sudoku[2, 0].Value + " ┃ " + Sudoku[3, 0].Value + " │ " + Sudoku[4, 0].Value + " │ " + Sudoku[5, 0].Value + " ┃ " + Sudoku[6, 0].Value + " │ " + Sudoku[7, 0].Value + " │ " + Sudoku[8, 0].Value + " ┃");
Console.WriteLine("┠───┼───┼───╂───┼───┼───╂───┼───┼───┨");
Console.WriteLine("┃ " + Sudoku[0, 1].Value + " │ " + Sudoku[1, 1].Value + " │ " + Sudoku[2, 1].Value + " ┃ " + Sudoku[3, 1].Value + " │ " + Sudoku[4, 1].Value + " │ " + Sudoku[5, 1].Value + " ┃ " + Sudoku[6, 1].Value + " │ " + Sudoku[7, 1].Value + " │ " + Sudoku[8, 1].Value + " ┃");
Console.WriteLine("┠───┼───┼───╂───┼───┼───╂───┼───┼───┨");
Console.WriteLine("┃ " + Sudoku[0, 2].Value + " │ " + Sudoku[1, 2].Value + " │ " + Sudoku[2, 2].Value + " ┃ " + Sudoku[3, 2].Value + " │ " + Sudoku[4, 2].Value + " │ " + Sudoku[5, 2].Value + " ┃ " + Sudoku[6, 2].Value + " │ " + Sudoku[7, 2].Value + " │ " + Sudoku[8, 2].Value + " ┃");
Console.WriteLine("┣━━━┿━━━┿━━━╋━━━┿━━━┿━━━╋━━━┿━━━┿━━━┫");
Console.WriteLine("┃ " + Sudoku[0, 3].Value + " │ " + Sudoku[1, 3].Value + " │ " + Sudoku[2, 3].Value + " ┃ " + Sudoku[3, 3].Value + " │ " + Sudoku[4, 3].Value + " │ " + Sudoku[5, 3].Value + " ┃ " + Sudoku[6, 3].Value + " │ " + Sudoku[7, 3].Value + " │ " + Sudoku[8, 3].Value + " ┃");
Console.WriteLine("┠───┼───┼───╂───┼───┼───╂───┼───┼───┨");
Console.WriteLine("┃ " + Sudoku[0, 4].Value + " │ " + Sudoku[1, 4].Value + " │ " + Sudoku[2, 4].Value + " ┃ " + Sudoku[3, 4].Value + " │ " + Sudoku[4, 4].Value + " │ " + Sudoku[5, 4].Value + " ┃ " + Sudoku[6, 4].Value + " │ " + Sudoku[7, 4].Value + " │ " + Sudoku[8, 4].Value + " ┃");
Console.WriteLine("┠───┼───┼───╂───┼───┼───╂───┼───┼───┨");
Console.WriteLine("┃ " + Sudoku[0, 5].Value + " │ " + Sudoku[1, 5].Value + " │ " + Sudoku[2, 5].Value + " ┃ " + Sudoku[3, 5].Value + " │ " + Sudoku[4, 5].Value + " │ " + Sudoku[5, 5].Value + " ┃ " + Sudoku[6, 5].Value + " │ " + Sudoku[7, 5].Value + " │ " + Sudoku[8, 5].Value + " ┃");
Console.WriteLine("┣━━━┿━━━┿━━━╋━━━┿━━━┿━━━╋━━━┿━━━┿━━━┫");
Console.WriteLine("┃ " + Sudoku[0, 6].Value + " │ " + Sudoku[1, 6].Value + " │ " + Sudoku[2, 6].Value + " ┃ " + Sudoku[3, 6].Value + " │ " + Sudoku[4, 6].Value + " │ " + Sudoku[5, 6].Value + " ┃ " + Sudoku[6, 6].Value + " │ " + Sudoku[7, 6].Value + " │ " + Sudoku[8, 6].Value + " ┃");
Console.WriteLine("┠───┼───┼───╂───┼───┼───╂───┼───┼───┨");
Console.WriteLine("┃ " + Sudoku[0, 7].Value + " │ " + Sudoku[1, 7].Value + " │ " + Sudoku[2, 7].Value + " ┃ " + Sudoku[3, 7].Value + " │ " + Sudoku[4, 7].Value + " │ " + Sudoku[5, 7].Value + " ┃ " + Sudoku[6, 7].Value + " │ " + Sudoku[7, 7].Value + " │ " + Sudoku[8, 7].Value + " ┃");
Console.WriteLine("┠───┼───┼───╂───┼───┼───╂───┼───┼───┨");
Console.WriteLine("┃ " + Sudoku[0, 8].Value + " │ " + Sudoku[1, 8].Value + " │ " + Sudoku[2, 8].Value + " ┃ " + Sudoku[3, 8].Value + " │ " + Sudoku[4, 8].Value + " │ " + Sudoku[5, 8].Value + " ┃ " + Sudoku[6, 8].Value + " │ " + Sudoku[7, 8].Value + " │ " + Sudoku[8, 8].Value + " ┃");
Console.WriteLine("┗━━━┷━━━┷━━━┻━━━┷━━━┷━━━┻━━━┷━━━┷━━━┛");
}
GridValue[,] HouseDetection(GridValue[,] SudokuGrid, int i, int j)
{
//Contrairement à la détection de la rangée et à la détection de la colonne, on va commencer par vérifier dans quel "maison" appartient la case
if ((i == 0 || i == 1 || i == 2) && (j == 0 || j == 1 | j == 2))
{
for (int hi = 0; hi < 3; hi++)
{
//On va devoir vérifier une section 2D de la matrice alors il va falloir faire des boucles pour chaque valeurs!
for (int hj = 0; hj < 3; hj++)
{
//Bon, on le script va être copié plusieurs fois mais on va pas utiliser une autre fonction pour économiser du code pour autant car ça servirait pas suffisament (autant niveau espace de stockage que niveau performance)
if (SudokuGrid[hi, hj].AlreadySolved == true)
{
if (SudokuGrid[i, j].PossibleValues.Contains(SudokuGrid[hi, hj].Value))
{
SudokuGrid[i, j].PossibleValues.Remove(SudokuGrid[hi, hj].Value);
}
}
}
}
} //Maison numéro 1 (x = {1,2,3} et y = {1,2,3})
if ((i == 5 || i == 4 || i == 5) && (j == 0 || j == 1 | j == 2))
{
for (int hi = 3; hi < 6; hi++)
{
//On va devoir vérifier une section 2D de la matrice alors il va falloir faire des boucles pour chaque valeurs!
for (int hj = 0; hj < 3; hj++)
{
//Bon, on le script va être copié plusieurs fois mais on va pas utiliser une autre fonction pour économiser du code pour autant car ça servirait pas suffisament (autant niveau espace de stockage que niveau performance)
if (SudokuGrid[hi, hj].AlreadySolved == true)
{
if (SudokuGrid[i, j].PossibleValues.Contains(SudokuGrid[hi, hj].Value))
{
SudokuGrid[i, j].PossibleValues.Remove(SudokuGrid[hi, hj].Value);
}
}
}
}
} //Maison numéro 2 (x = {4,5,6} et y = {1,2,3})
if ((i == 6 || i == 7 || i == 8) && (j == 0 || j == 1 | j == 2))
{
for (int hi = 6; hi < 9; hi++)
{
//On va devoir vérifier une section 2D de la matrice alors il va falloir faire des boucles pour chaque valeurs!
for (int hj = 0; hj < 3; hj++)
{
//Bon, on le script va être copié plusieurs fois mais on va pas utiliser une autre fonction pour économiser du code pour autant car ça servirait pas suffisament (autant niveau espace de stockage que niveau performance)
if (SudokuGrid[hi, hj].AlreadySolved == true)
{
if (SudokuGrid[i, j].PossibleValues.Contains(SudokuGrid[hi, hj].Value))
{
SudokuGrid[i, j].PossibleValues.Remove(SudokuGrid[hi, hj].Value);
}
}
}
}
} //Maison numéro 3 (x = {7,8,9} et y = {1,2,3})
if ((i == 0 || i == 1 || i == 2) && (j == 3 || j == 4 | j == 5))
{
for (int hi = 0; hi < 3; hi++)
{
//On va devoir vérifier une section 2D de la matrice alors il va falloir faire des boucles pour chaque valeurs!
for (int hj = 3; hj < 6; hj++)
{
//Bon, on le script va être copié plusieurs fois mais on va pas utiliser une autre fonction pour économiser du code pour autant car ça servirait pas suffisament (autant niveau espace de stockage que niveau performance)
if (SudokuGrid[hi, hj].AlreadySolved == true)
{
if (SudokuGrid[i, j].PossibleValues.Contains(SudokuGrid[hi, hj].Value))
{
SudokuGrid[i, j].PossibleValues.Remove(SudokuGrid[hi, hj].Value);
}
}
}
}
} //Maison numéro 4 (x = {1,2,3} et y = {4,5,6})
if ((i == 3 || i == 4 || i == 5) && (j == 3 || j == 4 | j == 5))
{
for (int hi = 3; hi < 6; hi++)
{
//On va devoir vérifier une section 2D de la matrice alors il va falloir faire des boucles pour chaque valeurs!
for (int hj = 3; hj < 6; hj++)
{
//Bon, on le script va être copié plusieurs fois mais on va pas utiliser une autre fonction pour économiser du code pour autant car ça servirait pas suffisament (autant niveau espace de stockage que niveau performance)
if (SudokuGrid[hi, hj].AlreadySolved == true)
{
if (SudokuGrid[i, j].PossibleValues.Contains(SudokuGrid[hi, hj].Value))
{
SudokuGrid[i, j].PossibleValues.Remove(SudokuGrid[hi, hj].Value);
}
}
}
}
} //Maison numéro 5 (x = {4,5,6} et y = {4,5,6})
if ((i == 6 || i == 7 || i == 8) && (j == 3 || j == 4 | j == 5))
{
for (int hi = 6; hi < 9; hi++)
{
//On va devoir vérifier une section 2D de la matrice alors il va falloir faire des boucles pour chaque valeurs!
for (int hj = 3; hj < 6; hj++)
{
//Bon, on le script va être copié plusieurs fois mais on va pas utiliser une autre fonction pour économiser du code pour autant car ça servirait pas suffisament (autant niveau espace de stockage que niveau performance)
if (SudokuGrid[hi, hj].AlreadySolved == true)
{
if (SudokuGrid[i, j].PossibleValues.Contains(SudokuGrid[hi, hj].Value))
{
SudokuGrid[i, j].PossibleValues.Remove(SudokuGrid[hi, hj].Value);
}
}
}
}
} //Maison numéro 6 (x = {7,8,9} et y = {4,5,6})
if ((i == 0 || i == 1 || i == 2) && (j == 6 || j == 7 | j == 8))
{
for (int hi = 0; hi < 3; hi++)
{
//On va devoir vérifier une section 2D de la matrice alors il va falloir faire des boucles pour chaque valeurs!
for (int hj = 6; hj < 9; hj++)
{
//Bon, on le script va être copié plusieurs fois mais on va pas utiliser une autre fonction pour économiser du code pour autant car ça servirait pas suffisament (autant niveau espace de stockage que niveau performance)
if (SudokuGrid[hi, hj].AlreadySolved == true)
{
if (SudokuGrid[i, j].PossibleValues.Contains(SudokuGrid[hi, hj].Value))
{
SudokuGrid[i, j].PossibleValues.Remove(SudokuGrid[hi, hj].Value);
}
}
}
}
} //Maison numéro 7 (x = {1,2,3} et y = {7,8,9})
if ((i == 3 || i == 4 || i == 5) && (j == 6 || j == 7 | j == 8))
{
for (int hi = 3; hi < 6; hi++)
{
//On va devoir vérifier une section 2D de la matrice alors il va falloir faire des boucles pour chaque valeurs!
for (int hj = 6; hj < 9; hj++)
{
//Bon, on le script va être copié plusieurs fois mais on va pas utiliser une autre fonction pour économiser du code pour autant car ça servirait pas suffisament (autant niveau espace de stockage que niveau performance)
if (SudokuGrid[hi, hj].AlreadySolved == true)
{
if (SudokuGrid[i, j].PossibleValues.Contains(SudokuGrid[hi, hj].Value))
{
SudokuGrid[i, j].PossibleValues.Remove(SudokuGrid[hi, hj].Value);
}
}
}
}
} //Maison numéro 8 (x = {4,5,6} et y = {7,8,9})
if ((i == 6 || i == 7 || i == 8) && (j == 6 || j == 7 | j == 8))
{
for (int hi = 6; hi < 9; hi++)
{
//On va devoir vérifier une section 2D de la matrice alors il va falloir faire des boucles pour chaque valeurs!
for (int hj = 6; hj < 9; hj++)
{
//Bon, on le script va être copié plusieurs fois mais on va pas utiliser une autre fonction pour économiser du code pour autant car ça servirait pas suffisament (autant niveau espace de stockage que niveau performance)
if (SudokuGrid[hi, hj].AlreadySolved == true)
{
if (SudokuGrid[i, j].PossibleValues.Contains(SudokuGrid[hi, hj].Value))
{
SudokuGrid[i, j].PossibleValues.Remove(SudokuGrid[hi, hj].Value);
}
}
}
}
} //Maison numéro 9 (x = {7,8,9} et y = {7,8,9})
return(SudokuGrid);
}
void initLevel()
{
begin = levenBegining.position;
end = levenEnding.position;
begin.y = 0;
end.y = 0;
Vector3 diag = end - begin;
diag = fitToGridSize(diag);
end = begin + diag;
direction = new Vector2i(0, 0);
direction.x = Math.Sign(diag.x);
direction.y = Math.Sign(diag.z);
width = Math.Abs(diag.x);
height = Math.Abs(diag.z);
gridWidth = (int)(width / gridSize);
gridHeight = (int)(height / gridSize);
levelData = new GridValue[gridWidth, gridHeight];
}
public abstract void Update(Ship vessel, GridValue[,] array);
public void AddToGrid(GridValue[,] arrary)
{
GridUpdator.Update(this, arrary);
}
GridValue[,] HouseSolving(GridValue[,] SudokuGrid, int i, int j)
{
for (int possibleAnswer = 1; possibleAnswer < 10; possibleAnswer++)
{
bool canBeThis = true;
if ((i == 0 || i == 1 || i == 2) && (j == 0 || j == 1 | j == 2))
{
for (int hi = 0; hi < 3; hi++)
{
for (int hj = 0; hj < 3; hj++)
{
if (SudokuGrid[hi, hj].AlreadySolved == false)
{
if (SudokuGrid[i, j].PossibleValues.Contains(possibleAnswer))
{
if (SudokuGrid[hi, hj].PossibleValues.Contains(possibleAnswer))
{
canBeThis = false;
}
}
else
{
canBeThis = false;
}
}
}
}
} //Maison numéro 1 (x = {1,2,3} et y = {1,2,3})
if ((i == 5 || i == 4 || i == 5) && (j == 0 || j == 1 | j == 2))
{
for (int hi = 3; hi < 6; hi++)
{
for (int hj = 0; hj < 3; hj++)
{
if (SudokuGrid[hi, hj].AlreadySolved == false)
{
if (SudokuGrid[i, j].PossibleValues.Contains(possibleAnswer))
{
if (SudokuGrid[hi, hj].PossibleValues.Contains(possibleAnswer))
{
if (SudokuGrid[hi, hj].PossibleValues.Contains(possibleAnswer))
{
canBeThis = false;
}
}
else
{
canBeThis = false;
}
}
}
}
}
} //Maison numéro 2 (x = {4,5,6} et y = {1,2,3})
if ((i == 6 || i == 7 || i == 8) && (j == 0 || j == 1 | j == 2))
{
for (int hi = 6; hi < 9; hi++)
{
for (int hj = 0; hj < 3; hj++)
{
if (SudokuGrid[hi, hj].AlreadySolved == false)
{
if (SudokuGrid[i, j].PossibleValues.Contains(possibleAnswer))
{
if (SudokuGrid[hi, hj].PossibleValues.Contains(possibleAnswer))
{
if (SudokuGrid[hi, hj].PossibleValues.Contains(possibleAnswer))
{
canBeThis = false;
}
}
else
{
canBeThis = false;
}
}
}
}
}
} //Maison numéro 3 (x = {7,8,9} et y = {1,2,3})
if ((i == 0 || i == 1 || i == 2) && (j == 3 || j == 4 | j == 5))
{
for (int hi = 0; hi < 3; hi++)
{
for (int hj = 3; hj < 6; hj++)
{
if (SudokuGrid[hi, hj].AlreadySolved == false)
{
if (SudokuGrid[i, j].PossibleValues.Contains(possibleAnswer))
{
if (SudokuGrid[hi, hj].PossibleValues.Contains(possibleAnswer))
{
if (SudokuGrid[hi, hj].PossibleValues.Contains(possibleAnswer))
{
canBeThis = false;
}
}
else
{
canBeThis = false;
}
}
}
}
}
} //Maison numéro 4 (x = {1,2,3} et y = {4,5,6})
if ((i == 3 || i == 4 || i == 5) && (j == 3 || j == 4 | j == 5))
{
for (int hi = 3; hi < 6; hi++)
{
for (int hj = 3; hj < 6; hj++)
{
if (SudokuGrid[hi, hj].AlreadySolved == false)
{
if (SudokuGrid[i, j].PossibleValues.Contains(possibleAnswer))
{
if (SudokuGrid[hi, hj].PossibleValues.Contains(possibleAnswer))
{
if (SudokuGrid[hi, hj].PossibleValues.Contains(possibleAnswer))
{
canBeThis = false;
}
}
else
{
canBeThis = false;
}
}
}
}
}
} //Maison numéro 5 (x = {4,5,6} et y = {4,5,6})
if ((i == 6 || i == 7 || i == 8) && (j == 3 || j == 4 | j == 5))
{
for (int hi = 6; hi < 9; hi++)
{
for (int hj = 3; hj < 6; hj++)
{
if (SudokuGrid[hi, hj].AlreadySolved == false)
{
if (SudokuGrid[i, j].PossibleValues.Contains(possibleAnswer))
{
if (SudokuGrid[hi, hj].PossibleValues.Contains(possibleAnswer))
{
if (SudokuGrid[hi, hj].PossibleValues.Contains(possibleAnswer))
{
canBeThis = false;
}
}
else
{
canBeThis = false;
}
}
}
}
}
} //Maison numéro 6 (x = {7,8,9} et y = {4,5,6})
if ((i == 0 || i == 1 || i == 2) && (j == 6 || j == 7 | j == 8))
{
for (int hi = 0; hi < 3; hi++)
{
for (int hj = 6; hj < 9; hj++)
{
if (SudokuGrid[hi, hj].AlreadySolved == false)
{
if (SudokuGrid[i, j].PossibleValues.Contains(possibleAnswer))
{
if (SudokuGrid[hi, hj].PossibleValues.Contains(possibleAnswer))
{
if (SudokuGrid[hi, hj].PossibleValues.Contains(possibleAnswer))
{
canBeThis = false;
}
}
else
{
canBeThis = false;
}
}
}
}
}
} //Maison numéro 7 (x = {1,2,3} et y = {7,8,9})
if ((i == 3 || i == 4 || i == 5) && (j == 6 || j == 7 | j == 8))
{
for (int hi = 3; hi < 6; hi++)
{
for (int hj = 6; hj < 9; hj++)
{
if (SudokuGrid[hi, hj].AlreadySolved == false)
{
if (SudokuGrid[i, j].PossibleValues.Contains(possibleAnswer))
{
if (SudokuGrid[hi, hj].PossibleValues.Contains(possibleAnswer))
{
if (SudokuGrid[hi, hj].PossibleValues.Contains(possibleAnswer))
{
canBeThis = false;
}
}
else
{
canBeThis = false;
}
}
}
}
}
} //Maison numéro 8 (x = {4,5,6} et y = {7,8,9})
if ((i == 6 || i == 7 || i == 8) && (j == 6 || j == 7 | j == 8))
{
for (int hi = 6; hi < 9; hi++)
{
for (int hj = 6; hj < 9; hj++)
{
if (SudokuGrid[hi, hj].AlreadySolved == false)
{
if (SudokuGrid[i, j].PossibleValues.Contains(possibleAnswer))
{
if (SudokuGrid[hi, hj].PossibleValues.Contains(possibleAnswer))
{
if (SudokuGrid[hi, hj].PossibleValues.Contains(possibleAnswer))
{
canBeThis = false;
}
}
else
{
canBeThis = false;
}
}
}
}
}
} //Maison numéro 9 (x = {7,8,9} et y = {7,8,9})
if (canBeThis == true)
{
SudokuGrid[i, j].AlreadySolved = true;
SudokuGrid[i, j].Value = possibleAnswer;
//On supprime la possibité de contenir d'autres nombres
for (int value = 1; value < 10; value++)
{
if (SudokuGrid[i, j].Value != value)
{
SudokuGrid[i, j].PossibleValues.Remove(value);
}
}
break;
}
else
{
SudokuGrid[i, j].Value = 0;
}
}
return(SudokuGrid);
}
//Display the grid
void SudokuDisplay(GridValue[,] Sudoku)
{
Sudoku[1, 1].Value = 1;
Sudoku[1, 2].Value = 2;
Console.WriteLine(Sudoku[0, 0].Value + Sudoku[1, 0].Value);
}