public void AddInfluencer(TekField f)
{
if (!Influencers.Contains(f)) // don't add more than once
{
Influencers.Add(f);
}
}
private void __SetBorder(TekFieldView p, TekField neighbour, TekFieldView.TekBorder border)
{
if (neighbour.Area == null)
{
if (p.Field.Area == null)
{
p.Borders[(int)border] = TekFieldView.TekBorderStyle.tbsNone;
}
else
{
p.Borders[(int)border] = TekFieldView.TekBorderStyle.tbsNone; // tbsExternal;
}
}
else if (p.Field.Area == null)
{
p.Borders[(int)border] = TekFieldView.TekBorderStyle.tbsNone; // tbsExternal;
}
else
{
if (neighbour.Area.AreaNum == p.Field.Area.AreaNum)
{
p.Borders[(int)border] = TekFieldView.TekBorderStyle.tbsInternal;
}
else
{
p.Borders[(int)border] = TekFieldView.TekBorderStyle.tbsExternal;
}
}
}
public override bool HeuristicApplies(TekBoard board, TekField field)
{
foreach (TekRegion region in TekRegion.GetCompactRegions(field))
{
foreach (TekField f in region.GetBorderFields())
{
try
{
int[] tryValues = f.PossibleValues.ToArray(); // setting value will empty possiblevalues array
foreach (int value in tryValues)
{
f.Value = value;
if (region.GetTotalPossibleValues().Count < region.Fields.Count)
{
AddHeuristicFields(region.Fields);
AddAffectedFields(f);
AddValue(value);
}
}
if (AffectedFields.Count > 0)
{
return(true);
}
}
finally
{
f.Value = 0;
}
}
}
return(false);
}
private void AddOnce(List <TekField> list, TekField field)
{
if (!list.Contains(field))
{
list.Add(field);
}
}
public bool IsCompact()
{
if (Fields.Count == 0)
{
return(false);
}
int i = 0;
while (i < Fields.Count)
{
TekField field1 = Fields[i++];
if (field1.Value != 0)
{
continue;
}
int j = i;
while (j < Fields.Count)
{
if (Fields[j].Value == 0 && !Fields[j].Influencers.Contains(field1))
{
return(false);
}
j++;
}
}
return(true);
}
private int ComputeDistance(TekField field1, TekField field2, List <TekField> chain)
{
if (field1.Influencers.Contains(field2))
{
return(1);
}
else
{
int value = ComputeDistance(field1, field2);
if (value >= 0)
{
return(value);
}
else
{
int minDistance = Int32.MaxValue - 1;
foreach (TekField f in field1.Influencers)
{
if (chain.Contains(f) && !ChainBackTracking.Contains(f))
{
ChainBackTracking.Add(f);
value = ComputeDistance(f, field2, chain);
if (value < minDistance)
{
minDistance = value;
}
ChainBackTracking.Remove(f);
}
}
return(1 + minDistance);
}
}
}
private bool ParseValue(string input, TekBoard board)
{
int row, col, value;
Match match = valuePattern.Match(input);
if (match.Success &&
Int32.TryParse(match.Groups["row"].Value, out row) &&
Int32.TryParse(match.Groups["col"].Value, out col) &&
Int32.TryParse(match.Groups["value"].Value, out value)
)
{
if (!board.IsInRange(row, col) || value <= 0 || value > Const.MAXTEK)
{
ParseError("Invalid value line {0}: ({1},{2}", input, row, col);
}
TekField field = board.Fields[row, col];
field.Value = value;
field.Initial = match.Groups["initial"].Value == "i";
return(true);
}
else
{
return(false);
}
}
protected bool IsTriplet(TekField field1, TekField field2, TekField field3, bool inSameArea = true)
// hidden triplets are ignored
{
if (inSameArea && (field1.Area != field2.Area || field1.Area != field3.Area || field2.Area != field3.Area))
{
return(false);
}
if (field1.TotalPossibleValues(field2, field3).Count != 3)
{
return(false);
}
// 2 or 3 values per field
if (field1.PossibleValues.Count < 2 || field1.PossibleValues.Count > 3)
{
return(false);
}
if (field2.PossibleValues.Count < 2 || field2.PossibleValues.Count > 3)
{
return(false);
}
if (field3.PossibleValues.Count < 2 || field3.PossibleValues.Count > 3)
{
return(false);
}
return(true);
}
public void PlayNotes(TekField field, params int[] values)
{
for (int i = 0; i < values.Length; i++)
{
PlayNote(field, values[i]);
}
}
public void ExcludeValues(TekField field, params int[] values)
{
for (int i = 0; i < values.Length; i++)
{
ExcludeValue(field, values[i]);
}
}
public override bool HeuristicApplies(TekBoard board, TekField field)
{
List <TekArea> AdjacentAreas = field.Area.GetAdjacentAreas();
foreach (TekArea area in AdjacentAreas)
{
foreach (int value in field.PossibleValues)
{
bool possible = false;
Region.Clear();
foreach (TekField f in area.Fields)
{
if (f.ValuePossible(value))
{
if (field.Influencers.Contains(f))
{
Region.AddField(f);
}
else
{
possible = true;
break;
}
}
}
if (!possible && Region.Fields.Count > 0)
{
AddAffectedField(field);
AddValue(value);
AddHeuristicFields(Region.Fields);
}
}
}
return(AffectedFields.Count > 0 && HeuristicValues.Count > 0);
}
public void AddNeighbour(TekField f)
{
if (!Neighbours.Contains(f)) // don't add more than once
{
Neighbours.Add(f);
}
}
private bool BruteForceSolve()
{
if (SortedCandidates.Count == 0)
{
return(Board.IsSolved());
}
TekField Field0 = SortedCandidates[0];
if (Field0.PossibleValues.Count == 0)
{
return(Board.IsSolved());
}
for (int i = 0; i < Field0.PossibleValues.Count; i++)
{
SetFieldValue(Field0, Field0.PossibleValues[i]);
if (BruteForceSolve())
{
return(true);
}
else // backtrack
{
SetFieldValue(Field0, 0);
}
} // if we get here, this branch has no solution
return(false);
}
public bool IsInvalidThreePairs(TekField field3)
{
if (Fields.Count != 2)
{
return(false);
}
return(IsInvalidThreePairs(Fields[0], Fields[1], field3));
}
protected bool IsInvalidThreePairs(TekField field1, TekField field2, TekField field3)
{
if (field1.CommonPossibleValues(field2, field3).Count != 2 || !IsPair(field1, field2) || !IsPair(field1, field3) || !IsPair(field2, field3))
{
return(false);
}
return(field1.Influencers.Contains(field2) && field1.Influencers.Contains(field3) && field2.Influencers.Contains(field3));
}
public virtual void AddField(TekField f)
{
if (Fields.Contains(f)) // don't add more than once
{
return;
}
Fields.Add(f);
Sort();
}
private void ExportExcludes(TekField field, StreamWriter wr)
{
wr.Write(EXCLUDESFORMAT1, field.Row, field.Col);
foreach (int value in field.ExcludedValues)
{
wr.Write(EXCLUDESFORMAT2, value);
}
wr.WriteLine();
}
public void ExcludeValue(TekField field, int value)
{
PushMove(field.Row, field.Col, TekMove.tmExclude, value);
field.ExcludeValue(value, true);
if (field.Notes.Contains(value))
{
PlayNote(field, value);
}
}
public void PlayClear(TekField field)
{
PushMove(field.Row, field.Col, TekMove.tmClear, field.Value);
field.ClearNotes();
if (!field.Initial)
{
field.Value = 0;
}
}
private void ExportNotes(TekField field, StreamWriter wr)
{
wr.Write(NOTESFORMAT1, field.Row, field.Col);
foreach (int value in field.Notes)
{
wr.Write(NOTESFORMAT2, value);
}
wr.WriteLine();
}
public void ExcludeValues(TekMoves moves, TekField field)
{
foreach (int value in HeuristicValues)
{
if (field.ValuePossible(value))
{
moves.ExcludeValue(field, value);
}
}
}
public override void AddField(TekField f)
{
base.AddField(f);
if (f.Area != null)
{
return; // or exception
}
f.Area = this;
SetInfluencers();
}
public bool IsTriplet(TekField field3, bool inSameArea = true)
{
if (Fields.Count != 2)
{
return(false);
}
else
{
return(IsTriplet(Fields[0], Fields[1], field3, inSameArea));
}
}
public override bool HeuristicApplies(TekBoard board, TekField field)
{
if (field.PossibleValues.Count == 1)
{
AddHeuristicField(field);
AddAffectedField(field);
AddValue(field.PossibleValues[0]);
return(true);
}
return(false);
}
private void AddField(TekBoard board, TekField field)
{
List <TekField> chain = FindChain(field);
if (chain == null)
{
chain = new List <TekField>();
Chains.Add(chain);
}
chain.Add(field);
}
public int ComputeDistance(TekField field1, TekField field2)
{
List <TekField> chain = FindChain(field1);
if (chain == null || !chain.Contains(field2))
{
return(-1);
}
int[,] table = Distances[Chains.IndexOf(chain)];
return(table[chain.IndexOf(field1), chain.IndexOf(field2)]);
}
private HeuristicAction _tryValue(TekField field, int value)
{
try
{
field.Value = value;
}
catch (ETekFieldInvalid)
{
return(HeuristicAction.haExcludeValue);
}
return(HeuristicAction.haNone);
}
public bool IsPair(TekField field)
// hidden pairs are ignored
{
if (Fields.Count != 1)
{
return(false);
}
else
{
return(IsPair(Fields[0], field));
}
}
private void initFields(int rows, int cols)
{
Fields = new TekField[rows, cols];
for (int r = 0; r < Rows; r++)
{
for (int c = 0; c < Cols; c++)
{
Fields[r, c] = new TekField(r, c);
}
}
EatExceptions = _EatExceptions;
}
public override bool HeuristicApplies(TekBoard board, TekField field)
{
Stopwatch s = Stopwatch.StartNew();
if (BruteForceSolve())
{
s.Stop();
timeElapsed = s.Elapsed;
board.LoadValues(Board.CopyValues());
return(true);
}
return(false); // can't be solved
}
