/// <summary> /// Constructor /// </summary> /// <param name="lane"></param> public StayInLaneState(ArbiterLane lane, Probability confidence, IState previous) { this.Lane = lane; this.internalLaneState = new InternalState(lane.LaneId, lane.LaneId, confidence); this.IgnorableWaypoints = new List<IgnorableWaypoint>(); this.CheckPreviousState(previous); }
/// <summary> /// </summary> private static float getPrediction(IEnumerable<string> pTokens, TokenCollection pFirst, TokenCollection pSecond) { Probability prob = new Probability(); foreach (string token in pTokens) { int firstCount = pFirst.get(token); int secondCount = pSecond.get(token); if (firstCount == 0 && secondCount == 0) { continue; } float probability = CalcProbability(prob, firstCount, pFirst.Sum, secondCount, pSecond.Sum); Console.WriteLine(@"{0}: [{1}] ({2}-{3}), ({4}-{5})", token, probability, firstCount, pFirst.Sum, secondCount, pSecond.Sum); } return prob.Combine(); }
public void ReturnTrueIfTheInstancesAreTheSameObject() { var probability = new Probability(0.25m); var otherProbability = probability; Assert.That(otherProbability, Is.EqualTo(probability)); }
public void ReturnFalseIfTheInstancesRepresentDifferentValues() { var probability = new Probability(0.25m); var otherProbability = new Probability(1/3); Assert.That(otherProbability, Is.Not.EqualTo(probability)); }
public void ReturnTrueIfTheInstancesRepresentTheSameValue() { var probability = new Probability(0.25m); var otherProbability = new Probability(0.25m); Assert.That(otherProbability, Is.EqualTo(probability)); }
public void ReturnThisProbabilityMultipliedByTheArgument(decimal firstProbability, decimal secondProbability) { var probability = new Probability(firstProbability); var combinedProbability = probability.CombinedWith(new Probability(secondProbability)); Assert.That(combinedProbability, Is.EqualTo(new Probability(firstProbability * secondProbability))); }
public void ReturnAPlusBLessAMultipliedByB(decimal a, decimal b) { var probabilityOfA = new Probability(a); var probabilityOfB = new Probability(b); var eitherEvent = probabilityOfA.Either(probabilityOfB); Assert.That(eitherEvent, Is.EqualTo(new Probability(a + b - (a*b)))); }
public void ShouldTestEquals() { var probabilityOne = new Probability(0.5); Assert.That(probabilityOne,Is.EqualTo(probabilityOne)); Assert.True(probabilityOne.Equals(new Probability(0.5))); Assert.False(probabilityOne.Equals(new Probability(1.0))); Assert.False(probabilityOne.Equals(null)); Assert.False(probabilityOne.Equals(new object())); }
public void Test_NaN() { Probability p = new Probability(); p.Add("one", 1.0); p.Add("two", 2.0); p.Add("three", double.NaN); Assert.AreEqual(2, p.Prob.Count); }
public CorrelationScoreTable(ScoreMethod method, int intensityBins, double[] binEdges) { _method = method; _binEdges = binEdges; IntensityBins = null; _intensityBinCount = intensityBins; WorstScore = new Probability<int>(0); _intensityHistogram = new Histogram<FitScore>(new CompareFitScoreByIntensity()); }
/// <summary> /// Calculates a probability value based on statistics from two categories /// </summary> private static float CalcProbability(Probability pProb, float pFirstCount, float pFirstTotal, float pSecondCount, float pSecondTotal) { const float s = 1f; const float x = .5f; float bw = pFirstCount / pFirstTotal; float gw = pSecondCount / pSecondTotal; float pw = ((bw) / ((bw) + (gw))); float n = pFirstCount + pSecondCount; float fw = ((s * x) + (n * pw)) / (s + n); pProb.Log(fw); return fw; }
public void Test_Serializing() { Probability p = new Probability(); p.Add("one", 1.0); p.Add("two", 2.0); p.Add("three", 3.0); Assert.AreEqual(3, p.Prob.Count); string str = p.ToString(); p = new Probability(str); Assert.AreEqual(3, p.Prob.Count); Assert.IsTrue(p.Prob.ContainsKey("one")); Assert.IsTrue(p.Prob.ContainsKey("two")); Assert.IsTrue(p.Prob.ContainsKey("three")); Assert.IsTrue(p.Prob.ContainsValue(1.0)); Assert.IsTrue(p.Prob.ContainsValue(2.0)); Assert.IsTrue(p.Prob.ContainsValue(3.0)); }
private void SpawnEnemy() { Instantiate(Probability.RandomInArray <GameObject>(enemyPrefabs), this.transform.position, Quaternion.identity, enemyHolder); numSpawns++; StartCoroutine(SpawnCooldown()); }
/// <summary> /// Initialization with values as parameters /// </summary> /// <param name="a">Input A</param> /// <param name="b">Input B</param> public EitherFunction(Probability a, Probability b) { A = a; B = b; }
private static Dist <int> NextBirthday(int distinctBirthdays) { var probabilityOfSharedBirthday = Probability.FromDecimal(Math.Min(distinctBirthdays, 365) / 365M); return(Distribution.OneOf <int>(distinctBirthdays, distinctBirthdays + 1, probabilityOfSharedBirthday)); }
protected void Awake() { _probability = new Probability(); _navMeshMapper = new NavMeshMapper(); }
/// <summary> /// Initialization with values as parameters /// </summary> /// <param name="a">Input A</param> /// <param name="b">Input B</param> public EitherFunction(decimal a, decimal b) { A = new Probability(a); B = new Probability(b); }
/// <summary> /// Constructor /// </summary> /// <param name="initial"></param> /// <param name="target"></param> public InternalState(ArbiterLaneId initial, ArbiterLaneId target) { this.Initial = initial; this.Target = target; this.Confidence = new Probability(0.8, 0.2); }
/// <summary> /// Creates a two dimensional array of all rank probabilities. /// </summary> /// <returns>Two dimensional array where the first dimension are ranks /// and the second dimension are ion types.</returns> public Probability<IonType>[,] GetProbabilities() { var ionTypes = IonTypes; var ranks = new Probability<IonType>[ionTypes.Length, MaxRanks]; for (int i = 0; i < ionTypes.Length; i++) { for (int j = 0; j < MaxRanks+1; j++) { var ionType = ionTypes[i]; ranks[i, j] = new Probability<IonType>(ionTypes[i], _rankTable[ionType][j], _rankTotals[j]); } } return ranks; }
public override void OnUpdate(int gameTime) { base.OnUpdate(gameTime); var position = Player.Position; if (!ScriptThread.GetVar <bool>("scr_hardcore").Value) { if (Function.Call <bool>(Hash.IS_OBJECT_NEAR_POINT, 0x9A3207B7, position.X, position.Y, position.Z, (float)random.Next(50, 200)) && position.DistanceTo(GameplayCamera.Position) < 700.0f && !flareMgr.CooldownActive && Probability.GetBoolean(0.0020f + intelligenceBias)) { flareMgr.Start(); } /*( if (Player.Vehicle.Ref.Health < Player.Vehicle.Ref.MaxHealth && * !extinguisher.CooldownActive && * Probability.GetBoolean(intelligenceBias) ) * { * ScriptMain.DebugPrint("use extinguisher (" + Name + ")"); * extinguisher.Start(); * }*/ } if (gameTime > state.NextDecisionTime) { // If we arent chasing a target, they have moved too far away, or have been chasing a target for a set amount of time, make a new decision. if (Player.ActiveTarget == null || Player.ActiveTarget.Ped.Ref.IsDead || position.DistanceTo(Player.ActiveTarget.Position) > 1000.0f || !Utility.IsPositionInArea(Player.ActiveTarget.Position, levelMgr.Level.Bounds.Min, levelMgr.Level.Bounds.Max) || Game.GameTime - attackStartedTime > 30000) { MakeDecision(); } state.SetNextDecisionTime(gameTime + random.Next(1000, 5000)); } switch (state.Status) { case AIStatus.FightOther: { if (Player.ActiveTarget != null) { if (Player.ActiveTarget.Position.DistanceTo(Player.Position) > 600.0f) { if (!tooFar) { var destination = Player.ActiveTarget.Position; Function.Call(Hash.TASK_PLANE_MISSION, Player.Ped.Ref, Player.Vehicle.Ref, 0, 0, destination.X, destination.Y, destination.Z, 6, 309.0, 26.0f, 200.0, 1000.0, 20.0); tooFar = true; } } else if (Function.Call <int>(Hash.GET_ACTIVE_VEHICLE_MISSION_TYPE, Player.Vehicle.Ref) != 6) { tooFar = false; Player.PersueTarget(Player.ActiveTarget); UI.ShowSubtitle("persuing " + Function.Call <int>(Hash.GET_ACTIVE_VEHICLE_MISSION_TYPE, Player.Vehicle.Ref).ToString()); } } break; } case AIStatus.RandomFlight: { if (position.DistanceTo(destination) < 15.0f) { SetRandomDestination(); ScriptMain.DebugPrint("Set new random destination for " + Player.Name); } else if (Player.Position.DistanceTo(sessionMgr.Current.Players[0].PlayerRef.Position) < 1000.0f && Player.Info.Sess.TeamNum != sessionMgr.Current.Players[0].TeamIdx) { Player.PersueTarget(sessionMgr.Current.Players[0].PlayerRef); state.Status = AIStatus.FightOther; } break; } } for (int i = 0; i < sessionMgr.Current.NumPlayers; i++) { if (gameTime - lastShotAtTime > 900) { var otherPlayer = sessionMgr.Current.Players[i]; if (otherPlayer.TeamIdx == Player.Info.Sess.TeamNum) { continue; } var p = otherPlayer.PlayerRef.Position; var direction = Vector3.Normalize(p - position); var otherHeading = otherPlayer.PlayerRef.Vehicle.Ref.Heading; if (Probability.GetBoolean(0.1f + intelligenceBias) && position.DistanceTo(p) < 400.0f) { Function.Call(Hash.SET_VEHICLE_SHOOT_AT_TARGET, Player.Ped.Ref, otherPlayer.PlayerRef.Vehicle.Ref, p.X, p.Y, p.Z); ScriptMain.DebugPrint("Shoot at target (" + Player.Name + " > " + otherPlayer.PlayerRef.Name + ") team idx:" + otherPlayer.PlayerRef.Info.Sess.TeamNum.ToString() + " sess team:" + otherPlayer.TeamIdx); lastShotAtTime = gameTime; } } } }
public int Compare(Probability <IonType> x, Probability <IonType> y) { return(String.Compare(x.Label.Name, y.Label.Name, StringComparison.Ordinal)); }
protected bool Equals(Probability other) { return rawProbability.Equals(other.rawProbability); }
public override int HandleProbabilisticChoice(Probability p0, Probability p1, Probability p2) { var choice = HandleProbabilisticChoice(3); switch (choice) { case 0: SetProbabilityOfLastChoice(p0); return(choice); case 1: SetProbabilityOfLastChoice(p1); return(choice); default: SetProbabilityOfLastChoice(p2); return(choice); } }
public Probability Either(Probability other) { return new Probability(rawProbability + other.rawProbability - (rawProbability * other.rawProbability)); }
private void UpdatePulledEntities(int gameTime, float maxDistanceDelta) { float verticalForce = ScriptThread.GetVar <float>("vortexVerticalPullForce"); float horizontalForce = ScriptThread.GetVar <float>("vortexHorizontalPullForce"); float topSpeed = ScriptThread.GetVar <float>("vortexTopEntitySpeed"); for (var e = 0; e < _activeEntityCount; e++) { var entity = _activeEntities[e].Entity; var dist = Vector2.Distance(entity.Position.Vec2(), _position.Vec2()); if (dist > maxDistanceDelta - 12.6f || entity.HeightAboveGround > 300.0f) { RemoveEntity(e); continue; } var targetPos = new Vector3(_position.X + _activeEntities[e].XBias, _position.Y + _activeEntities[e].YBias, entity.Position.Z); var direction = Vector3.Normalize(targetPos - entity.Position); var forceBias = Probability.NextFloat(); var force = ForceScale * (forceBias + forceBias / dist); if (_activeEntities[e].IsPlayer) { if (gameTime - _lastPlayerShapeTestTime > 1000) { var raycast = World.Raycast(entity.Position, targetPos, IntersectOptions.Map); _lastRaycastResultFailed = raycast.DitHitAnything; _lastPlayerShapeTestTime = gameTime; } if (_lastRaycastResultFailed) { continue; } verticalForce *= 1.45f; horizontalForce *= 1.5f; } if (entity.Model.IsPlane) { force *= 6.0f; verticalForce *= 6.0f; } // apply a directional force pulling them into the tornado... entity.ApplyForce(direction * horizontalForce, new Vector3(Probability.NextFloat(), 0, Probability.GetScalar())); var upDir = Vector3.Normalize(new Vector3(_position.X, _position.Y, _position.Z + 1000.0f) - entity.Position); // apply vertical forces entity.ApplyForceToCenterOfMass(upDir * verticalForce); var cross = Vector3.Cross(direction, Vector3.WorldUp); // move them along side the vortex. entity.ApplyForceToCenterOfMass(Vector3.Normalize(cross) * force * horizontalForce); Function.Call(Hash.SET_ENTITY_MAX_SPEED, entity.Handle, topSpeed); } }
/// <summary> /// Creates a new instance of <see cref="AssessmentSectionCategory"/>. /// </summary> /// <param name="categoryGroup">The input to calculate the derived macro stability inwards input.</param> /// <param name="lowerBoundary">The input to calculate the derived macro stability inwards input.</param> /// <param name="upperBoundary">The input to calculate the derived macro stability inwards input.</param> /// <exception cref="AssemblyToolKernelException">Thrown when <paramref name="lowerBoundary"/> is not a valid probability.</exception> /// <exception cref="AssemblyToolKernelException">Thrown when <paramref name="upperBoundary"/> is not a valid probability.</exception> /// <exception cref="AssemblyToolKernelException">Thrown when <paramref name="lowerBoundary"/> exceeds <paramref name="upperBoundary"/>.</exception> public AssessmentSectionCategory(AssessmentSectionCategoryGroup categoryGroup, Probability lowerBoundary, Probability upperBoundary) : base(categoryGroup, lowerBoundary, upperBoundary) { }
public void ReturnThisProbabilitySubtractedFrom1(decimal rawProbability) { var probability = new Probability(rawProbability); var inverseProbability = probability.InverseOf(); Assert.That(inverseProbability, Is.EqualTo(new Probability(1 - rawProbability))); }
public static void AssertEqualProbabilities(Probability expected, Probability actual) { TestBase.AssertEqualProbabilities(expected.ToDecimal(), actual); }
public Probability Either(Probability probability) { return new Probability(_probability + probability._probability - CombinedWith(probability)._probability); }
public static void AssertEqualProbabilities(decimal expected, Probability actual) { Assert.AreEqual(expected, actual); }
// calculates sensor model private Probability Et(int tp1, bool ut) { // standard probability of posterior agreeing with internal lane est Probability eStandard = new Probability(0.65, 0.35); // modify probabilities off of consistency Probability et = eStandard; // return return et; }
public static void AssertEqualProbabilities(Probability expected, Probability actual, double delta) { TestBase.AssertEqualProbabilities(expected.ToDouble(), actual, delta); }
/** * Returns all hexes that surround the given hex, in the map, at a given radius * Passing a non-positive value for the radius will simply yeild a singleton * containing the given hex. */ private List<HexScript> findArea(HexScript center, int radius, Probability variation) { List<HexScript> to_fill = new List<HexScript>(); to_fill.Add(center); // find remaining layers if (radius > 0) { List<HexScript> initial = new List<HexScript>(); initial.Add(center); addNextLayer(initial, to_fill, radius, variation); } return to_fill; }
public static void AssertEqualProbabilities(double expected, Probability actual) { AssertEqualProbabilities(expected, actual, 0); }
/// <summary> /// Returns the cumulative distribution function. /// </summary> /// <param name="k"></param> /// <returns></returns> public double CumulativeDistributionFunction(int k) { return(Probability.Binomial(k, n, p)); }
public static void AssertEqualProbabilities(double expected, Probability actual, double delta) { Assert.AreEqual(expected, actual.ToDouble(), delta); }
private void AddIonProbability(Probability<IonType> probability) { var name = probability.Label; if (_ionFrequencies.ContainsKey(name)) _ionFrequencies[name] += probability; else _ionFrequencies.Add(name, probability); }
public double Quantile(Probability p) => Mu + Sigma * (Pow(p, A) - Pow(1 - p, B));
private static int IndexOfProbabilityExceedingBound(IEnumerable <Probability> probabilities, Probability lowerBound) { return(probabilities .Select((p, k) => new KeyValuePair <int, Probability>(k, p)) .Where(item => item.Value > lowerBound) .Min(item => item.Key)); }
/// <summary> /// Returns the cumulative distribution function. /// </summary> public double cdf(double x) { return(Probability.Gamma(alpha, lambda, x)); }
public void MinimumGroupSizeWhereProbabilityOf2SharedBirthdaysExceedsBound() { var probOfSharedBirthdays = ComputeProbabilitiesOfSharedBirthdays(); Assert.AreEqual(15, IndexOfProbabilityExceedingBound(probOfSharedBirthdays, Probability.FromDecimal(.25M))); Assert.AreEqual(23, IndexOfProbabilityExceedingBound(probOfSharedBirthdays, Probability.FromDecimal(.5M))); Assert.AreEqual(32, IndexOfProbabilityExceedingBound(probOfSharedBirthdays, Probability.FromDecimal(.75M))); Assert.AreEqual(57, IndexOfProbabilityExceedingBound(probOfSharedBirthdays, Probability.FromDecimal(.99M))); Assert.AreEqual(70, IndexOfProbabilityExceedingBound(probOfSharedBirthdays, Probability.FromDecimal(.999M))); }
/** * Finds all hexes that are adjacent to any hex in prev_layer at a given radius from the hexes in prev_layer, that * do not exist in total, with no duplicates. Ideally, prev_layer is a subset of total. Passing a non-positive * radius will yield no change. Variation should be a float between 0.0 and 1.0 inclusive coupled with a static decay * value that will reduce the probability on susequent layer calls. Contrary to logic, the greater the variability * the greater the chance of a uniform shape being formed from the hexes in total. */ private void addNextLayer(List<HexScript> prev_layer, List<HexScript> total, int radius, Probability variation) { // based case if (radius <= 0) { return; } List<HexScript> cur_layer = new List<HexScript>(); // Find hexes, which have not already been found, adjacent to any hex in the previous layer foreach (HexScript hex in prev_layer) { // find all adjacent hexes for (int pos = 0; pos < 6; ++pos) { HexScript adj_hex = adjacentHexTo(hex, pos); if ( (variation == null || UnityEngine.Random.value <= variation.getProbability()) && adj_hex != null && !total.Contains(adj_hex)) { cur_layer.Add(adj_hex); total.Add(adj_hex); // add to total as well } } } // avoid cutting off the generation of the area because of an empty layer if (cur_layer.Count == 0) { cur_layer = prev_layer; } if (variation != null) { variation.reduce(); } // find the next layer addNextLayer(cur_layer, total, radius - 1, variation); }
public void can_calculate_probability_of_inverse_event() { var probability = new Probability(); Assert.Equal(0.4, probability.CalculateProbabilityOfInverse(0.6)); }
public double Quantile(Probability p) => - Log(1 - p) / Rate;
public Probability CombinedWith(Probability probability) { return new Probability(_probability * probability._probability); }
/// <summary> /// Creates a new instance of <see cref="FailureMechanismCategory"/>. /// </summary> /// <param name="categoryGroup">The input to calculate the derived macro stability inwards input.</param> /// <param name="lowerBoundary">The input to calculate the derived macro stability inwards input.</param> /// <param name="upperBoundary">The input to calculate the derived macro stability inwards input.</param> /// <exception cref="AssemblyToolKernelException">Thrown when <paramref name="lowerBoundary"/> is not a valid probability.</exception> /// <exception cref="AssemblyToolKernelException">Thrown when <paramref name="upperBoundary"/> is not a valid probability.</exception> /// <exception cref="AssemblyToolKernelException">Thrown when <paramref name="lowerBoundary"/> exceeds <paramref name="upperBoundary"/>.</exception> public FailureMechanismCategory(FailureMechanismCategoryGroup categoryGroup, Probability lowerBoundary, Probability upperBoundary) : base(categoryGroup, lowerBoundary, upperBoundary) { }
protected bool Equals(Probability other) { return _probability == other._probability; }
public override string ToString() { return($"{HomeTeam} - {AwayTeam} - {Probability.ToString("0.00")}% - {EnumUtility.GetDescriptionFromEnumValue(Result)}"); }
/// <summary> /// Constructor /// </summary> /// <param name="initial"></param> /// <param name="target"></param> public InternalState(ArbiterLaneId initial, ArbiterLaneId target, Probability confidence) { this.Initial = initial; this.Target = target; this.Confidence = confidence; }
public TestCategoryBase(double category, Probability lowerLimit, Probability upperLimit) : base(category, lowerLimit, upperLimit) { }
// f1:t+1 = sFORWARD(f1:t, et+1) private Probability Forward() { // get t and t+1 int tp1 = this.FilteredEstimate.Count; int t = tp1 - 1; // check numbering if (t < 0) return new Probability(0.9, 0.2); // transition Probability transition = new Probability(0.7, 0.3); // calculate prediction from t-1 to t // sum(xt): P(Xt+1|xt)P(xt|e1:t) Probability prediction = transition * FilteredEstimate[t]; prediction = new Probability(Math.Max(prediction.T, 0.00001), Math.Max(prediction.F, 0.00001), true); // calculate boolean evidence for t+1 bool ut = this.Ut(PosteriorEvidence[tp1], tp1); //Probability ct = this.Ct(this.PosteriorEvidence, ut); // calculate sensor model given the estiamtes agree Probability evidence = ut ? new Probability(0.9, 0.2) : new Probability(0.2, 0.9); //update with evidence for time t, calculate P(et+1|Xt+1) * (PreviousStep) //Probability filtered = ut ? et * prediction : et.Invert() * prediction; Probability filtered = evidence * prediction; // normalize Probability nFiltered = filtered.Normalize(); // return return nFiltered; }
public double Quantile(Probability p) => Mean + StandardDeviation * Constants.Sqrt2 * ErrorFunction.InverseValue(2 * p - 1);
public void can_calculate_probability_of_either_events() { var probability = new Probability(); Assert.Equal(0.8, probability.CalculateProbabilityOfEither(0.6, 0.5)); }
public double Quantile(Probability p) => inverseCdf.GetValue(p);
public double Quantile(Probability p) => Min + p * (Max - Min);
static public void Learn() { int threadCount; int threadCount2; ThreadPool.GetMaxThreads(out threadCount, out threadCount2); Console.WriteLine("スレッド数は" + threadCount + "です。"); Console.WriteLine("世代数を入力してください。"); int generationDestination = int.Parse(Console.ReadLine()); Console.WriteLine("学習を開始します。"); int nowGenerationIndex = 0; int index = 0; TetrisEnvironment.MinoKind[] nexts = new TetrisEnvironment.MinoKind[5]; List <TetrisEnvironment.MinoKind> _leftMinoBag = new List <TetrisEnvironment.MinoKind>(); Chromosome[] nowChromosome = new Chromosome[generationDestination]; const int FrameMax = 10800; int[,] field = new int[10, 25]; Random random = new Random(); while (true) { for (int i = 0; i < generationDestination; i++) { float[] values = new float[11]; values[0] = random.Next(-100, 155); values[1] = random.Next(-100, 155); values[2] = random.Next(-100, 155); values[3] = random.Next(-100, 155); values[4] = random.Next(-100, 155); values[5] = random.Next(-100, 155); values[6] = random.Next(-100, 155); values[7] = random.Next(-100, 155); values[8] = random.Next(-100, 155); values[9] = random.Next(-100, 155); values[10] = random.Next(-100, 155); nowChromosome[i].chromosome = CreateChromosome(values); } Label: var values2 = DecodeChromosome(nowChromosome[index].chromosome); NewEvaluation.h_sumofheight = values2[0]; NewEvaluation.h_dekoboko = values2[1]; NewEvaluation.h_holeCount = values2[2]; NewEvaluation.h_holeup1 = values2[3]; NewEvaluation.h_holeup2 = values2[4]; NewEvaluation.h_holeup3 = values2[5]; NewEvaluation.h_holeup4 = values2[6]; NewEvaluation.h_line1 = values2[7]; NewEvaluation.h_line2 = values2[8]; NewEvaluation.h_line3 = values2[9]; NewEvaluation.h_line4 = values2[10]; for (int x = 0; x < 10; x++) { for (int y = 0; y < 25; y++) { field[x, y] = 0; } } Console.Clear(); Console.WriteLine($"{nowGenerationIndex}世代 {index}/{generationDestination}\r\n\r\n"); Console.WriteLine($"現在の評価\r\n" + $"高さ合計:{ NewEvaluation.h_sumofheight}\r\n" + $"1ライン消し:{ NewEvaluation.h_line1}\r\n" + $"2ライン消し:{ NewEvaluation.h_line2}\r\n" + $"3ライン消し:{ NewEvaluation.h_line3}\r\n" + $"4ライン消し:{ NewEvaluation.h_line4}\r\n" + $"でこぼこ:{ NewEvaluation.h_dekoboko}\r\n" + $"穴:{ NewEvaluation.h_holeCount}\r\n" + $"穴の上ミノ1:{ NewEvaluation.h_holeup1}\r\n" + $"穴の上ミノ2:{ NewEvaluation.h_holeup2}\r\n" + $"穴の上ミノ3:{ NewEvaluation.h_holeup3}\r\n" + $"穴の上ミノ4:{ NewEvaluation.h_holeup4}\r\n"); TetrisEnvironment.UpdateNexts(nexts, _leftMinoBag); TetrisEnvironment.UpdateNexts(nexts, _leftMinoBag); TetrisEnvironment.UpdateNexts(nexts, _leftMinoBag); TetrisEnvironment.UpdateNexts(nexts, _leftMinoBag); TetrisEnvironment.UpdateNexts(nexts, _leftMinoBag); var minotemp = TetrisEnvironment.UpdateNexts(nexts, _leftMinoBag); TetrisEnvironment.Mino nowMino = TetrisEnvironment.CreateMino(minotemp); bool canhold = true; TetrisEnvironment.MinoKind?hold = new TetrisEnvironment.MinoKind?(); int frameCount = 0; int score = 0; int ren = 0; bool backtoback = false; while (true) { var way = NewTetrisAI.Find(field, (int)nowMino.kind, Utility.Enum2IntArray(new TetrisEnvironment.MinoKind[1] { nexts[0] }), 0, (int?)hold, canhold); way.way = way.way.Substring(0, way.way.IndexOf('5') + 1); foreach (char action in way.way) { switch (int.Parse(action.ToString())) { case (int)TetrisEnvironment.Move.SoftDrop: if (TetrisEnvironment.CheckValidPosition(field, nowMino.positions, new TetrisEnvironment.Vector2(0, -1))) { nowMino.positions[0] += new TetrisEnvironment.Vector2(0, -1); nowMino.positions[1] += new TetrisEnvironment.Vector2(0, -1); nowMino.positions[2] += new TetrisEnvironment.Vector2(0, -1); nowMino.positions[3] += new TetrisEnvironment.Vector2(0, -1); frameCount += MoveFrame; } break; case (int)TetrisEnvironment.Move.HardDrop: frameCount += MinoSet; canhold = true; int count = 0; while (true) { if (TetrisEnvironment.CheckValidPosition(field, nowMino.positions, new TetrisEnvironment.Vector2(0, count))) { count--; } else { count++; break; } } nowMino.positions[0] += new TetrisEnvironment.Vector2(0, count); nowMino.positions[1] += new TetrisEnvironment.Vector2(0, count); nowMino.positions[2] += new TetrisEnvironment.Vector2(0, count); nowMino.positions[3] += new TetrisEnvironment.Vector2(0, count); foreach (var position in nowMino.positions) { field[position.x, position.y] = 1; } //ミノ消去ANDスコア加算 int clearedCount = TetrisEnvironment.CheckLine(field); if (clearedCount == 4) { backtoback = true; } else { backtoback = false; } if (clearedCount == 0) { ren = 0; } else { ren++; } TetrisEnvironment.UpdateScore(clearedCount, ren, ref score, backtoback); var temp2 = TetrisEnvironment.UpdateNexts(nexts, _leftMinoBag); nowMino = TetrisEnvironment.CreateMino(temp2); if (!TetrisEnvironment.CheckValidPosition(field, nowMino.positions, TetrisEnvironment.Vector2.Zero) || frameCount >= FrameMax) { //死亡 if (index == generationDestination - 1) { //次の世代に移行 List <Chromosome> newChromosomes = new List <Chromosome>(); List <Chromosome> tempList = new List <Chromosome>(); nowChromosome[index].eval = score; tempList.AddRange(nowChromosome); tempList.Sort((a, b) => b.eval.CompareTo(a.eval)); score = 0; //エリート方式で追加 for (int i = 0; i < generationDestination - 3; i++) { newChromosomes.Add(new Chromosome(0, tempList[i].chromosome)); } newChromosomes.Add(new Chromosome(0, GeneticAlgorithm.TwoPointCrossOver(tempList[0].chromosome, tempList[1].chromosome))); newChromosomes.Add(new Chromosome(0, GeneticAlgorithm.TwoPointCrossOver(tempList[0].chromosome, tempList[2].chromosome))); if (Probability.Percent(3)) { newChromosomes.Add(new Chromosome(0, GeneticAlgorithm.Mutation(tempList[0].chromosome))); } else { newChromosomes.Add(new Chromosome(0, tempList[0].chromosome)); } nowChromosome = newChromosomes.ToArray(); nowGenerationIndex++; index = 0; } else { nowChromosome[index].eval = score; } index++; goto Label; } break; case (int)TetrisEnvironment.Move.Hold: if (canhold) { canhold = false; if (hold == null) { hold = nowMino.kind; var temp = TetrisEnvironment.UpdateNexts(nexts, _leftMinoBag); nowMino = TetrisEnvironment.CreateMino(temp); } else { var temp = nowMino.kind; nowMino = TetrisEnvironment.CreateMino((TetrisEnvironment.MinoKind)hold); hold = temp; } } break; case (int)TetrisEnvironment.Move.Left: if (TetrisEnvironment.CheckValidPosition(field, nowMino.positions, TetrisEnvironment.Vector2.MinusX1)) { nowMino.positions[0] += TetrisEnvironment.Vector2.MinusX1; nowMino.positions[1] += TetrisEnvironment.Vector2.MinusX1; nowMino.positions[2] += TetrisEnvironment.Vector2.MinusX1; nowMino.positions[3] += TetrisEnvironment.Vector2.MinusX1; frameCount += MoveFrame; } break; case (int)TetrisEnvironment.Move.LeftRotate: if (TetrisEnvironment.RotateMino(TetrisEnvironment.Move.LeftRotate, ref nowMino, field)) { frameCount += MoveFrame; } break; case (int)TetrisEnvironment.Move.Right: if (TetrisEnvironment.CheckValidPosition(field, nowMino.positions, TetrisEnvironment.Vector2.X1)) { nowMino.positions[0] += TetrisEnvironment.Vector2.X1; nowMino.positions[1] += TetrisEnvironment.Vector2.X1; nowMino.positions[2] += TetrisEnvironment.Vector2.X1; nowMino.positions[3] += TetrisEnvironment.Vector2.X1; frameCount += MoveFrame; } break; case (int)TetrisEnvironment.Move.RightRotate: if (TetrisEnvironment.RotateMino(TetrisEnvironment.Move.RightRotate, ref nowMino, field)) { frameCount += MoveFrame; } break; } //TetrisEnvironment.Print(field, nowMino.positions, false); //Console.WriteLine("現在のミノ"); //Console.Write(nowMino.kind + "\r\n"); //Console.WriteLine("ネクスト"); //Console.Write(nexts[0]); //Console.Write(nexts[1]); //Console.Write(nexts[2]); //Console.Write(nexts[3]); //Console.Write(nexts[4] + "\r\n"); //Console.WriteLine("ホールド"); //Console.WriteLine(hold + "\r\n"); //Thread.Sleep(10); ////Console.ReadKey(); } } } }