private static Points RotateY(Points points, double sinDeg, double cosDeg) { double _x = (points.x * cosDeg) + (points.z * sinDeg); double _z = (points.x * -sinDeg) + (points.z * cosDeg); return new Points(_x, points.y, _z); }
private static Points RotateX(Points points, double sinDeg, double cosDeg) { double _y = (points.y * cosDeg) + (points.z * sinDeg); double _z = (points.y * -sinDeg) + (points.z * cosDeg); return new Points(points.x, _y, _z); }
private static Points RotateZ(Points points, double sinDeg, double cosDeg) { double _x = (points.x * cosDeg) + (points.y * sinDeg); double _y = (points.x * -sinDeg) + (points.y * cosDeg); return new Points(_x, _y, points.z); }
private static Vector2 FindPosition(Rectangle area, Points point) { switch (point) { case Points.Left: return new Vector2(area.Left, area.Top + (area.Height / 2)); case Points.Right: return new Vector2(area.Right, area.Top + (area.Height / 2)); case Points.Top: return new Vector2(area.Left + (area.Width / 2), area.Top); case Points.Bottom: return new Vector2(area.Left + (area.Width / 2), area.Bottom); case Points.Centre: return new Vector2(area.Center.X, area.Center.Y); case Points.TopLeft: return new Vector2(area.X, area.Y); case Points.TopRight: return new Vector2(area.X + area.Width, area.Y); case Points.BottomLeft: return new Vector2(area.X, area.Y + area.Height); case Points.BottomRight: return new Vector2(area.X + area.Width, area.Y + area.Height); default: return Vector2.Zero; } }
/// <summary> /// Creates a new instance. /// </summary> public HeatmapPlotValue() { data = new Points<HeatPoint>(); points.Add(data); ColorPalette = ColorPalettes.Hot; XLabel = "Column"; YLabel = "Row"; }
public void Init(Gamefield gamefield) { this.Gamefield = gamefield; PointSystem = Gamefield.PointSystem; Reset(); OnDestroy(); OnInit(); InvokeTurnsChanged(); }
public static Points[,] RotateZ(Points[,] points, double deg) { double radDeg = (Math.PI * deg) / 180.0; double cosDeg = Math.Cos(radDeg); double sinDeg = Math.Sin(radDeg); for (int i = 0; i < points.GetLength(0); i++) for (int j = 0; j < points.GetLength(1); j++) points[i, j] = RotateZ(points[i, j], sinDeg, cosDeg); return points; }
public void Apply(ref ControlArea area, Rectangle parentArea, Points anchoredPoints) { if (AnchorControl != null) parentArea = AnchorControl.Area; Vector2 pointOnSelf = FindPosition(area.ToRectangle(), Start); Vector2 pointOnParent = FindPosition(parentArea, End); TranslateArea(ref area, pointOnParent - pointOnSelf + Offset, anchoredPoints); }
public static Points[,] Perspective(Points[,] points) { const double Zk = 200; const double Zpl = 10; for (int i = 0; i < points.GetLength(0); i++) for (int j = 0; j < points.GetLength(1); j++) { double perspective = (Zk - Zpl) / (Zk - points[i, j].z); points[i, j] = new Points(points[i, j].x * perspective, points[i, j].y * perspective, points[i, j].z - Zpl); } return points; }
public void ShowPoints(Points points) { var hub = GameObject.Find("PrefabHub").GetComponent<PrefabHub>(); _ten = hub.PointTextures[0]; _twentyFive = hub.PointTextures[1]; _fifty = hub.PointTextures[2]; _mulTwo = hub.PointTextures[3]; _mulFive = hub.PointTextures[4]; _mulTen = hub.PointTextures[5]; PowerUpPrefab = hub.PowerUpPrefab; var pu = (GameObject) GameObject.Instantiate(PowerUpPrefab, PointGiverObject.transform.position + new Vector3(Random.Range(-4.0f, 4.0f), Random.Range(-4.0f, 4.0f) + 2.0f, Random.Range(-4.0f, 4.0f)), Quaternion.Euler(27.33f, 226.9f, 0.0f)); float scale = 1.0f; switch (points) { case Points.Ten: scale = Random.Range (0.7f, 1.3f); pu.GetComponent<PowerUpSprite>().UiTexture = _ten; break; case Points.TwentyFive: pu.GetComponent<PowerUpSprite>().UiTexture = _twentyFive; scale = Random.Range (0.7f, 1.3f); break; case Points.Fifty: pu.GetComponent<PowerUpSprite>().UiTexture = _fifty; scale = Random.Range (0.7f, 1.3f); break; case Points.MulTwo: pu.GetComponent<PowerUpSprite>().UiTexture = _mulTwo; scale = Random.Range (1.7f, 2.3f); break; case Points.MulFive: pu.GetComponent<PowerUpSprite>().UiTexture = _mulFive; scale = Random.Range (1.7f, 2.3f); break; case Points.MulTen: pu.GetComponent<PowerUpSprite>().UiTexture = _mulTen; scale = Random.Range (1.7f, 2.3f);; break; default: pu.GetComponent<PowerUpSprite>().UiTexture = _ten; break; } pu.transform.localScale = new Vector3(scale, scale, scale); }
/// <summary> /// Creates a new SurfacePlot. /// </summary> public SurfacePlotValue() { data = new Points<Vertex>(); ColorPalette = ColorPalettes.Jet; XLabel = "X"; YLabel = "Y"; ZLabel = "Z"; points.Add(data); IsMesh = false; IsSurf = true; MeshThickness = 1.0; Color = "#444444"; ShowLegend = false; }
public Points GetAlternativeWaySegments(Car car) { var result = new Points(); var myCell = GetCell(car.X, car.Y); result.Add(new Point(car)); Cell prevCell = null; var passedWayPoints = new List<Cell>(); for (var e = 1; result.Count < 5; e++) { var nextWp = GetNextWayPoint(car, e); for (var curCell = myCell; !curCell.Equals(nextWp); ) { var nextCell = DijkstraNextCell(curCell, nextWp, prevCell == null ? new Cell[] { } : new[] { prevCell }); var nextCenter = GetCenter(nextCell); for (var i = 0; i < result.Count; i++) { if (CheckVisibilityAndWp(car, result[i], nextCenter, passedWayPoints)) { result.RemoveRange(i + 1, result.Count - i - 1); break; } } result.Add(nextCenter); prevCell = curCell; curCell = nextCell; } myCell = nextWp; passedWayPoints.Add(nextWp); } var extended = ExtendWaySegments(result, 100); result.Clear(); passedWayPoints.Clear(); foreach (var t in extended) { if (result.Count > 0 && result.Last().Equals(t)) continue; if (GetNextWayPoint(car).Equals(GetCell(t))) passedWayPoints.Add(GetCell(t)); while (result.Count > 1 && CheckVisibilityAndWp(car, result[result.Count - 2], t, passedWayPoints)) result.Pop(); result.Add(t); } return result; }
// Use this for initialization void Awake () { playerPoints = new ArrayList(); fileWay = Application.persistentDataPath + "/points.dat"; medicFileWay = Application.persistentDataPath + "/MedicData.txt"; Debug.Log(medicFileWay); #region "Singleton method" if (stateGame == null) { stateGame = this; DontDestroyOnLoad(gameObject); } else { Destroy(gameObject); } #endregion }
private void TranslateArea(ref ControlArea area, Vector2 translation, Points anchoredPoints) { // an anchor can move a side if it has direct control of that side // or it can move the opposite side is that one has no direct anchors // or it can move both of the other 2 sides if neither of those have direct anchors. var leftOrRightAnchored = EitherSelected(anchoredPoints, Points.Left, Points.Right); var topOrBottomAnchored = EitherSelected(anchoredPoints, Points.Top, Points.Bottom); // left and right if (Start.Selected(Points.Left) || (Start.Selected(Points.Right) && !anchoredPoints.Selected(Points.Left)) || !leftOrRightAnchored) area.Left += (int)translation.X; if (Start.Selected(Points.Right) || (Start.Selected(Points.Left) && !anchoredPoints.Selected(Points.Right)) || !leftOrRightAnchored) area.Right += (int)translation.X; // top and bottom if (Start.Selected(Points.Top) || (Start.Selected(Points.Bottom) && !anchoredPoints.Selected(Points.Top)) || !topOrBottomAnchored) area.Top += (int)translation.Y; if (Start.Selected(Points.Bottom) || (Start.Selected(Points.Top) && !anchoredPoints.Selected(Points.Bottom)) || !topOrBottomAnchored) area.Bottom += (int)translation.Y; }
private float GetPoints(string teamToCheck, Points pointsToAdd, IEnumerable<GameDto> gameDtos) { var result = .0f; var streak = 0; var games = gameDtos.OrderByDescending(g => g.Date).Take(GameCount).ToArray(); // Check if enough data exists if (games.Length < GameCount) { throw new LogicException("Not enough games for both teams"); } foreach (var game in games) { var scoreToCheck = string.Equals(game.Team1, teamToCheck, StringComparison.CurrentCultureIgnoreCase) ? game.Score1 : game.Score2; var scoreToCheckAgainst = string.Equals(game.Team2, teamToCheck, StringComparison.CurrentCultureIgnoreCase) ? game.Score1 : game.Score2; // Team won a single game if (scoreToCheck > scoreToCheckAgainst) { // Add winning game result += pointsToAdd.Victory; streak += 1; } // Team lost a single game else { // Add winning streak result += streak*pointsToAdd.Streak; streak = 0; } } // Add remaining streaks return result + streak*pointsToAdd.Streak; }
public unsafe void Read(Action <Points> callback) { using (MemoryStream FS = new MemoryStream(System.IO.File.ReadAllBytes(File))) //using (System.IO.FileStream FS = new System.IO.FileStream(File, System.IO.FileMode.Open, System.IO.FileAccess.Read,System.IO.FileShare.Read,8192,System.IO.FileOptions.SequentialScan)) { int FooterPOS = (int)FS.Length - 32; FS.Position = FooterPOS; BinaryReader RD = new BinaryReader(FS); DateTime StartTime = TimeTag.Convert(RD.ReadDouble()); DateTime EndTime = TimeTag.Convert(RD.ReadDouble()); int PointsReceived = RD.ReadInt32(); int PointsArchived = RD.ReadInt32(); int DataBlockSize = RD.ReadInt32(); int DataBlockCount = RD.ReadInt32(); int FATPos = FooterPOS - 10 - 12 * DataBlockCount; FS.Position = FATPos; List <Blocks> Blocks = new List <Blocks>(DataBlockCount); byte[] Header = RD.ReadBytes(10); Blocks B = default(Blocks); for (int x = 1; x <= DataBlockCount; x++) { B.BlockID = RD.ReadInt32(); B.Time = TimeTag.Convert(RD.ReadDouble()); Blocks.Add(B); } FS.Position = 0; Points P = default(Points); int NextPos = DataBlockSize * 1024; byte[] Buffer = new byte[DataBlockSize * 1024]; fixed(byte *lp = Buffer) { foreach (Blocks BK in Blocks) { FS.Read(Buffer, 0, DataBlockSize * 1024); int pos = 0; while (pos < DataBlockSize * 1024 - 9) { int I = *(int *)(lp + pos); short S = *(short *)(lp + pos + 4); float V = *(float *)(lp + pos + 6); pos += 10; long TimeDiff = I * 1000L + (S >> 5); if (TimeDiff != 0) { P.Time = TimeTag.Convert(TimeDiff); P.Value = V; P.PointID = BK.BlockID; callback(P); } } //FS.Position = NextPos; NextPos += DataBlockSize * 1024; } return; } } }
public static void AssertDesiredSize(this IControl control, string name, Points width, Points height) { Assert.AreEqual(width, control.DesiredSize.Width.FirstAsync().ToTask().GetResultAndUnpackExceptions(), name.Capitalize() + " has wrong desired width"); Assert.AreEqual(height, control.DesiredSize.Height.FirstAsync().ToTask().GetResultAndUnpackExceptions(), name.Capitalize() + " has wrong desired height"); }
public override string ToString() { var pts = string.Join(",", Points.Select(p => String.Format("({0},{1})", p.X, p.Y)).ToArray()); return(String.Format("{0} - {1}", Type.ToString(), pts)); }
} = 240; //Thời gian kết thúc, sau sẽ được truyện vào từ Terminate //Method sinh Cus public IEnumerator <Task> Generator(Process p, object data) { Console.WriteLine(this.Now + @" The barber shop is opening for business..."); //Resource barbers = CreateBarbers(); ABarbers = Resource.Create(new List <Barber>() { new Barber(this, "Minh"), new Barber(this, "Anh") }); int i = 0; switch (TypeDistribuion) { case Distribution.NormalDis: TypeDis = new Normal(Interval, 1.0); break; case Distribution.ExponentialDis: TypeDis = new Exponential(Interval); break; default: Console.WriteLine("k tim thay"); break; } do { long d; do { d = (long)TypeDis.NextDouble(); } while (d <= 0L); if (FirstTime != 0 && Now == 0) { yield return(p.Delay(FirstTime)); i++; //Console.WriteLine(@"xxx so Cus trong hang doi = " + ABarbers.BlockCount + " " + Now); Customer c = new Customer(this, i.ToString(), this.Now, QueueCapacity); c.Activate(null, 0L, ABarbers); Console.WriteLine(this.Now + " The customer " + c.Name + " come"); } else { yield return(p.Delay(d)); Console.WriteLine(@"xxx BlockCount - " + ABarbers.BlockCount + "- OutOfService - " + ABarbers.OutOfService + "- Reserved - " + ABarbers.Reserved + "- Now - " + Now); i++; Customer c = new Customer(this, i.ToString(), this.Now, QueueCapacity); c.Activate(null, 0L, ABarbers); Console.WriteLine(this.Now + " The customer " + c.Name + " come"); Console.WriteLine(@"yyy BlockCount - " + ABarbers.BlockCount + "- OutOfService - " + ABarbers.OutOfService + "- Reserved - " + ABarbers.Reserved + "- Now - " + Now); //point = new Point(Now, ABarbers.BlockCount); Points.Add(new Point(Now, ABarbers.BlockCount)); } } while (Now < EndingTime && i < LengthOfFile); Console.WriteLine(@"======================================================"); Console.WriteLine(@"The barber shop is closed for the day."); if (ABarbers.BlockCount > 0) { Console.WriteLine(@"The barbers have to work late today."); } yield break; }
protected override async void Start() { base.Start(); // 3D scene with Octree var scene = new Scene(Context); octree = scene.CreateComponent <Octree>(); // Camera var cameraNode = scene.CreateChild(); cameraNode.Position = new Vector3(0, size * 2, size); camera = cameraNode.CreateComponent <Camera>(); cameraNode.LookAt(Vector3.Zero, Vector3.Up); // Light Node lightNode = cameraNode.CreateChild(); var light = lightNode.CreateComponent <Light>(); light.LightType = LightType.Point; light.Range = size * size; light.Brightness = 1.3f; // Viewport var viewport = new Viewport(Context, scene, camera); Renderer.SetViewport(0, viewport); plotNode = scene.CreateChild(); if (!(Points is null)) { int quantity = Convert.ToInt32(Math.Sqrt(Points.Count)); float step = size / Convert.ToSingle(quantity); double max = Points.Select(Mapping).Max(); double min = Points.Select(Mapping).Min(); double range = (max - min) / 6; if (range > 0) { double doubleRange = range * 2; double tripleRange = range * 3; double fiveRange = range * 5; foreach (threeDimensionalPointDTO point in Points) { Color color = Color.Black; double value = Mapping.Invoke(point) - min; switch (Math.Floor(value / range)) { case -1: case 0: color = new Color(Convert.ToSingle(value / range), Convert.ToSingle(value / range), 1); break; case 1: color = new Color(Convert.ToSingle((doubleRange - value) / range), 1, 1); break; case 2: color = new Color(0, 1, Convert.ToSingle((tripleRange - value) / range)); break; case 3: color = new Color(Convert.ToSingle((value - tripleRange) / range), 1, 0); break; case 4: color = new Color(1, Convert.ToSingle((fiveRange - value) / range), 0); break; default: color = new Color(1, 0, Convert.ToSingle((value - fiveRange) / range)); break; } var boxNode = plotNode.CreateChild(); boxNode.Position = new Vector3(Convert.ToSingle(point.x * step), 0, Convert.ToSingle(-point.y * step)); var box = new Bar(step, color); boxNode.AddComponent(box); box.Value = Convert.ToSingle(value); } } } await plotNode.RunActionsAsync(new EaseBackOut(new RotateBy(2f, 0, 360, 0))); }
public override IEnumerable <Vertex> GetIndexedVertices() { return(Points.OfType <DisplacementPoint>().Select(x => x.CurrentPosition)); }
public static T Points <T>(this T polyLineSegment, Points value) where T : IPolyLineSegment { polyLineSegment.Points = value; return(polyLineSegment); }
public static void DrawWay(Car self, Moves stack, Brush brush, double width) { if (stack == null) return; var pts = new Points(); pts.AddRange(MyStrategy.GetCarPath(self, stack).Select(car => new Point(car))); SegmentsDrawQueue.Add(new object[] { brush, pts, width }); }
public static List <MWPoint2D> OrderInDistance(List <MWPoint2D> pts) { List <MWPoint2D> lpts = pts; MWPoint2D pt = lpts.First(p => p.X == lpts.Max(v => v.X)); List <MWPoint2D> res = new List <MWPoint2D> { pt }; lpts.Remove(pt); while (lpts.Count > 0) { MWPoint2D p0 = lpts.Aggregate(lpts[0], (closest, next) => Points.Distance(res[res.Count - 1], next) < Points.Distance(res[res.Count - 1], closest) ? next : closest); res.Add(p0); lpts.Remove(p0); } return(res); }
protected override IEnumerator<Task> GetProcessSteps() { Resource barbers = (Resource)ActivationData; //NewResource barbers = (NewResource)ActivationData; Console.WriteLine("M so Cus trong hang doi = " + barbers.BlockCount + " " + Now); //if (barbers.BlockCount < QueueCapacity)//max so Cus trong hang doi //{ // yield return barbers.Acquire(this);//?o?n n?y s? nh?y sang Barber ?? th?c hi?n, khi th?c hi?n xong s? nh?y v? 2//Sau doan nay Cus se luu vao hang doi //} //else //{ // yield break; //} if (barbers.BlockCount < Condition)//max so Cus trong hang doi { yield break; } else { yield return barbers.Acquire(this);//?o?n n?y s? nh?y sang Barber ?? th?c hi?n, khi th?c hi?n xong s? nh?y v? 2//Sau doan nay Cus se luu vao hang doi } System.Diagnostics.Debug.Assert(barbers == Activator); System.Diagnostics.Debug.Assert(ActivationData != null); Barber barber = (Barber)ActivationData; Points.Add(new Point(Now, barber.BlockCount)); Console.WriteLine("H H so Cus trong hang doi = " + barbers.BlockCount + " " + Now); TimeIn = this.Now; Console.WriteLine(this.Now + " ? " + barber.Name + " begins cutting hair of customer " + this.Name); WaitOnTask(barber); yield return Suspend(); // HINT: The above two lines of code can be shortened to // yield return barber; Console.WriteLine("NN NN so Cus trong hang doi = " + barbers.BlockCount + " " + Now); TimeOut = this.Now; Console.WriteLine(this.Now + " x Customer " + Name + " pays {0} for the haircut.", barber.Name); Console.WriteLine($"thoi gian trong hang doi {TimeIn - this.TimeCome}" + $" --- thoi gian trong he thong {TimeOut - this.TimeCome}"); yield return barbers.Release(this);//giai phong bo nho //Resource barbers = (Resource)ActivationData; //yield return barbers.Acquire(this); //System.Diagnostics.Debug.Assert(barbers == Activator); //System.Diagnostics.Debug.Assert(ActivationData != null); //Barber barber = (Barber)ActivationData; //WaitOnTask(barber); //yield return Suspend(); //// HINT: The above two lines of code can be shortened to //// yield return barber; //Console.WriteLine("Customer pays {0} for the haircut.", // barber.Name); //yield return barbers.Release(this); }
private void Start() { materialCubo = GetComponent <MeshRenderer>(); playerPoints = GetComponentInParent <Points>(); walls = wallManager.GetComponent <WallsRemaining>(); }
// Level // Spielverlauf zeichnen // ------------------------------------------------------------------------------------------------------------------------------------ void Draw_Level() { // Background // Hintergrundbild // ************************************************************************************************************** spriteBatch.Draw(texBackground, new Vector2(0, Background_Position), Color.White); // ************************************************************************************************************** // Hintergundanimationen durchlaufen und zeichnen // ************************************************************************************************************** for (int i = 0; i < ListBackgroundAnimation.Count(); i++) { spriteBatch.Draw(texBackgroundAnimation, new Vector2(ListBackgroundAnimation[i].x, ListBackgroundAnimation[i].y), Color.White); } // ************************************************************************************************************** // Powershot zeichnen // Unter Gegner // ************************************************************************************************************** // Wenn eigenes Schiff aktiv und Powerschuss-Animtaion läuft bool PowerShot_drawed = false; if (MyShipIsActive == true & PowerShotAnimation == true) { if (PowerShotAnimationFrame < 15) { // Wenn Powerschuss noch aufbaut spriteBatch.Draw(texMyShotPowerShot, new Vector2(MyShip_X - (texMyShotPowerShot.Width / 2), MyShip_Y - 120), Color.White); } else { if (PowerShotAnimationFrame % 2 == 0) { // Powerschuss Strahl spriteBatch.Draw(texMyShotPowerShot, new Vector2(MyShip_X - (texMyShotPowerShot.Width / 2), MyShip_Y - 20 - texMyShotPowerShot.Height), null, Color.White, 0.0f, new Vector2(0, 0), 1.0f, SpriteEffects.None, 1); PowerShot_drawed = true; } } } // ************************************************************************************************************** // PowerUps durchlaufen und zeichnen // ************************************************************************************************************** for (int i = 0; i < ListPowerUps.Count(); i++) { // PowerUp zeichnen if (ListPowerUps[i].show == true) { spriteBatch.Draw(ListPowerUps[i].Texture, new Vector2(ListPowerUps[i].x - (ListPowerUps[i].Texture.Width / 2), ListPowerUps[i].y - (ListPowerUps[i].Texture.Height / 2)), null, Color.White); } // DEBUG Hitbox anzeigen if (DEBUG == true) { HitboxRectangle.Width = ListPowerUps[i].Texture.Width; HitboxRectangle.Height = ListPowerUps[i].Texture.Height; HitboxRectangle.X = ListPowerUps[i].x - (ListPowerUps[i].Texture.Width / 2); HitboxRectangle.Y = ListPowerUps[i].y - (ListPowerUps[i].Texture.Height / 2); spriteBatch.Draw(HitboxTexture, HitboxRectangle, Color.Bisque); } } // ************************************************************************************************************** // ShipEnemys // Gegnerische Schiffe // ************************************************************************************************************** for (int i = 0; i < ListShipEnemys.Count(); i++) { // Prüfvariable ob Standard geladen wird bool load_just = true; // Ausrichtung des Schiffes erstellen und ausgeben if (ListShipEnemys[i].sprite == "left") { spriteBatch.Draw(ListEnemyTextures[ListShipEnemys[i].enemy_type].left, new Vector2(ListShipEnemys[i].position_x, ListShipEnemys[i].position_y), null, Color.White, ListShipEnemys[i].rotation, new Vector2(ListEnemyTextures[ListShipEnemys[i].enemy_type].left.Width / 2, ListEnemyTextures[ListShipEnemys[i].enemy_type].left.Height / 2), 1, SpriteEffects.None, 0); load_just = false; } else if (ListShipEnemys[i].sprite == "right") { spriteBatch.Draw(ListEnemyTextures[ListShipEnemys[i].enemy_type].right, new Vector2(ListShipEnemys[i].position_x, ListShipEnemys[i].position_y), null, Color.White, ListShipEnemys[i].rotation, new Vector2(ListEnemyTextures[ListShipEnemys[i].enemy_type].right.Width / 2, ListEnemyTextures[ListShipEnemys[i].enemy_type].right.Height / 2), 1, SpriteEffects.None, 0); load_just = false; } if (load_just == true) { spriteBatch.Draw(ListEnemyTextures[ListShipEnemys[i].enemy_type].just, new Vector2(ListShipEnemys[i].position_x, ListShipEnemys[i].position_y), null, Color.White, ListShipEnemys[i].rotation, new Vector2(ListEnemyTextures[ListShipEnemys[i].enemy_type].just.Width / 2, ListEnemyTextures[ListShipEnemys[i].enemy_type].just.Height / 2), 1, SpriteEffects.None, 0); } // DEBUG Hitbox anzeigen if (DEBUG == true) { HitboxRectangle.Width = ListShipEnemys[i].hitbox_width; HitboxRectangle.Height = ListShipEnemys[i].hitbox_height; HitboxRectangle.X = ListShipEnemys[i].hitbox_x; HitboxRectangle.Y = ListShipEnemys[i].hitbox_y; spriteBatch.Draw(HitboxTexture, HitboxRectangle, Color.Orange); } } // ************************************************************************************************************** // Endboss Szenario // ************************************************************************************************************** // Endboss zeichnen if (BossSzenario == true & DrawBoss == true) { spriteBatch.Draw(texBoss, new Vector2(Boss_X - (texBoss.Width / 2), Boss_Y - (texBoss.Height / 2)), null, Color.White); // DEBUG Hitbox anzeigen if (DEBUG == true) { HitboxRectangle.Width = Boss_Hitbox_Width; HitboxRectangle.Height = Boss_Hitbox_Height; HitboxRectangle.X = Boss_X - (Boss_Hitbox_Width / 2); HitboxRectangle.Y = Boss_Y - (Boss_Hitbox_Height / 2); spriteBatch.Draw(HitboxTexture, HitboxRectangle, Color.Cyan); } } // ************************************************************************************************************** // ListMyShotRocket // Erweiterte Schüsse durchlaufen und zeichnen // ************************************************************************************************************** for (int i = 0; i < ListMyShotRocket.Count(); i++) { // Position der Raketen ermitteln und zeichen spriteBatch.Draw(texMyShotRocket, new Vector2(ListMyShotRocket[i].x - (texMyShotRocket.Width / 2), ListMyShotRocket[i].y - (texMyShotRocket.Height / 2)), null, Color.White); // Rauch zeichnen if (ListMyShotRocket[i].smoke1_y != -1000) { spriteBatch.Draw(texSmoke1, new Vector2(ListMyShotRocket[i].x - (texSmoke1.Width / 2), ListMyShotRocket[i].smoke1_y - (texSmoke1.Height / 2)), null, Color.White); } if (ListMyShotRocket[i].smoke2_y != -1000) { spriteBatch.Draw(texSmoke2, new Vector2(ListMyShotRocket[i].x - (texSmoke2.Width / 2), ListMyShotRocket[i].smoke2_y - (texSmoke2.Height / 2)), null, Color.White); } if (ListMyShotRocket[i].smoke3_y != -1000) { spriteBatch.Draw(texSmoke3, new Vector2(ListMyShotRocket[i].x - (texSmoke3.Width / 2), ListMyShotRocket[i].smoke3_y - (texSmoke3.Height / 2)), null, Color.White); } if (ListMyShotRocket[i].smoke4_y != -1000) { spriteBatch.Draw(texSmoke4, new Vector2(ListMyShotRocket[i].x - (texSmoke4.Width / 2), ListMyShotRocket[i].smoke4_y - (texSmoke4.Height / 2)), null, Color.White); } if (ListMyShotRocket[i].smoke5_y != -1000) { spriteBatch.Draw(texSmoke5, new Vector2(ListMyShotRocket[i].x - (texSmoke5.Width / 2), ListMyShotRocket[i].smoke5_y - (texSmoke5.Height / 2)), null, Color.White); }// DEBUG Hitbox anzeigen if (DEBUG == true) { HitboxRectangle.Width = texMyShotRocket.Width; HitboxRectangle.Height = texMyShotRocket.Height; HitboxRectangle.X = ListMyShotRocket[i].x - (HitboxRectangle.Width / 2); HitboxRectangle.Y = ListMyShotRocket[i].y - (HitboxRectangle.Height / 2); spriteBatch.Draw(HitboxTexture, HitboxRectangle, Color.Cyan); } } // ************************************************************************************************************** // MyShip // Eigenes Raumschiff // ************************************************************************************************************** // Wenn eigenes Schiff aktiv if (MyShipIsActive == true) { if (Indestructible == 0 | (Indestructible % 2 == 0)) { // Raumschiff zeichnen if (MyShipPosition == 0) { spriteBatch.Draw(texMyShip, new Vector2(MyShip_X - (texMyShip.Width / 2), MyShip_Y - (texMyShip.Height / 2)), Color.White); } if (MyShipPosition == 1) { spriteBatch.Draw(texMyShipRight, new Vector2(MyShip_X - (texMyShipRight.Width / 2), MyShip_Y - (texMyShipRight.Height / 2)), Color.White); } if (MyShipPosition == -1) { spriteBatch.Draw(texMyShipLeft, new Vector2(MyShip_X - (texMyShipLeft.Width / 2), MyShip_Y - (texMyShipLeft.Height / 2)), Color.White); } // DEBUG MODE // Hitbox des Powerschusses anzeigen + 1 if (DEBUG == true) { HitboxRectangle.Width = MyShip_PowerShot_Hitbox_Width; HitboxRectangle.Height = MyShip_PowerShot_Hitbox_Height;; HitboxRectangle.X = MyShip_PowerShot_Hitbox_X; HitboxRectangle.Y = MyShip_PowerShot_Hitbox_Y; spriteBatch.Draw(HitboxTexture, HitboxRectangle, Color.Green); } // DEBUG MODE // Hitbox des Powerschusses anzeigen + 2 if (DEBUG == true) { HitboxRectangle.Width = MyShip_PowerShot_Hitbox_Width_2; HitboxRectangle.Height = MyShip_PowerShot_Hitbox_Height_2;; HitboxRectangle.X = MyShip_PowerShot_Hitbox_X_2; HitboxRectangle.Y = MyShip_PowerShot_Hitbox_Y_2; spriteBatch.Draw(HitboxTexture, HitboxRectangle, Color.Orange); } // DEBUG MODE // Hitbox anzeigen if (DEBUG == true) { HitboxRectangle.Width = MyShip_Hitbox_Width; HitboxRectangle.Height = MyShip_Hitbox_Height;; HitboxRectangle.X = MyShip_Hitbox_X; HitboxRectangle.Y = MyShip_Hitbox_Y; spriteBatch.Draw(HitboxTexture, HitboxRectangle, Color.Red); } } } // ************************************************************************************************************** // Powershot zeichnen // Über andere Gegner // ************************************************************************************************************** // Wenn eigenes Schiff aktiv und Powerschuss-Animtaion läuft if (MyShipIsActive == true & PowerShotAnimation == true) { if (PowerShotAnimationFrame >= 15) { if (PowerShot_drawed == false) { spriteBatch.Draw(texMyShotPowerShot, new Vector2(MyShip_X - (texMyShotPowerShot.Width / 2), MyShip_Y - 20 - texMyShotPowerShot.Height), null, Color.White, 0.0f, new Vector2(0, 0), 1.0f, SpriteEffects.FlipHorizontally, 1); } } if (DEBUG == true) { HitboxRectangle.Width = PowerShotHitboxWidth; HitboxRectangle.Height = PowerShotHitboxHeight; HitboxRectangle.X = PowerShotHitboxX; HitboxRectangle.Y = PowerShotHitboxY; spriteBatch.Draw(HitboxTexture, HitboxRectangle, Color.BurlyWood); } } // ************************************************************************************************************** // ListMyShots // Schüsse durchlaufen und zeichnen // ************************************************************************************************************** for (int x = 0; x < ListMyShots.Count(); x++) { // Schuss Feuer if (ListMyShots[x].type == "Fire") { // Schuss zeichnen spriteBatch.Draw(texMyShotFire, new Vector2(ListMyShots[x].x + (texMyShotFire.Width / 2), ListMyShots[x].y - (texMyShotFire.Height / 2)), null, Color.White, ListMyShots[x].angle, new Vector2(texMyShotFire.Width, texMyShotFire.Width), 1.0f, SpriteEffects.None, 1); // DEBUG MODE // Hitbox anzeigen if (DEBUG == true) { HitboxRectangle.Width = ListMyShots[x].hitbox_width; HitboxRectangle.Height = ListMyShots[x].hitbox_height; HitboxRectangle.X = ListMyShots[x].hitbox_x; HitboxRectangle.Y = ListMyShots[x].hitbox_y; spriteBatch.Draw(HitboxTexture, HitboxRectangle, Color.Red); } } // Schuss Phaser if (ListMyShots[x].type == "Phaser") { // Schuss zeichnen spriteBatch.Draw(texMyShotPhaser, new Vector2(ListMyShots[x].x + (texMyShotPhaser.Width / 2), ListMyShots[x].y - (texMyShotPhaser.Height / 2)), null, Color.White, ListMyShots[x].angle, new Vector2(texMyShotPhaser.Width, texMyShotPhaser.Width), 1.0f, SpriteEffects.None, 1); // DEBUG MODE // Hitbox anzeigen if (DEBUG == true) { HitboxRectangle.Width = ListMyShots[x].hitbox_width; HitboxRectangle.Height = ListMyShots[x].hitbox_height; HitboxRectangle.X = ListMyShots[x].hitbox_x; HitboxRectangle.Y = ListMyShots[x].hitbox_y; spriteBatch.Draw(HitboxTexture, HitboxRectangle, Color.Red); } } // Schuss Laser if (ListMyShots[x].type == "Laser") { // Bei Laser Level 1 if (ListMyShots[x].level == 1) { // Schuss zeichnen spriteBatch.Draw(texMyShotLaser1, new Vector2(ListMyShots[x].x + (texMyShotLaser1.Width / 2), ListMyShots[x].y - (texMyShotLaser1.Height / 2)), null, Color.White, ListMyShots[x].angle, new Vector2(texMyShotLaser1.Width, texMyShotLaser1.Width), 1.0f, SpriteEffects.None, 1); } // Bei Laser Level 2 if (ListMyShots[x].level == 2) { // Schuss zeichnen spriteBatch.Draw(texMyShotLaser2, new Vector2(ListMyShots[x].x + (texMyShotLaser2.Width / 2), ListMyShots[x].y - (texMyShotLaser2.Height / 2)), null, Color.White, ListMyShots[x].angle, new Vector2(texMyShotLaser2.Width, texMyShotLaser2.Width), 1.0f, SpriteEffects.None, 1); } // Bei Laser Level 3 if (ListMyShots[x].level == 3) { // Schuss zeichnen spriteBatch.Draw(texMyShotLaser3, new Vector2(ListMyShots[x].x + (texMyShotLaser3.Width / 2), ListMyShots[x].y - (texMyShotLaser3.Height / 2)), null, Color.White, ListMyShots[x].angle, new Vector2(texMyShotLaser3.Width, texMyShotLaser3.Width), 1.0f, SpriteEffects.None, 1); } // DEBUG MODE // Hitbox anzeigen if (DEBUG == true) { HitboxRectangle.Width = ListMyShots[x].hitbox_width; HitboxRectangle.Height = ListMyShots[x].hitbox_height; HitboxRectangle.X = ListMyShots[x].hitbox_x; HitboxRectangle.Y = ListMyShots[x].hitbox_y; spriteBatch.Draw(HitboxTexture, HitboxRectangle, Color.BlueViolet); } } } // ************************************************************************************************************** // Enemy Shots // Gegnerische Schüsse durchlaufen und zeichnen // ************************************************************************************************************** // Schuss typ 1 --> Direkter Schuss --> <ClassEnemyShotDirect> Durchlaufen und zeichnen for (int i = 0; i < ListEnemyShotDirect.Count(); i++) { // Bei kleinem Schuß if (ListEnemyShotDirect[i].hitbox_height == 20) { // Schuss auswählen und zeichnen if (ListEnemyShotDirect[i].angel == 1) { spriteBatch.Draw(texEnemyShot1, new Vector2(Convert.ToInt32(ListEnemyShotDirect[i].x) + (texEnemyShot1.Width / 2), Convert.ToInt32(ListEnemyShotDirect[i].y + (texEnemyShot1.Height / 2))), null, Color.White, 0.0f, new Vector2(texEnemyShot1.Width, texEnemyShot1.Height), 1.0f, SpriteEffects.None, 1); } else if (ListEnemyShotDirect[i].angel == 2) { spriteBatch.Draw(texEnemyShot1, new Vector2(Convert.ToInt32(ListEnemyShotDirect[i].x) + (texEnemyShot1.Width / 2), Convert.ToInt32(ListEnemyShotDirect[i].y + (texEnemyShot1.Height / 2))), null, Color.White, 0.0f, new Vector2(texEnemyShot1.Width, texEnemyShot1.Height), 1.0f, SpriteEffects.FlipHorizontally, 1); } else if (ListEnemyShotDirect[i].angel == 3) { spriteBatch.Draw(texEnemyShot1, new Vector2(Convert.ToInt32(ListEnemyShotDirect[i].x) + (texEnemyShot1.Width / 2), Convert.ToInt32(ListEnemyShotDirect[i].y + (texEnemyShot1.Height / 2))), null, Color.White, 0.0f, new Vector2(texEnemyShot1.Width, texEnemyShot1.Height), 1.0f, SpriteEffects.FlipVertically, 1); } // DEBUG MODE // Hitbox anzeigen if (DEBUG == true) { HitboxRectangle.Width = ListEnemyShotDirect[i].hitbox_width; HitboxRectangle.Height = ListEnemyShotDirect[i].hitbox_height; HitboxRectangle.X = ListEnemyShotDirect[i].hitbox_x; HitboxRectangle.Y = ListEnemyShotDirect[i].hitbox_y; spriteBatch.Draw(HitboxTexture, HitboxRectangle, Color.Aquamarine); } } // Bei großem Schuß else if (ListEnemyShotDirect[i].hitbox_height == 40) { // Schuss auswählen und zeichnen if (ListEnemyShotDirect[i].angel == 1) { spriteBatch.Draw(texEnemyShot1_2, new Vector2(Convert.ToInt32(ListEnemyShotDirect[i].x) + (texEnemyShot1_2.Width / 2), Convert.ToInt32(ListEnemyShotDirect[i].y + (texEnemyShot1_2.Height / 2))), null, Color.White, 0.0f, new Vector2(texEnemyShot1_2.Width, texEnemyShot1_2.Height), 1.0f, SpriteEffects.None, 1); } else if (ListEnemyShotDirect[i].angel == 2) { spriteBatch.Draw(texEnemyShot1_2, new Vector2(Convert.ToInt32(ListEnemyShotDirect[i].x) + (texEnemyShot1_2.Width / 2), Convert.ToInt32(ListEnemyShotDirect[i].y + (texEnemyShot1_2.Height / 2))), null, Color.White, 0.0f, new Vector2(texEnemyShot1_2.Width, texEnemyShot1_2.Height), 1.0f, SpriteEffects.FlipHorizontally, 1); } else if (ListEnemyShotDirect[i].angel == 3) { spriteBatch.Draw(texEnemyShot1_2, new Vector2(Convert.ToInt32(ListEnemyShotDirect[i].x) + (texEnemyShot1_2.Width / 2), Convert.ToInt32(ListEnemyShotDirect[i].y + (texEnemyShot1_2.Height / 2))), null, Color.White, 0.0f, new Vector2(texEnemyShot1_2.Width, texEnemyShot1_2.Height), 1.0f, SpriteEffects.FlipVertically, 1); } // DEBUG MODE // Hitbox anzeigen if (DEBUG == true) { HitboxRectangle.Width = ListEnemyShotDirect[i].hitbox_width; HitboxRectangle.Height = ListEnemyShotDirect[i].hitbox_height; HitboxRectangle.X = ListEnemyShotDirect[i].hitbox_x; HitboxRectangle.Y = ListEnemyShotDirect[i].hitbox_y; spriteBatch.Draw(HitboxTexture, HitboxRectangle, Color.Aquamarine); } } } // Schuss typ 2 --> Laser Schuss --> <ClassEnemyShotLaser> Durchlaufen und zeichnen for (int i = 0; i < ListEnemyShotLaser.Count(); i++) { // Schuss auswählen und zeichnen spriteBatch.Draw(ListEnemyShotLaser[i].texture, new Vector2(Convert.ToInt32(ListEnemyShotLaser[i].x) - (ListEnemyShotLaser[i].texture.Width / 2), Convert.ToInt32(ListEnemyShotLaser[i].y)), Color.White); // DEBUG MODE // Hitbox anzeigen if (DEBUG == true) { HitboxRectangle.Width = ListEnemyShotLaser[i].texture.Width; HitboxRectangle.Height = ListEnemyShotLaser[i].texture.Height; HitboxRectangle.X = Convert.ToInt32(ListEnemyShotLaser[i].x) - (ListEnemyShotLaser[i].texture.Width / 2); HitboxRectangle.Y = Convert.ToInt32(ListEnemyShotLaser[i].y); spriteBatch.Draw(HitboxTexture, HitboxRectangle, Color.BlanchedAlmond); } } // ************************************************************************************************************** // ListExplosions // Explosionen durchlaufen und zeichen // ************************************************************************************************************** for (int x = 0; x < ListExplosions.Count(); x++) { // Explosionen zeichnen spriteBatch.Draw(ListExplosions[x].Texture, new Vector2(ListExplosions[x].x - (ListExplosions[x].Texture.Width / 2), ListExplosions[x].y - (ListExplosions[x].Texture.Height / 2)), Color.White); } // ************************************************************************************************************** // Anzeige zeichnen // ************************************************************************************************************** // Display spriteBatch.Draw(texDisplay, new Vector2(0, Display_Y), null, Color.White); // Waffe spriteBatch.Draw(texDisplay_Weapon, new Vector2(74, 2 + Display_Content_Y), null, Color.White); // Level Waffe spriteBatch.Draw(texDisplay_LevelShot, new Vector2(138, 3 + Display_Content_Y), null, Color.White); // Level Extension if (Display_Show_Extension == true) { spriteBatch.Draw(texDisplay_Extension, new Vector2(155, 3 + Display_Content_Y), null, Color.White); spriteBatch.Draw(texDisplay_LevelExtension, new Vector2(186, 3 + Display_Content_Y), null, Color.White); } // Powerschuss Bar ausgeben spriteBatch.Draw(texDisplay_PowerShotBar, new Rectangle((204 + MyShip_PowerShot_Width), 5 + Display_Content_Y, (224 - MyShip_PowerShot_Width), 26), Color.White); // Leben ausgeben spriteBatch.DrawString(fntDisplay, Lives.ToString(), new Vector2(29, 2 + Display_Content_Y), Color.Black); // Punkte Ausgeben spriteBatch.DrawString(fntDisplay, Points.ToString(), new Vector2(209, 2 + Display_Content_Y), Color.Black); // Anzahl Powerschüsse ausgeben spriteBatch.DrawString(fntDisplay, MyShip_PowerShots.ToString(), new Vector2(441, 2 + Display_Content_Y), Color.Black); // Warnung zeichnen if (ShowWarning == true) { spriteBatch.Draw(texWarning, new Vector2(0, 400), null, Color.White); } // ************************************************************************************************************** // Endboss Zeit ausgeben // ************************************************************************************************************** if (BossTimeString != "") { Color BossTimeColor = new Color(0.8f, 0.8f, 0.8f, 0.8f); Vector2 FontOrigin = fntBossTime.MeasureString(BossTimeString) / 2; spriteBatch.DrawString(fntBossTime, BossTimeString.ToString(), new Vector2(graphics.GraphicsDevice.Viewport.Width / 2, 60 + Display_Content_Y), Color.LightGray, 0, FontOrigin, 1.0f, SpriteEffects.None, 0.5f); } // ************************************************************************************************************** }
protected override Rect GetBoundingRectangleCore() { var bounds = new Rect(Points.xPosition(Column), 0, Points.GetWidth(Column), Points.ColumnHeaderHeight); return new Rect(Owner.ColumnHeader.PointToScreen(bounds.TopLeft), Owner.ColumnHeader.PointToScreen(bounds.BottomRight)); }
private void MouseDown(Viewport3D vp, ViewportEvent e) { if (!_currentTool.NoSelection()) { var vtxs = _currentTool.GetVerticesAtPoint(e.X, vp.Height - e.Y, vp); if (vtxs.Any()) { // Use the topmost vertex as the control point var vtx = vtxs.First(); // Mouse down on a point if (vtx.IsSelected && KeyboardState.Ctrl && _currentTool.ShouldDeselect(vtxs)) { // If the vertex is selected and ctrl is down, deselect the vertices vtxs.ForEach(x => x.IsSelected = false); } else { if (!vtx.IsSelected && !KeyboardState.Ctrl && _currentTool.ShouldDeselect(vtxs)) { // If we aren't clicking on a selected point and ctrl is not down, deselect the others Points.ForEach(x => x.IsSelected = false); // If this point is already selected, don't deselect others. This is the same behaviour as 2D selection. } vtxs.ForEach(x => x.IsSelected = true); } VertexSelectionChanged(); // Don't do other click operations return; } // Nothing clicked if (!KeyboardState.Ctrl) { // Deselect all the points if not ctrl-ing Points.ForEach(x => x.IsSelected = false); } } if (!_currentTool.No3DSelection()) { // Do selection var ray = vp.CastRayFromScreen(e.X, e.Y); var hits = Document.Map.WorldSpawn.GetAllNodesIntersectingWith(ray, true); var solid = hits .OfType <Solid>() .Select(x => new { Item = x, Intersection = GetIntersectionPoint(x, ray) }) .Where(x => x.Intersection != null) .OrderBy(x => (x.Intersection - ray.Start).VectorMagnitude()) .Select(x => x.Item) .FirstOrDefault(); if (solid != null) { if (solid.IsSelected && KeyboardState.Ctrl) { // deselect solid var select = new MapObject[0]; var deselect = new[] { solid }; Document.PerformAction("Deselect VM solid", new ChangeSelection(select, deselect)); } else if (!solid.IsSelected) { // select solid var select = new[] { solid }; var deselect = !KeyboardState.Ctrl ? Document.Selection.GetSelectedObjects() : new MapObject[0]; Document.PerformAction("Select VM solid", new ChangeSelection(select, deselect)); } // Don't do other click operations return; } } base.MouseDown(vp, e); }
public Points GetWaySegments(Car car) { var result = new Points(); var isWayPoint = new List<bool>(); var myCell = GetCell(car.X, car.Y); result.Add(new Point(car)); isWayPoint.Add(false); Cell prevCell = null; for (var e = 1; result.Count < 5; e++) { var nextWp = GetNextWayPoint(car, e); for (var curCell = myCell; !curCell.Equals(nextWp);) { var nextCell = DijkstraNextCell(curCell, nextWp, prevCell == null ? new Cell[] { } : new[] { prevCell }); var nextPoint = GetCenter(nextCell); while (result.Count > 1 && !isWayPoint[isWayPoint.Count - 1] && CheckVisibility(car, result[result.Count - 2], nextPoint, car.Height / 2 + 10)) { result.Pop(); isWayPoint.RemoveAt(isWayPoint.Count - 1); } result.Add(nextPoint); isWayPoint.Add(nextCell.Equals(nextWp)); prevCell = curCell; curCell = nextCell; } myCell = nextWp; } return result; }
/// <summary> /// Updates the polygon. Use this after changing something. /// </summary> public void UpdatePolygon() { Points.Clear(); Points.Add(LineStart); Points.Add(LineEnd); }
Quaternion GetOrientation(Points p) { var x = p.GetDirection ("X"); var y = p.GetDirection ("Y"); var z = p.GetDirection ("Z"); Quaternion rot; if (y.IsZero ()) { if (z.IsZero () && x.IsZero ()) { x = Vector3d.Cross (p.Up (), Vector3d.up); x.Normalize (); z = Vector3d.Cross (x, p.Up ()); } else if (z.IsZero ()) { z = Vector3d.Cross (x, p.Up ()); z.Normalize (); } else if (x.IsZero ()) { x = Vector3d.Cross (p.Up (), z); x.Normalize (); } rot = p.ChooseRotation (x, z); } else if (x.IsZero ()) { // y is not zero if (z.IsZero ()) { z = Vector3d.Cross (p.Up (), y); z.Normalize (); } rot = p.ChooseRotation (z, y); } else if (z.IsZero ()) { // neither x nor y are zero rot = p.ChooseRotation (y, x); } else { // no direction is 0 rot = p.ChooseRotation (x, z, y); } return rot; }
private void DeselectAll(object sender) { Points.ForEach(x => x.IsSelected = false); VertexSelectionChanged(); }
static void Main(string[] arguments) { string command = string.Empty; char[,] field = CreateField(); char[,] bombs = PlaceBombs(); int counter = 0; bool crash = false; List<Points> winners = new List<Points>(6); int row = 0; int col = 0; bool flag = true; const int max = 35; bool flag2 = false; do { if (flag) { Console.WriteLine("Lets play. You should find the fields without mines." + " Command 'top' shows the ranking, 'restart' starts a new game, 'exit' finishes the game!"); Input(field); flag = false; } Console.Write("Row and Col: "); command = Console.ReadLine().Trim(); if (command.Length >= 3 && int.TryParse(command[0].ToString(), out row) && int.TryParse(command[2].ToString(), out col) && row <= field.GetLength(0) && col <= field.GetLength(1)) { command = "turn"; } switch (command) { case "top": Ranking(winners); break; case "restart": field = CreateField(); bombs = PlaceBombs(); Input(field); crash = false; flag = false; break; case "exit": Console.WriteLine("Bye!"); break; case "turn": if (bombs[row, col] != '*') { if (bombs[row, col] == '-') { OnTurn(field, bombs, row, col); counter++; } if (max == counter) { flag2 = true; } else { Input(field); } } else { crash = true; } break; default: Console.WriteLine("\nError! Wrong command!\n"); break; } if (crash) { Input(bombs); Console.Write("\nExit game with {0} points. " + "Nickname: ", counter); string nickname = Console.ReadLine(); Points player = new Points(nickname, counter); if (winners.Count < 5) { winners.Add(player); } else { for (int i = 0; i < winners.Count; i++) { if (winners[i].PointsIn < player.PointsIn) { winners.Insert(i, player); winners.RemoveAt(winners.Count - 1); break; } } } winners.Sort((Points player1, Points player2) => player2.Name.CompareTo(player1.Name)); winners.Sort((Points player1, Points player2) => player2.PointsIn.CompareTo(player1.PointsIn)); Ranking(winners); field = CreateField(); bombs = PlaceBombs(); counter = 0; crash = false; flag = true; } if (flag2) { Console.WriteLine("\nCongrats!"); Input(bombs); Console.WriteLine("Name: "); string name = Console.ReadLine(); Points points = new Points(name, counter); winners.Add(points); Ranking(winners); field = CreateField(); bombs = PlaceBombs(); counter = 0; flag2 = false; flag = true; } } while (command != "exit"); Console.Read(); }
public List <Point> PointsWithTotalDistanceLowerThan(int distance) { return(Points.Where(p => p.TotalDistance < distance).ToList()); }
/// <summary> /// Clears all anchor points. /// </summary> public void ClearAllPoints() { foreach (var anchor in anchors) { Frame parent = anchor.Value.AnchorControl ?? Parent; if (parent != null) parent.anchorChildren.Remove(this); } anchoredPoints = 0; UpdateAnchors(); }
public string ToString(bool includeTransponder) { return("<competitor no=\"" + Number + "\" class=\"" + ClassName + "\" firstname=\"" + FirstName + "\" lastname=\"" + LastName + "\" registration=\"" + CarRegistration + "\" driverregistration=\"" + DriverRegistration + "\" points=\"" + Points.ToString() + "\" startpos=\"" + StartPosition.ToString() + "\" hidden=\"" + (Hidden ? "yes" : "no") + "\"" + (includeTransponder ? " transponders=\"" + Transponder + "\"/>" : "/>")); }
/// <summary> /// Sets the the specified point on this frame to be at the same position /// as the corresponding point on the parent frame. /// </summary> /// <param name="point">The point.</param> /// <param name="offset">The offset.</param> public void SetPoint(Points point, Int2D offset) { SetPoint(point, offset.X, offset.Y); }
private void UpdateFunc(List <DPoint> linePts1, List <DPoint> linePts2, Func <double, double> f1, Func <double, double> f2, double lowerLim, double upperLim, double logStep) { lineSeries1 = linePts1; lineSeries2 = linePts2; func1 = f1; func2 = f2; lowLim = lowerLim; upLim = upperLim; step = logStep; Points.Clear(); int lpIndex1 = 0; double lpIntercept1 = 0d; double lpSlope1 = 0d; int lpIndex2 = 0; double lpIntercept2 = 0d; double lpSlope2 = 0d; for (double x = lowerLim; x < upLim * logStep; x *= logStep) { if (x > upLim) { x = upLim; } double lineValue1 = 0; if (lineSeries1[lpIndex1].X <= x) { while (lpIndex1 < lineSeries1.Count && lineSeries1[lpIndex1].X <= x) { lpIndex1++; } if (lpIndex1 < lineSeries1.Count) { var cp = lineSeries1[lpIndex1 - 1]; var np = lineSeries1[lpIndex1]; lpSlope1 = (np.Y - cp.Y) / Math.Log10(np.X / cp.X); lpIntercept1 = cp.Y - lpSlope1 * Math.Log10(cp.X); } } if (lpIndex1 == 0 && lineSeries1[0].X >= x) { lineValue1 = lineSeries1[0].Y; } else if (lpIndex1 < lineSeries1.Count) { lineValue1 = lpIntercept1 + lpSlope1 * (Math.Log10(x)); } else { lineValue1 = lineSeries1.Last().Y; } double lineValue2 = 0; if (lineSeries2[lpIndex2].X <= x) { while (lpIndex2 < lineSeries2.Count && lineSeries2[lpIndex2].X <= x) { lpIndex2++; } if (lpIndex2 < lineSeries2.Count) { var cp = lineSeries2[lpIndex2 - 1]; var np = lineSeries2[lpIndex2]; lpSlope2 = (np.Y - cp.Y) / Math.Log10(np.X / cp.X); lpIntercept2 = cp.Y - lpSlope2 * Math.Log10(cp.X); } } if (lpIndex2 == 0 && lineSeries2[0].X >= x) { lineValue2 = lineSeries2[0].Y; } else if (lpIndex2 < lineSeries2.Count) { lineValue2 = lpIntercept2 + lpSlope2 * (Math.Log10(x)); } else { lineValue2 = lineSeries2.Last().Y; } var val1 = Math.Pow(10d, (func1(x) + lineValue1) / 10d); var val2 = Math.Pow(10d, (func2(x) + lineValue2) / 10d); var total = 10d * Math.Log10(val1 + val2); Points.Add(new DataPoint(x, total)); } }
/// <summary> /// Sets the the specified point on this frame to be at the same position /// as the corresponding point on the parent frame. /// </summary> /// <param name="point">The point.</param> /// <param name="x">The x offset.</param> /// <param name="y">The y offset.</param> /// <param name="anchorFrame">The frame this frame is anchored to.</param> /// <param name="anchoredTo">The point on the anchorFrame to anchor to.</param> public void SetPoint(Points point, int x, int y, Frame anchorFrame, Points anchoredTo) { foreach (var side in anchors) { if (point.Selected(side.Key)) { Anchor anchor = side.Value; anchor.Start = side.Key; anchor.End = anchoredTo; anchor.AnchorControl = anchorFrame; anchor.Offset = new Vector2(x, y); } } anchoredPoints |= point; Frame parent = anchorFrame ?? this.Parent; if (parent != null && !parent.anchorChildren.Contains(this)) parent.anchorChildren.Add(this); UpdateAnchors(); }
public void AssertAvailableSize(Points width, Points height) { Assert.IsTrue(_available.HasValue, _name.Capitalize() + " have not receieved an available size"); Assert.AreEqual(width, _available.Value.Width, _name.Capitalize() + " got wrong available width"); Assert.AreEqual(height, _available.Value.Height, _name.Capitalize() + " got wrong available height"); }
public override void MouseDown(ViewportBase vp, ViewportEvent e) { _clickSelectionDone = false; if (_currentTool != null) { // If the current tool handles the event, we're done _currentTool.MouseDown(vp, e); if (e.Handled) { return; } } if (!(vp is Viewport2D)) { MouseDown((Viewport3D)vp, e); return; } if (_currentTool == null) { return; } if (_currentTool.NoSelection()) { return; } var viewport = (Viewport2D)vp; // Otherwise we try a selection // Find the clicked vertices var vtxs = _currentTool.GetVerticesAtPoint(e.X, viewport.Height - e.Y, viewport); if (!vtxs.Any()) { // Nothing clicked if (!KeyboardState.Ctrl) { // Deselect all the points if not ctrl-ing Points.ForEach(x => x.IsSelected = false); } // Try to select in 2D // Create a box to represent the click, with a tolerance level var unused = viewport.GetUnusedCoordinate(new Coordinate(100000, 100000, 100000)); var tolerance = 4 / viewport.Zoom; // Selection tolerance of four pixels var used = viewport.Expand(new Coordinate(tolerance, tolerance, 0)); var add = used + unused; var click = viewport.Expand(viewport.ScreenToWorld(e.X, viewport.Height - e.Y)); var box = new Box(click - add, click + add); var centerHandles = Select.DrawCenterHandles; var centerOnly = Select.ClickSelectByCenterHandlesOnly; // Get the first element that intersects with the box var solid = Document.Map.WorldSpawn.GetAllNodesIntersecting2DLineTest(box, centerHandles, centerOnly).OfType <Solid>().FirstOrDefault(); if (solid != null) { // select solid var select = new[] { solid }; var deselect = !KeyboardState.Ctrl ? Document.Selection.GetSelectedObjects() : new MapObject[0]; Document.PerformAction("Select VM solid", new ChangeSelection(select, deselect)); // Don't do other click operations return; } base.MouseDown(vp, e); return; } var vtx = vtxs.First(); // When clicking, only select vertices in a single solid vtxs = vtxs.Where(x => x.Solid == vtx.Solid).ToList(); // If any vertices are selected, don't change the selection yet if (!vtxs.Any(x => x.IsSelected)) { _clickSelectionDone = true; DoSelection(vtxs, viewport); } // Only move selected vertices vtxs = vtxs.Where(x => x.IsSelected).ToList(); if (!vtxs.Any()) { return; } // Use the fist vertex as the control point _currentTool.DragStart(vtxs); MoveSelection = vtxs; _snapPointOffset = SnapIfNeeded(viewport.Expand(viewport.ScreenToWorld(e.X, viewport.Height - e.Y))) - viewport.ZeroUnusedCoordinate(vtx.Coordinate); _movingPoint = vtx; }
/// <summary> /// Sets the the specified point on this frame to be at the same position /// as the corresponding point on the parent frame. /// </summary> /// <param name="point">The point.</param> /// <param name="x">The x offset.</param> /// <param name="y">The y offset.</param> public void SetPoint(Points point, int x, int y) { SetPoint(point, x, y, null, point); }
private void AddVertex(string values) { var fields = Split(values); Points.Add(new Point3D(fields[0], fields[1], fields[2])); }
public static Points ExtendWaySegments(Points pts, double delta) { var res = new Points(); for (var idx = 1; idx < pts.Count; idx++) { EnumeratePointsBetween(pts[idx - 1], pts[idx], delta, point => { if (res.Count == 0 || !res[res.Count - 1].Equals(point)) res.Add(point); return true; }); } return res; }
public Transform PlaceShip(ShipConstruct ship, ExBuildControl.Box vessel_bounds) { if (site == null) { return part.transform; } Transform xform; xform = part.FindModelTransform ("EL launch pos"); var points = new Points (site); Transform t = part.transform; GameObject launchPos = new GameObject ("EL launch pos"); launchPos.transform.parent = t; launchPos.transform.position = t.position; launchPos.transform.position += points.center - part.vessel.GetWorldPos3D (); launchPos.transform.rotation = GetOrientation (points); xform = launchPos.transform; Debug.Log (String.Format ("[EL] launchPos {0} {1}", xform.position, xform.rotation)); float angle; Vector3 axis; xform.rotation.ToAngleAxis (out angle, out axis); Part rootPart = ship.parts[0].localRoot; Vector3 pos = rootPart.transform.position; Vector3 shift = points.ShiftBounds (xform, pos, vessel_bounds); shift += xform.position; rootPart.transform.Translate (shift, Space.World); rootPart.transform.RotateAround (xform.position, axis, angle); return xform; }
/// <summary> /// Sets the the specified point on this frame to be at the same position /// as the corresponding point on the parent frame. /// </summary> /// <param name="point">The point.</param> /// <param name="offset">The offset.</param> /// <param name="anchorFrame">The frame this frame is anchored to.</param> /// <param name="anchoredTo">The point on the anchorFrame to anchor to.</param> public void SetPoint(Points point, Int2D offset, Frame anchorFrame, Points anchoredTo) { SetPoint(point, offset.X, offset.Y, anchorFrame, anchoredTo); }
public static bool Selected(this Points points, Points option) { return (points & option) == option; }
// Use this for initialization void Start() { healthComponent = character.GetComponent <Health>(); pointsComponent = character.GetComponent <Points>(); }
public Moves Do(ACar car, Points pts) { // Проверка что данный путь был выбран if (_selectThisTick + 1 != MyStrategy.world.Tick) _lastSuccessStack = null; Self = car.Clone(); if (_lastCall == LastSuccess) LastSuccess = _lastCall; for (var t = 0; t < MyStrategy.world.Tick - _lastCall && _lastSuccessStack != null && _lastSuccessStack.Count > 0; t++) { _lastSuccessStack[0].Times--; _lastSuccessStack.Normalize(); } if (_lastSuccessStack != null && (_lastSuccessStack.Count == 0 || _useDist2 && _lastSuccessStack.ComputeTime() < 30)) _lastSuccessStack = null; _lastCall = MyStrategy.world.Tick; /* * Количество бонусов на расстоянии 0.5t * Если изменилось - пересчитывать сильно */ var bonusesCount05 = MyStrategy.Bonuses .Count(bonus => Self.GetDistanceTo(bonus) < Const.TileSize / 2); /* * Количество бонусов на расстоянии 2t * Если изменилось - чуть нужно пересчитать */ var bonusesCount2 = MyStrategy.Bonuses .Count( bonus => Self.GetDistanceTo(bonus) < Const.TileSize*2 && MyStrategy.CellDistance(Self, bonus) <= 2); // Если был success на прошлом тике, то продолжаем. Или каждые _interval тиков. if (Const.Game.InitialFreezeDurationTicks < MyStrategy.world.Tick && bonusesCount05 == _bonusesCount05 && LastSuccess < MyStrategy.world.Tick - 1 && (MyStrategy.world.Tick - (LastSuccess + 1))%_interval != 0) { _validateLastSuccessStack(); return _lastSuccessStack; } /* * Смотрим на шины, которые на расстоянии не более 6 тайлов */ var prevProj = _projCandidates; _projCandidates = MyStrategy.Tires .Where( proj => Self.GetDistanceTo(proj[0]) <= Const.TileSize * 6 && MyStrategy.CellDistance(Self, proj[0]) <= 6) .ToArray(); var extended = MyStrategy.ExtendWaySegments(pts, 50); _bruteWayPoints = extended.GetRange(0, Math.Min(_waypointsCount, extended.Count)).ToArray(); if (LastStageMove.IsUseNitro && _turnsCount(_bruteWayPoints) > 1) return null; #if DEBUG var bruteWayPoints = new Points(); bruteWayPoints.AddRange(_bruteWayPoints); Visualizer.SegmentsDrawQueue.Add(new object[]{ Brushes.Brown, bruteWayPoints, 0.0 }); #endif _needDist = Const.TileSize*0.5 - 3; _needDist2 = Const.TileSize - 3; _turnTo = _bruteWayPoints[_bruteWayPoints.Length - 1]; _turnTo2 = _bruteWayPoints[Math.Min(_bruteWayPoints.Length - 1, (int)(_bruteWayPoints.Length * 0.83))]; #if DEBUG Visualizer.CircleFillQueue.Add(new Tuple<Brush, ACircularUnit>(Brushes.OrangeRed, new ACircularUnit { X = _turnTo.X, Y = _turnTo.Y, Radius = 20})); Visualizer.CircleFillQueue.Add(new Tuple<Brush, ACircularUnit>(Brushes.Orange, new ACircularUnit { X = _turnTo2.X, Y = _turnTo2.Y, Radius = 20 })); #endif _patterns = Patterns.Select(pt => new PathPattern { From = pt.From, To = pt.To, Step = pt.Step, Move = pt.Move.Clone() }).ToArray(); foreach (var p in _patterns) { if (p.Move.WheelTurn is TurnPattern) { var turnPattern = p.Move.WheelTurn as TurnPattern; if (turnPattern.Pattern == TurnPatternType.ToNext) p.Move.WheelTurn = Self.GetAngleTo(_turnTo) < 0 ? -1 : 1; else if (turnPattern.Pattern == TurnPatternType.FromNext) p.Move.WheelTurn = Self.GetAngleTo(_turnTo) < 0 ? 1 : -1; } } _movesStack = new Moves(); _bestMovesStack = new Moves(); _bestTime = MyStrategy.Infinity; _bestImportance = 0; /* * Смотрим на бонусы, которые на расстоянии не более 4t * TODO: уменьшить приоритет бонусов, которые может быть возьмет другой (в.т.ч тиммейт) */ _bonusCandidates = MyStrategy.Bonuses .Where( bonus => MyStrategy.world.Tick > 270 && // Не смотреть на бонусы при старте!!! Self.GetDistanceTo(bonus) <= Const.TileSize * 4 && MyStrategy.CellDistance(Self, bonus) <= 4 ) .ToArray(); /* * Смотрим на лужи, которые на расстоянии не более 5 тайлов */ var prevSlicks = _slickCandidates; _slickCandidates = MyStrategy.OilSlicks .Where( slick => Self.GetDistanceTo(slick) <= Const.TileSize*5 && MyStrategy.CellDistance(Self, slick) <= 5 ) .ToArray(); /* * Пытаться объехать тех, которые * - Крашнулись * - Убиты * - Двигатель меньше чем на 0.5 мощности * - Двигаются по встречной * * - Если у меня нитро, или будет нитро * * - Своих */ var prevCars = _carCandidates; _carCandidates = MyStrategy.Others .Where(opp => opp[0].GetDistanceTo(Self) < Const.TileSize*9) .Where( opp => opp[0].Original.IsTeammate || MyStrategy.IsCrashed(opp[0].Original) || !DurabilityObserver.IsActive(opp[0].Original) || opp[0].EnginePower < 0.5 || Self.RemainingNitroTicks > 0 || Math.Abs(Geom.GetAngleBetween(Self.Speed, opp[0].Speed)) > Math.PI / 2 ) .Where(opp => MyStrategy.CellDistance(Self, opp[0]) <= 9) // 9 - потому что он может ехать по встречке .ToArray(); if (_cache != null) { for (var k = 0; k < _patterns.Length; k++) { var range = (prevSlicks == null || prevCars == null || prevProj == null || _bonusesCount2 != bonusesCount2 || prevSlicks.Length != _slickCandidates.Length || prevCars.Length != _carCandidates.Length || prevProj.Length != _projCandidates.Length) ? (k == 0 ? 6 : 4) : (k == 0 ? 6 : 2); if (_bonusesCount05 != bonusesCount05 || Special && k == 0) range = 10; _patterns[k].From = Math.Max(0, _cache[k].Times - range); _patterns[k].To = Math.Min(_patterns[k].To * 9 / 7, _cache[k].Times + range); _patterns[k].Step = 2; } } _bonusesCount05 = bonusesCount05; _bonusesCount2 = bonusesCount2; var wayPointRequired = false; for(var i = _bruteWayPoints.Length - 1; i >= 0; i--) { if (_bruteWayPoints[i].GetDistanceTo2(_turnTo) < _needDist*_needDist) { for (var j = 0; j < i; j++) wayPointRequired |= MyStrategy.GetNextWayPoint(Self.Original).Equals(MyStrategy.GetCell(_bruteWayPoints[j])); break; } } _doRecursive(Self, 0, new PassedInfo { WayPoint = !wayPointRequired }); _cache = null; if (_bestTime == MyStrategy.Infinity) return _lastSuccessStack; if (_bestMovesStack.ComputeTime() != _bestTime) throw new Exception("ComputeTime != BestTime"); LastSuccess = MyStrategy.world.Tick; _cache = _bestMovesStack.Clone(); if (_maxTicksInfo == null) _maxTicksInfo = new int[_bestMovesStack.Count]; for (var i = 0; i < _maxTicksInfo.Length; i++) _maxTicksInfo[i] = Math.Max(_maxTicksInfo[i], _bestMovesStack[i].Times); _bestMovesStack.Normalize(); _lastSuccessStack = _bestMovesStack.Clone(); return _bestMovesStack; }
private void NewWorld() { var nwDialog = new NewWorldView(); if ((bool)nwDialog.ShowDialog()) { _loadTimer.Reset(); _loadTimer.Start(); _saveTimer.Stop(); Task.Factory.StartNew(() => { World w = nwDialog.NewWorld; w.SpawnX = w.TilesWide / 2; w.SpawnY = (int)Math.Max(0, w.GroundLevel - 10); w.GroundLevel = (int)w.GroundLevel; w.RockLevel = (int)w.RockLevel; w.BottomWorld = w.TilesHigh * 16; w.RightWorld = w.TilesWide * 16; w.Tiles = new Tile[w.TilesWide, w.TilesHigh]; var cloneTile = new Tile(); for (int y = 0; y < w.TilesHigh; y++) { OnProgressChanged(w, new ProgressChangedEventArgs(Calc.ProgressPercentage(y, w.TilesHigh), "生成世界中...")); if (y == (int)w.GroundLevel - 10) { cloneTile = new Tile { WireRed = false, IsActive = true, LiquidType = LiquidType.None, LiquidAmount = 0, Type = 2, U = -1, V = -1, Wall = 2 } } ; if (y == (int)w.GroundLevel - 9) { cloneTile = new Tile { WireRed = false, IsActive = true, LiquidType = LiquidType.None, LiquidAmount = 0, Type = 0, U = -1, V = -1, Wall = 2 } } ; else if (y == (int)w.GroundLevel + 1) { cloneTile = new Tile { WireRed = false, IsActive = true, LiquidType = LiquidType.None, LiquidAmount = 0, Type = 0, U = -1, V = -1, Wall = 0 } } ; else if (y == (int)w.RockLevel) { cloneTile = new Tile { WireRed = false, IsActive = true, LiquidType = LiquidType.None, LiquidAmount = 0, Type = 1, U = -1, V = -1, Wall = 0 } } ; else if (y == w.TilesHigh - 182) { cloneTile = new Tile(); } for (int x = 0; x < w.TilesWide; x++) { w.Tiles[x, y] = (Tile)cloneTile.Clone(); } } return(w); }) .ContinueWith(t => CurrentWorld = t.Result, TaskFactoryHelper.UiTaskScheduler) .ContinueWith(t => RenderEntireWorld()) .ContinueWith(t => { CurrentFile = null; PixelMap = t.Result; UpdateTitle(); Points.Clear(); Points.Add("出生点"); // PointTool.MouseDown 判定 Points.Add("地牢"); foreach (NPC npc in CurrentWorld.NPCs) { Points.Add(npc.Name); } MinimapImage = RenderMiniMap.Render(CurrentWorld); _loadTimer.Stop(); OnProgressChanged(this, new ProgressChangedEventArgs(0, string.Format("加载世界耗时 {0} 秒.", _loadTimer.Elapsed.TotalSeconds))); _saveTimer.Start(); }, TaskFactoryHelper.UiTaskScheduler); } }
/// <summary> /// returns the next point in the list /// </summary> /// <param name="point"></param> /// <returns></returns> public Point GetNextPoint(Point point) { return(this.Points.ElementAt(Points.FindIndex(x => x == point) + 1)); }
/// <summary> /// checkls if the first point of the list has a car on it. /// </summary> /// <returns></returns> public bool IsFirstPointEmpty() { return(Cars.Exists(x => x.CurPoint == Points.First())); }
public static void DrawWireRegionFromTerrain(Points points, float penWidth, Color color) { Binding.FCE_Draw_WireRegionFromTerrain(points.Pointer, penWidth, (float)color.R / 255f, (float)color.G / 255f, (float)color.B / 255f); }
public static T Points <T>(this T polygon, Points value) where T : IPolygon { polygon.Points = value; return(polygon); }
private static void Main() { string command; char[,] board = CreateBoard(); char[,] mines = PlaceMines(); int counter = 0; bool isMine = false; List<Points> highScores = new List<Points>(6); int row = 0; int column = 0; bool inGame = true; const int MaxScore = 35; bool maxResultAchieved = false; do { if (inGame) { Console.WriteLine("Lets play MineSweeper. Try to find the free from mines fields." + "The 'top' command shows the current standings, 'restart' starts a new game, 'exit'" + "quits the game."); PrintBoard(board); inGame = false; } Console.Write("Enter row and column: "); command = Console.ReadLine().Trim(); if (command != null && command.Length >= 3) { if (int.TryParse(command[0].ToString(), out row) && int.TryParse(command[2].ToString(), out column) && row <= board.GetLength(0) && column <= board.GetLength(1)) { command = "turn"; } } switch (command) { case "top": PrintHighscores(highScores); break; case "restart": board = CreateBoard(); mines = PlaceMines(); PrintBoard(board); break; case "exit": Console.WriteLine("Bye, bye!"); break; case "turn": if (mines[row, column] != '*') { if (mines[row, column] == '-') { PlayerTurn(board, mines, row, column); counter++; } if (MaxScore == counter) { maxResultAchieved = true; } else { PrintBoard(board); } } else { isMine = true; } break; default: Console.WriteLine("\nError! Invalid command!\n"); break; } if (isMine) { PrintBoard(mines); Console.Write("\nBOOM! You died heroically with {0} points. Enter your nickname: ", counter); string nickname = Console.ReadLine(); Points result = new Points(nickname, counter); if (highScores.Count < 5) { highScores.Add(result); } else { for (int i = 0; i < highScores.Count; i++) { if (highScores[i].UserPoints < result.UserPoints) { highScores.Insert(i, result); highScores.RemoveAt(highScores.Count - 1); break; } } } highScores.Sort((result1, result2) => string.Compare( result2.UserName, result1.UserName, StringComparison.Ordinal)); highScores.Sort((result1, result2) => result2.UserPoints.CompareTo(result1.UserPoints)); PrintHighscores(highScores); board = CreateBoard(); mines = PlaceMines(); counter = 0; isMine = false; inGame = true; } if (maxResultAchieved) { Console.WriteLine("\nCongratulations! You opened 35 cells!"); PrintBoard(mines); Console.WriteLine("Enter your name: "); string name = Console.ReadLine(); Points result = new Points(name, counter); highScores.Add(result); PrintHighscores(highScores); board = CreateBoard(); mines = PlaceMines(); counter = 0; maxResultAchieved = false; inGame = true; } } while (command != "exit"); Console.WriteLine("Made in Bulgaria"); Console.Read(); }
private List <AreaPoints> GenerateAreaPointsList(int countOfClasses) => Points.GenerateCenters(countOfClasses).Select(x => new AreaPoints(x)).ToList();