public void SpawnEntity() { Possibility p = possibilities[possibilityIndex]; GameObject go = EntityManager.GenerateEntity(p.name, p.go, defaultMaterial); go.transform.position = where; }
public void AddPossibility(Possibility block) { if (block.Model == null) { Vector3 start = block.Map.GetRelativePosition(block.StartCoord), end = block.Map.GetRelativePosition(block.EndCoord); Vector3 scale = new Vector3(Math.Abs(end.X - start.X), Math.Abs(end.Y - start.Y), Math.Abs(end.Z - start.Z)); Matrix matrix = Matrix.CreateScale(scale) * Matrix.CreateTranslation(new Vector3(-0.5f) + (start + end) * 0.5f); ModelAlpha box = new ModelAlpha(); box.Filename.Value = "AlphaModels\\distortion-box"; box.Distortion.Value = true; box.Color.Value = new Vector3(2.8f, 3.0f, 3.2f); box.Alpha.Value = blockPossibilityInitialAlpha; box.Serialize = false; box.DrawOrder.Value = 11; // In front of water box.BoundingBox.Value = new BoundingBox(new Vector3(-0.5f), new Vector3(0.5f)); box.GetVector3Parameter("Scale").Value = scale; box.Add(new Binding <Matrix>(box.Transform, x => matrix * x, block.Map.Transform)); this.Entity.Add(box); block.Model = box; } List <Possibility> mapList; if (!this.possibilities.TryGetValue(block.Map, out mapList)) { mapList = new List <Possibility>(); possibilities[block.Map] = mapList; } mapList.Add(block); blockPossibilityLifetime = 0.0f; }
public void PredictPlatforms() { Queue <Prediction> predictions = new Queue <Prediction>(); Vector3 jumpVelocity = this.startSlowMo(predictions); float interval = this.getPredictionInterval(jumpVelocity.Length()); float[] lastPredictionHit = new float[] { 0.0f, 0.0f }; while (predictions.Count > 0) { Prediction prediction = predictions.Dequeue(); if (prediction.Time > lastPredictionHit[prediction.Level] + (interval * 1.5f)) { Possibility possibility = this.FindPlatform(prediction.Position); if (possibility != null) { lastPredictionHit[prediction.Level] = prediction.Time; this.AddPossibility(possibility); if (prediction.Level == 0) { this.predictJump(predictions, prediction.Position, jumpVelocity, prediction.Level + 1); } } } } }
public Heap(int[] primes) { arr = new Possibility[primes.Length+1]; for(int i = 1; i <arr.Length ; i ++){ arr[i] = new Possibility(primes[i-1],0); } }
public void InitInput(string content) { var splitContent = content.Split(new string[] { "\r\n" }, StringSplitOptions.None); int tileNumber = -1; List <string> grid = new List <string>(); foreach (var currentLine in splitContent) { if (currentLine.Contains("Tile ")) { tileNumber = int.Parse(currentLine.Replace("Tile ", "").TrimEnd(':')); } else if (string.IsNullOrEmpty(currentLine)) { _tiles.Add(tileNumber, new Tile(grid.ToArray(), tileNumber)); grid = new List <string>(); } else { grid.Add(currentLine); } } MaxSize = (int)Math.Sqrt(_tiles.Count); _solvedGrid = new Possibility[MaxSize, MaxSize]; }
public static bool TryImplementUniquenessConstraintForSquares( IReadOnlyPuzzle puzzle, ReadOnlySpan <Coordinate> squareCoordinates, ExactCoverGraph graph) { Span <bool> isConstraintSatisfiedAtIndex = stackalloc bool[graph.AllPossibleValues.Length]; if (!TryCheckForSetValues(puzzle, graph, squareCoordinates, isConstraintSatisfiedAtIndex)) { return(false); } Possibility?[]?[] squares = new Possibility[squareCoordinates.Length][]; for (int i = 0; i < squares.Length; i++) { squares[i] = graph.GetAllPossibilitiesAt(in squareCoordinates[i]); } for (int possibilityIndex = 0; possibilityIndex < isConstraintSatisfiedAtIndex.Length; possibilityIndex++) { if (isConstraintSatisfiedAtIndex[possibilityIndex]) { if (!TryDropPossibilitiesAtIndex(squares, possibilityIndex)) { return(false); } continue; } if (!TryAddObjectiveForPossibilityIndex(squares, possibilityIndex, graph, requiredCount: 1, objective: out _)) { return(false); } } return(true); }
public Heap(Possibility[] poss) { arr = new Possibility[poss.Length+1]; for(int i = 1; i <arr.Length ; i ++){ arr[i] = poss[i-1]; } }
public void Constructor_SetsValuesAsExpected() { var possibility = new Possibility(new Coordinate(1, 1), 2); Assert.Equal(new Coordinate(1, 1), possibility.Coordinate); Assert.Equal(2, possibility.Index); Assert.Equal(NodeState.UNKNOWN, possibility.State); }
public PossibilityChange(PlayerPossibility possibility, Possibility before, Possibility after, string reason, Player playerAsking, Player playerAnswering, DateTime dateTime) { Possibility = possibility; Before = before; After = after; Reason = reason; PlayerAsking = playerAsking; PlayerAnswering = playerAnswering; DateTime = dateTime; }
public void UpdatePossibility(Possibility possibility, string reason, Player asking, Player answering) { if (Possibility == possibility) { return; } _changes.Add(new PossibilityChange(this, Possibility, possibility, reason, asking, answering, DateTime.Now)); Possibility = possibility; }
internal static Possibility[] CreatePossibilities(Coordinate coordinate, int count) { var possibilities = new Possibility[count]; for (--count; count >= 0; --count) { possibilities[count] = new Possibility(coordinate, 0); } return(possibilities); }
private bool Equals(Possibility other) { if (ReferenceEquals(null, other)) { return(false); } return(Tile == other.Tile && Directions[0] == other.Directions[0] && Directions[1] == other.Directions[1] && Directions[2] == other.Directions[2] && Directions[3] == other.Directions[3]); }
private bool _TryConstrainToPossibleSets( ReadOnlySpan <Coordinate> toConstrain, IReadOnlyPuzzle puzzle, ExactCoverGraph graph, List <OptionalObjective> setsToOr) { Possibility?[]?[] unsetSquares = new Possibility[toConstrain.Length][]; BitVector alreadySet = new BitVector(); int numUnset = 0; for (int i = 0; i < toConstrain.Length; ++i) { var square = puzzle[in toConstrain[i]];
//Returns the index of the rolled possibility. public int Roll() { float from = 0; float to = 0; List <Thing> t = new List <Thing>(); for (int i = 0; i < list.Count; i++) { if (list[i].finished) { continue; } to += list[i].rarity; t.Add(new Thing(from, to, list[i])); from = to; } float randomNumber = Random.Range(0, to); int winningListIndex = -1; for (int i = 0; i < t.Count; i++) { if (t[i].isInside(randomNumber)) { winningListIndex = t[i].pos.index; break; } } if (winningListIndex == -1) { return(-1); } if (takeAwayPossibilityAfterRoll) { list[winningListIndex] = new Possibility(list[winningListIndex].index, list[winningListIndex].rarity, true); } return(winningListIndex); }
public void PredictWalls() { // Predict block possibilities Queue <Prediction> predictions = new Queue <Prediction>(); this.startSlowMo(predictions); Matrix rotationMatrix = Matrix.CreateRotationY(this.Rotation); Vector2 direction = new Vector2(-rotationMatrix.Forward.X, -rotationMatrix.Forward.Z); while (predictions.Count > 0) { Prediction prediction = predictions.Dequeue(); Possibility possibility = this.FindWall(prediction.Position, direction); if (possibility != null) { this.AddPossibility(possibility); break; } } }
/** * profilePossibility * This takes a ColorSequence and profiles the possibility. * This means that it calculates the worst-case scenario, where guessing this possibility leads to the largest number of remaining possible sequences. */ private Possibility profilePossibility(ColorSequence possibility, Possibility bestPossibility) { int maxPossibilities = 0; int maxW = 0; int maxB = 0; for (int w = 0; w <= 5; w++) { for (int b = 0; b <= 5; b++) { if (w + b > 5) continue; // skip the white/black combination if it's not possible int possibilitiesRemaining = calculatePossibilitiesLeftAfterAssumedResponse(possibility, w, b, bestPossibility.worstCaseSetCount); if (possibilitiesRemaining >= bestPossibility.worstCaseSetCount) { // aready worse than best possibility's count, so no point in continuing return new Possibility(possibilitiesRemaining, possibility, w, b); } if (possibilitiesRemaining > maxPossibilities) { maxPossibilities = possibilitiesRemaining; maxW = w; maxB = b; } } } return new Possibility(maxPossibilities, possibility, maxW, maxB); }
public void InstantiatePossibility(Possibility block) { block.Model.Delete.Execute(); List <Possibility> mapList = possibilities[block.Map]; mapList.Remove(block); if (mapList.Count == 0) { possibilities.Remove(block.Map); } bool regenerate = block.Map.Empty(block.StartCoord.CoordinatesBetween(block.EndCoord), false, false); foreach (Voxel.Coord c in block.StartCoord.CoordinatesBetween(block.EndCoord)) { Vector3 absolutePos = block.Map.GetAbsolutePosition(c); bool foundConflict = false; foreach (Voxel m2 in Voxel.ActivePhysicsVoxels) { if (m2 != block.Map && m2[absolutePos].ID != 0) { foundConflict = true; break; } } if (!foundConflict) { regenerate |= block.Map.Fill(c, Voxel.States.Blue); } } if (regenerate) { block.Map.Regenerate(); const float prePrime = 2.0f; // Front and back faces for (int x = block.StartCoord.X; x < block.EndCoord.X; x++) { for (int y = block.StartCoord.Y; y < block.EndCoord.Y; y++) { particleSystem.AddParticle(block.Map.GetAbsolutePosition(x, y, block.EndCoord.Z - 1), Vector3.Zero, -1.0f, prePrime); particleSystem.AddParticle(block.Map.GetAbsolutePosition(x, y, block.StartCoord.Z), Vector3.Zero, -1.0f, prePrime); } } // Left and right faces for (int z = block.StartCoord.Z; z < block.EndCoord.Z; z++) { for (int y = block.StartCoord.Y; y < block.EndCoord.Y; y++) { particleSystem.AddParticle(block.Map.GetAbsolutePosition(block.StartCoord.X, y, z), Vector3.Zero, -1.0f, prePrime); particleSystem.AddParticle(block.Map.GetAbsolutePosition(block.EndCoord.X - 1, y, z), Vector3.Zero, -1.0f, prePrime); } } // Top and bottom faces for (int z = block.StartCoord.Z; z < block.EndCoord.Z; z++) { for (int x = block.StartCoord.X; x < block.EndCoord.X; x++) { particleSystem.AddParticle(block.Map.GetAbsolutePosition(x, block.StartCoord.Y, z), Vector3.Zero, -1.0f, prePrime); particleSystem.AddParticle(block.Map.GetAbsolutePosition(x, block.EndCoord.Y - 1, z), Vector3.Zero, -1.0f, prePrime); } } AkSoundEngine.PostEvent(AK.EVENTS.PLAY_MAGIC_CUBE_STINGER, this.Entity); } }
public Thing(float from, float to, Possibility pos) { this.from = from; this.to = to; this.pos = pos; }
private static void Switch(Possibility[] arr, int i , int j) { var t = arr[i]; arr[i] = arr[j]; arr[j] = t; }
public void ReplaceMin(Possibility rep) { arr[1] = rep; PercolateDown(1); }
public void Set(int p, int i, int v) { dic[p] = new Possibility(v,i); this.minHeap.ReplaceMin(dic[p]); }
public Possibilities(int[] primes) { foreach(var p in primes){ var poss = new Possibility(p,0); dic.Add(p,poss); } this.minHeap = new Heap(dic.Values.ToArray()); }
public GhostPossibility(Ghost ghost, Possibility possibility) { Ghost = ghost; Possibility = possibility; }
public EvidencePossibility(EvidenceType type, Possibility possibility, EvidenceState originalState) { Type = type; Possibility = possibility; OriginalState = originalState; }
private TextColor GetHeaderTextColor(Possibility possibility) => possibility switch {
List<Possibility> FindPossibilitiesForMultiplyCage(int dimension) { List<Possibility> possibilities = new List<Possibility>(); List<int> primeFactors = Helper.PrimeFactors(TargetValue); primeFactors.Add(1); MultiSet multisetOfPrimes = new MultiSet(primeFactors); IEnumerable<Partition> partitions = multisetOfPrimes.Partition().Filter(CellCount, dimension); foreach (var partion in partitions) { Possibility newPossibility = new Possibility(partion); if (newPossibility.MaxRepeatCount <= this.RepeatCount && !possibilities.Contains(newPossibility, new SequenceComparer<Possibility>())) possibilities.Add(newPossibility); } return possibilities; }
List<Permutation> FindValidPermutationsForPossibility(Cage cage, Possibility possibility) { List<Permutation> validPerms = new List<Permutation>(); List<Permutation> perms = Helper.GetUniquePermutation(possibility.ToList<int>()); foreach (var permutation in perms) { Cage copyCage = cage.DeepCopy(); bool isPermutationValid = true; for (int i = 0; i < copyCage.Cells.Count; i++) { if (!copyCage.Cells[i].IsValueFeasible(permutation[i])) { isPermutationValid = false; break; } else { MarkCellAsSolved(copyCage.Cells[i], permutation[i], copyCage.Cells); } } if (isPermutationValid) validPerms.Add(permutation); } return validPerms; }
// play the game! private void play() { // convert GUI representation of code to AI representation of code byte[] seq = new byte[5]; for(int i = 0; i < DEPTH; i++) { seq[i] = (byte)(1 << mastermind.code[i]); } ColorSequence code = new ColorSequence(seq); // first guess is always the same because it is proven to be best in worst-case byte[] firstGuess = {1,1,2,4,8}; ColorSequence guess = new ColorSequence(firstGuess); Match m = calculateMatch(code, guess); if (showOnGui(guess, m)) return; current_set = restrictSet(guess, m.whiteHits, m.blackHits); for (int i = 1; i <= 8; i++) { mastermind.lblPossibilities.Text = "Possibilities: " + current_set.Count; mastermind.progressBar.Maximum = current_set.Count; mastermind.progressBar.Value = 0; Possibility bestPossibility = new Possibility(int.MaxValue, null, 0, 0); foreach (ColorSequence possibility in current_set) { Possibility profile = profilePossibility(possibility, bestPossibility); if (profile.worstCaseSetCount < bestPossibility.worstCaseSetCount) // found a better possibility { bestPossibility = profile; } //Console.WriteLine(bestPossibility.ToString()); mastermind.progressBar.Value += 1; Application.DoEvents(); } //Console.WriteLine(bestPossibility); m = calculateMatch(code, bestPossibility.sequence); if (showOnGui(bestPossibility.sequence, m)) return; current_set = restrictSet(bestPossibility.sequence, m.whiteHits, m.blackHits); } }
List<Possibility> FindPossibilitiesForAddCage(int dimension) { List<Possibility> possibilities = new List<Possibility>(); var inputSet = new List<int>(); for (int i = 0; i < RepeatCount; i++) inputSet.AddRange(Enumerable.Range(1, dimension)); foreach (var set in Helper.Powerset(inputSet, CellCount, TargetValue)) { Possibility newPossibility = new Possibility(set); if (!possibilities.Contains(newPossibility, new SequenceComparer<Possibility>())) possibilities.Add(newPossibility); } return possibilities; }