private int CheckNeighbours(int x, int y) { var neighbours = GetNeighbours(x, y); int neighbourCount = 0; foreach (var neighbour in neighbours) { if (CurrentGenCells.Contains(new Tuple <int, int>(neighbour.Item1, neighbour.Item2))) { neighbourCount++; } else { var currentNeighbour = new Tuple <int, int>(neighbour.Item1, neighbour.Item2); int currentNeighbourCount; if (PotentialCells.TryGetValue(currentNeighbour, out currentNeighbourCount)) { PotentialCells[currentNeighbour] += 1; } else { PotentialCells.Add(currentNeighbour, 1); } } } return(neighbourCount); }
public HashSet <Tuple <int, int> > PopulateNextGen(bool shouldNotify = true) { PotentialCells.Clear(); NextGenCells.Clear(); foreach (var cell in CurrentGenCells) { if (Rules.ShouldLive(CheckNeighbours(cell.Item1, cell.Item2))) { NextGenCells.Add(new Tuple <int, int>(cell.Item1, cell.Item2)); } } var results = PotentialCells.Where(p => Rules.ShouldZombiefy(p.Value)).ToHashSet(); foreach (var result in results) { NextGenCells.Add(new Tuple <int, int>(result.Key.Item1, result.Key.Item2)); } if (shouldNotify) { GlobalHost.ConnectionManager.GetHubContext <GameHub>().Clients.All.nextUniverseStep(HsToList(CurrentGenCells), Generation); } CurrentGenCells = NextGenCells; NextGenCells = new HashSet <Tuple <int, int> >(); return(CurrentGenCells); }
private int FindNakedPair(int begin, out int bitMask) { bitMask = 0; int i; for (i = begin; i < N;) { PotentialCells pc = mPotentialCells[i]; if (pc.cellCount != 2) { ++i; continue; } int end = i + pc.cellCount; if (end > N) { break; } int j; for (j = i + 1; j < end; ++j) { if (mPotentialCells[j].cellMask != pc.cellMask) { break; } } if (j < end) { i = j; continue; } for (j = i; j < end; ++j) { bitMask |= (1 << mPotentialCells[j].number); } bitMask = ~bitMask; return(i); } return(N); }
public int CompareTo(object otherObj) { PotentialCells other = (PotentialCells)otherObj; if (cellMask < other.cellMask) { return(-1); } if (cellMask > other.cellMask) { return(1); } return(0); }
private void GetPotentialCells(int pattern) { for (int i = 0; i < N; ++i) { PotentialCells pc = mPotentialCells[i]; pc.number = i; pc.cellMask = 0; pc.cellCount = 0; } for (int cell = 0; cell < N; ++cell) { int row = mPatterns[pattern, cell].row; int col = mPatterns[pattern, cell].col; UpdatePotentialCells(mCells[row, col], cell); } }
// cellNumber can be row, col or block index // Transpose bits (possible values in cell) // to cellMask (possible cells with value) private void UpdatePotentialCells(int bits, int cellNumber) { if ((bits & CONFIRMED) != 0) { return; } for (int number = 0, bit = 1; number < N; ++number, bit <<= 1) { if ((bits & bit) != 0) { PotentialCells pc = mPotentialCells[number]; pc.cellMask |= (1 << cellNumber); ++pc.cellCount; } } }
public Board() { InitializeComponent(); int i; for (i = 0; i < N; ++i) { mPotentialCells[i] = new PotentialCells(); } // Build LUT for each type of scan: row, col, block i = 0; // By Row for (int row = 0; row < N; ++row) { mPatternLabels[i] = "row " + row; for (int col = 0; col < N; ++col) { mPatterns[i, col].row = row; mPatterns[i, col].col = col; } ++i; } // By Column for (int col = 0; col < N; ++col) { mPatternLabels[i] = "col " + col; for (int row = 0; row < N; ++row) { mPatterns[i, row].row = row; mPatterns[i, row].col = col; } ++i; } // By Block for (int br = 0; br < B; ++br) { int rowBegin = br * B; int rowEnd = rowBegin + B; for (int bc = 0; bc < B; ++bc) { int colBegin = bc * B; int colEnd = colBegin + B; int j = 0; mPatternLabels[i] = "block " + br + "," + bc; for (int row = rowBegin; row < rowEnd; ++row) { for (int col = colBegin; col < colEnd; ++col) { mPatterns[i, j].row = row; mPatterns[i, j].col = col; ++j; } } ++i; } } }
private bool FindNakedTriples() { for (int pattern = 0; pattern < NUM_PATTERNS; ++pattern) { GetPotentialCells(pattern); for (int i = 0; i < (N - 2); ++i) { ref PotentialCells iCell = ref mPotentialCells[i]; if ((iCell.cellCount < 2) || (iCell.cellCount > 3)) { continue; } for (int j = i + 1; j < (N - 1); ++j) { ref PotentialCells jCell = ref mPotentialCells[j]; if ((jCell.cellCount < 2) || (jCell.cellCount > 3)) { continue; } for (int k = j + 1; k < N; ++k) { ref PotentialCells kCell = ref mPotentialCells[k]; if ((kCell.cellCount < 2) || (kCell.cellCount > 3)) { continue; } int cellMask = iCell.cellMask | jCell.cellMask | kCell.cellMask; if (BitCount(cellMask) != 3) { continue; } // Confirmed a naked triple; but is it new? int bitMask = ~((1 << iCell.number) | (1 << jCell.number) | (1 << kCell.number)); bool excluded = false; int bit = 1; // Do any of the cells referenced in the cellMask have bits not in the bitMask? for (int cell = 0; (cell < N) && (cellMask != 0); ++cell, bit <<= 1) { if ((cellMask & bit) != 0) { cellMask &= ~bit; } else { continue; } int row = mPatterns[pattern, cell].row; int col = mPatterns[pattern, cell].col; Debug.Assert((mCells[row, col] & CONFIRMED) == 0); if ((mCells[row, col] & bitMask) != 0) { mCells[row, col] &= ~bitMask; excluded = true; } } if (excluded) { Debug.Print("Naked triple " + GetGroupName(~bitMask) + " in " + mPatternLabels[pattern]); return(true); } } }