public void CheckSells(int x, int y) { PossiblePositions[] position = new PossiblePositions[8]; position[0].X = new List <int>(); position[0].Y = new List <int>(); position[0].X.Add(x); position[0].Y.Add(y); int[] positionIndex = new int[8] { 0, 0, 0, 0, 0, 0, 0, 0 }; int n = 1, countRecursionRuns = 0; while (n < 8) { position[n].X = new List <int>(); position[n].Y = new List <int>(); int countPosiblePositions = 0; ClearPossiblePosiitons(position, n); SetPossiblePositions(position, n, ref countPosiblePositions); if (countPosiblePositions > 0) { PlaceQueen(position[n].X[0], position[n].Y[0]); n++; } else { PlaceAgain(position, ref n, ref countPosiblePositions, ref countRecursionRuns, positionIndex); } } }
private void fillPossiblePositionOnMove(PossiblePositions possibility, Action action, bool[,] islands, VisitedState[,] derivedVisisted) { var dX = -S.MoveX(action.direction); var dY = -S.MoveY(action.direction); for (int i = -1; i <= width; i++) { for (int j = -1; j <= height; j++) { var x = dX >= 0 ? i : width - 1 - i; var y = dY >= 0 ? j : height - 1 - j; if (S.isOutOfBoundsOrIsland(islands, x, y)) { if (!S.isOutOfBoundsOrIsland(islands, x + dX, y + dY) && possibility.map[x + dX, y + dY]) { possibility.total -= 1; } continue; } if (S.isOutOfBoundsOrIsland(islands, x + dX, y + dY)) { possibility.map[x, y] = false; } else { possibility.map[x, y] = possibility.map[x + dX, y + dY]; } if (derivedVisisted[x, y] == VisitedState.fresh) { derivedVisisted[x, y] = VisitedState.old; } } } }
public FootballPlayer(bool offense, bool defense, bool specialTeams, PossiblePositions positions) { Offense = offense; Defense = defense; SpecialTeams = specialTeams; Positions = positions; }
public PossiblePositions Clone() { var result = new PossiblePositions(); result.map = map.Clone() as bool[, ]; result.total = total; return(result); }
public void CheckNoPossibilityOverVisited(VisitedState[,] derivedVisited, PossiblePositions possibility) { for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { if (derivedVisited[x, y] == VisitedState.old && possibility.map[x, y]) { possibility.total--; possibility.map[x, y] = false; } } } }
public void processEnemyMine(ProbableMines enemyProbableMines, PossiblePositions possibility, Action action) { var mine = new Mine(); for (var x = 0; x < width; ++x) { for (var y = 0; y < width; ++y) { if (possibility.map[x, y]) { } } } }
public void processSilence(Action action, bool[,] reachSilence, PossiblePositions possibility, bool[,] islands, PathMark[,] recordedPath) { for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { reachSilence[x, y] = false; } } for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { if (possibility.map[x, y]) { foreach (var dir in S.possibleDirections) { var dX = S.MoveX(dir); var dY = S.MoveY(dir); for (int k = 1; k <= 4; k++) { if (S.isOutOfBoundsOrIsland(islands, x + dX * k, y + dY * k) || recordedPath[S.pathCenterX + dX * k, S.pathCenterY + dY * k].visited) { break; } reachSilence[x + dX * k, y + dY * k] = true; } } } } } for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { if (reachSilence[x, y] && !possibility.map[x, y]) { possibility.map[x, y] = true; ++possibility.total; } } } //TODO: implement branching instead of erasing memory here: S.EraseRecordedPath(recordedPath); }
private void MarkVisitedPath(VisitedState[,] possibleVisited, PathMark[,] path, PossiblePositions possibility) { var targetX = 0; var targetY = 0; var found = false; for (int x = 0; x < height && !found; x++) { for (int y = 0; y < width && !found; y++) { if (possibility.map[x, y]) { targetX = x; targetY = y; found = true; } } } MarkVisitedPathRecurs(possibleVisited, path, targetX, targetY, 0, 0); possibleVisited[targetX, targetY] = VisitedState.fresh; }
public void processSurface(PossiblePositions posibility, Action action, PathMark[,] recordedPath, bool[,] islands, VisitedState[,] derivedPath) { posibility.total = 0; S.SectorToCoord(action.sector, out int minX, out int maxX, out int minY, out int maxY); for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { if (x < minX || x > maxX || y < minY || y > maxY || S.isOutOfBoundsOrIsland(islands, x, y)) { posibility.map[x, y] = false; } else if (posibility.map[x, y]) { posibility.total += 1; } derivedPath[x, y] = VisitedState.unknow; } } S.EraseRecordedPath(recordedPath); }
private void processMove(PossiblePositions possibility, Action action, bool[,] islands, PathMark[,] recordedPath, VisitedState[,] derivedVisisted) { fillPossiblePositionOnMove(possibility, action, islands, derivedVisisted); var dX = S.MoveX(action.direction); var dY = S.MoveY(action.direction); for (int x = dX >= 0 ? 0 : S.pathWidth - 1; dX >= 0 ? x < S.pathWidth : x >= 0; x += (dX >= 0 ? 1 : -1)) { for (int y = dY >= 0 ? 0 : S.pathHeight - 1; dY >= 0 ? y < S.pathHeight : y >= 0; y += (dY >= 0 ? 1 : -1)) { if (x + dX < 0 || x + dX >= S.pathWidth - 1 || y + dY < 0 || y + dY >= S.pathHeight - 1) { recordedPath[x, y].visited = false; recordedPath[x, y].processed = false; } else { recordedPath[x, y] = recordedPath[x + dX, y + dY]; } } } recordedPath[width - 1, height - 1].visited = true; recordedPath[width - 1, height - 1].processed = false; }
private void processDamageImpact(List <Action> damageActions, int targetOldHealth, int targetNewHealth, List <Action> targetActions, PossiblePositions targetPossibility) { if (targetOldHealth != -1) { var surface = targetActions.Any(a => a.type == ActionType.surface); var dif = targetNewHealth - targetOldHealth - (surface ? 1 : 0); for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { var shouldErase = false; if (damageActions.Count == 1) { if (dif == 2 && (x != damageActions[0].x || y != damageActions[0].y)) { shouldErase = true; } else if (dif == 1 && (Math.Abs(x - damageActions[0].x) > 1 || Math.Abs(y - damageActions[0].y) > 1)) //hit, but it's too far { shouldErase = true; } else if (dif == 1 && x == damageActions[0].x && y == damageActions[0].y)//hit but not a direct center { shouldErase = true; } else if (dif == 0 && Math.Abs(x - damageActions[0].x) <= 1 && Math.Abs(y - damageActions[0].y) <= 1) //didn't hit { shouldErase = true; } } else { if (dif == 4 && (x != damageActions[0].x || y != damageActions[0].y)) //double direct hit. should be the same spot { shouldErase = true; } else if (dif == 3 && (x != damageActions[0].x || y != damageActions[0].y) && (x != damageActions[1].x || y != damageActions[1].y)) // at least on direct hit, should be on the spot of 1 action { shouldErase = true; } else if (dif == 2 && (x != damageActions[0].x || y != damageActions[0].y) && (x != damageActions[1].x || y != damageActions[1].y))//not direct hit { shouldErase = true; } else if (dif == 2 && !(Math.Abs(x - damageActions[0].x) <= 1 && Math.Abs(y - damageActions[0].y) <= 1 && Math.Abs(x - damageActions[1].x) <= 1 && Math.Abs(y - damageActions[1].y) <= 1))//and not close to both shots simulteniously { shouldErase = true; } else if (dif == 1 && (Math.Abs(x - damageActions[0].x) > 1 || Math.Abs(y - damageActions[0].y) > 1) && (Math.Abs(x - damageActions[1].x) > 1 || Math.Abs(y - damageActions[1].y) > 1)) // not close to any { shouldErase = true; } else if (dif == 0 && (Math.Abs(x - damageActions[0].x) <= 1 && Math.Abs(y - damageActions[0].y) <= 1) && (Math.Abs(x - damageActions[1].x) <= 1 || Math.Abs(y - damageActions[1].y) <= 1)) // no hit, but it's close to some damage center { shouldErase = true; } } if (shouldErase) { if (targetPossibility.map[x, y]) { targetPossibility.total -= 1; } targetPossibility.map[x, y] = false; } } } } }
private void processFireTorpedo(bool[,] islands, int[,] reachTorpedo, Action action, PossiblePositions atackerPossibility) { for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { reachTorpedo[x, y] = 0; } } fillPossibleFireTorpedoPositions(islands, reachTorpedo, action.x, action.y, 5); for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { if (reachTorpedo[x, y] == 0) { if (atackerPossibility.map[x, y]) { atackerPossibility.total -= 1; } atackerPossibility.map[x, y] = false; } } } }