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;
}
