Vector2 CellToWorld(iPoint cell) { var new_y = cell.y * m_lineHeight + m_bubbleRadius; var new_x = m_bubbleRadius * cell.x + m_bubbleRadius; return(new Vector2(new_x, new_y)); }
/// <summary> /// основной конструктор /// </summary> /// <param name="number_Window">номер бота (номер окна)</param> public botWindow(int number_Window) { numberWindow = number_Window; // эта инфа поступает при создании объекта класса botParam = new BotParam(numberWindow); //globalParam = new GlobalParam(); #region Вариант 1. переменные класса подчитываются из текстовых файлов //this.databot = LoadUserDataBot(TypeLoadUserData.txt); #endregion #region Вариант 2. переменные класса подчитываются из БД //this.databot = LoadUserDataBot(TypeLoadUserData.db); #endregion //this.statusOfAtk = GetStatusOfAtk(); //значение статуса, 1 - мы уже били босса, 0 - нет // serverFactory = new ServerFactory(number_Window); serverFactory = new ServerFactory(this); server = serverFactory.create(); // создали конкретный экземпляр класса server по паттерну "простая Фабрика" (Америка, Европа или Синг) // точки для тыканья. универсально для всех серверов this.pointButtonClose = new Point(850 - 5 + botParam.X, 625 - 5 + botParam.Y); //(848, 620); this.pointOneMode = new Point(123 - 5 + botParam.X, 489 - 5 + botParam.Y); // 118, 484 }
// =============================== Методы ================================================== /// <summary> /// получаем следующую точку маршрута /// </summary> /// <returns></returns> public override iPoint RouteNextPoint() { iPoint [,] route = { { new Point(505 - 5 + xx, 505 - 5 + yy), new Point(462 - 5 + xx, 468 - 5 + yy), new Point(505 - 5 + xx, 474 - 5 + yy) }, { new Point(569 - 5 + xx, 414 - 5 + yy), new Point(511 - 5 + xx, 436 - 5 + yy), new Point(563 - 5 + xx, 444 - 5 + yy) }, { new Point(334 - 5 + xx, 375 - 5 + yy), new Point(287 - 5 + xx, 350 - 5 + yy), new Point(286 - 5 + xx, 400 - 5 + yy) }, { new Point(404 - 5 + xx, 339 - 5 + yy), new Point(362 - 5 + xx, 319 - 5 + yy), new Point(410 - 5 + xx, 289 - 5 + yy) }, { new Point(379 - 5 + xx, 352 - 5 + yy), new Point(306 - 5 + xx, 347 - 5 + yy), new Point(350 - 5 + xx, 312 - 5 + yy) }, { new Point(540 - 5 + xx, 479 - 5 + yy), new Point(476 - 5 + xx, 467 - 5 + yy), new Point(521 - 5 + xx, 442 - 5 + yy) } }; iPoint result = route[NumberOfRoute(), counterRouteNode]; return(result); }
// =============================== Методы ================================================== /// <summary> /// получаем следующую точку маршрута /// </summary> /// <returns></returns> public override iPoint RouteNextPoint() { iPoint[] route = { new Point(505 - 5 + xx, 505 - 5 + yy), new Point(462 - 5 + xx, 468 - 5 + yy), new Point(492 - 5 + xx, 437 - 5 + yy), new Point(539 - 5 + xx, 486 - 5 + yy), new Point(462 - 5 + xx, 468 - 5 + yy) }; iPoint result = route[CounterRouteNode]; CounterRouteNode++; if (CounterRouteNode > 4) { CounterRouteNode = 0; } return(result); }
// =============================== Методы ================================================== /// <summary> /// получаем следующую точку маршрута /// </summary> /// <returns></returns> public override iPoint RouteNextPoint() { iPoint[] route = { new Point(387 - 5 + xx, 461 - 5 + yy), new Point(311 - 5 + xx, 455 - 5 + yy), new Point(290 - 5 + xx, 352 - 5 + yy), new Point(308 - 5 + xx, 249 - 5 + yy), new Point(412 - 5 + xx, 267 - 5 + yy), new Point(498 - 5 + xx, 311 - 5 + yy), new Point(498 - 5 + xx, 388 - 5 + yy), new Point(487 - 5 + xx, 448 - 5 + yy) }; iPoint result = route[counterRouteNode]; return(result); }
static ArrayList GetMonotonIntervals(iPoint[] Pts) { ArrayList result = new ArrayList(); int n = Pts.Length; if (n == 0) return result; ArrayList L = new ArrayList(); //----- Start with Strong Monoton (Pts[i].y < Pts[i+1].y) or (Pts[i].y > Pts[i+1].y) int FirstStrongMonoton = 0; while (Pts[FirstStrongMonoton].y == Pts[FirstStrongMonoton + 1].y) FirstStrongMonoton++; bool Up = (Pts[FirstStrongMonoton].y < Pts[FirstStrongMonoton + 1].y); MonotonInterval Interval = new MonotonInterval(Up, FirstStrongMonoton, FirstStrongMonoton); L.Add(Interval); int i = FirstStrongMonoton; do { // Interval.to = i; if ((Pts[i].y == Pts[mod(i + 1, n)].y) || (Up == (Pts[i].y < Pts[mod(i + 1, n)].y))) Interval.to = i; else { Up = (Pts[i].y < Pts[mod(i + 1, n)].y); Interval = new MonotonInterval(Up, i, i); L.Add(Interval); } i = mod(i + 1, n); } while (i != FirstStrongMonoton); if (L.Count / 2 * 2 != L.Count) {// Connect the Last with first MonotonInterval M0 = (MonotonInterval)L[0]; MonotonInterval ML = (MonotonInterval)L[L.Count - 1]; M0.from = ML.from; L.RemoveAt(L.Count - 1); } //----- order now by the min y - value of interval to result // and as second Key by the x-value // while (L.Count > 0) { MonotonInterval M = (MonotonInterval)L[0]; i = 0; // order by y-value while ((i < result.Count) && (Pts[M.Min()].y > Pts[((MonotonInterval)result[i]).Min()].y)) i++; // order by x- value as second Key while ((i < result.Count) && (Pts[M.Min()].y == Pts[((MonotonInterval)result[i]).Min()].y) && (Pts[M.Min()].x > (Pts[((MonotonInterval)result[i]).Min()].x))) i++; result.Insert(i, M); L.RemoveAt(0); } return result; }
void CheckEliminate(iPoint pt, int color, List <BubbleCell> eraseList, int threshold) { m_openTable.Clear(); m_closedTable.Clear(); var count = 1; try { m_openTable.Add(new iPoint(pt.x, pt.y)); while (m_openTable.Count > 0) { int last = m_openTable.Count - 1; iPoint cur = m_openTable[last]; m_openTable.RemoveAt(last); m_closedTable.Add(cur); var a = new iPoint(cur.x + 2, cur.y); if (GetBubbleColor(a.x, a.y) == color) { if (!m_closedTable.Contains(a)) { m_openTable.Add(a); ++count; } } var b = new iPoint(cur.x - 2, cur.y); if (GetBubbleColor(b.x, b.y) == color) { if (!m_closedTable.Contains(b)) { m_openTable.Add(b); ++count; } } var c = new iPoint(cur.x - 1, cur.y - 1); if (GetBubbleColor(c.x, c.y) == color) { if (!m_closedTable.Contains(c)) { m_openTable.Add(c); ++count; } } var d = new iPoint(cur.x + 1, cur.y + 1); if (GetBubbleColor(d.x, d.y) == color) { if (!m_closedTable.Contains(d)) { m_openTable.Add(d); ++count; } } var e = new iPoint(cur.x - 1, cur.y + 1); if (GetBubbleColor(e.x, e.y) == color) { if (!m_closedTable.Contains(e)) { m_openTable.Add(e); ++count; } } var f = new iPoint(cur.x + 1, cur.y - 1); if (GetBubbleColor(f.x, f.y) == color) { if (!m_closedTable.Contains(f)) { m_openTable.Add(f); ++count; } } } } finally { if (eraseList != null) { if (m_closedTable.Count > threshold) { foreach (iPoint p in m_closedTable) { var b = GetBubble(p.x, p.y); if (b != null && b.go != null) { m_eraseList.Add(b); } } } } m_openTable.Clear(); m_closedTable.Clear(); } }
private void canvas1_MouseMove(object sender, MouseEventArgs e) { if (toolState>0) return; cur_p = new iPoint(e.GetPosition(this.canvas1)); /* Frank: My own custom drawline with variable thickness (still needs some work) bm = new WriteableBitmap(canvas1, null); int x1 = cur_p.x; int y1 = cur_p.y; int x2 = prev_p.x; int y2 = prev_p.y; double pp_x = y1 - y2; double pp_y = x2 - x1; double mag = Math.Sqrt(pp_x * pp_x + pp_y * pp_y); //normalize pp_x /= mag; pp_y /= mag; for (int i = 0; i < Globals.brushSize; i++) bm.DrawLine((int)(x1 + pp_x * i), (int)(y1 + pp_y * i), (int)(x2 + pp_x * i), (int)(y2 + pp_y * i), Globals.scb.Color); bm.Invalidate(); updateCanvasFromWBM(bm); */ Line line = new Line() { X1 = cur_p.x, Y1 = cur_p.y, X2 = prev_p.x, Y2 = prev_p.y }; line.Stroke = new SolidColorBrush(Globals.scb.Color); line.StrokeThickness = Globals.brushSize; line.StrokeStartLineCap = Globals.plc; this.canvas1.Children.Add(line); prev_p = cur_p; }
void Sweep(List <BubbleCell> eraseList) { eraseList.Clear(); m_openTable.Clear(); m_closedTable.Clear(); var cells = GetLine(0); if (cells != null) { for (int i = 0; i < cells.Length; ++i) { var b = GetBubble(i, 0); if (b != null && b.go != null) { var pt = new iPoint(b.x, b.y); m_closedTable.Add(pt); m_openTable.Add(pt); } } } var count = 1; try { while (m_openTable.Count > 0) { int last = m_openTable.Count - 1; iPoint cur = m_openTable[last]; m_openTable.RemoveAt(last); m_closedTable.Add(cur); var a = new iPoint(cur.x + 2, cur.y); var aa = GetBubble(a.x, a.y); if (aa != null && aa.go != null) { if (!m_closedTable.Contains(a)) { m_openTable.Add(a); ++count; } } var b = new iPoint(cur.x - 2, cur.y); var bb = GetBubble(b.x, b.y); if (bb != null && bb.go != null) { if (!m_closedTable.Contains(b)) { m_openTable.Add(b); ++count; } } var c = new iPoint(cur.x - 1, cur.y - 1); var cc = GetBubble(c.x, c.y); if (cc != null && cc.go != null) { if (!m_closedTable.Contains(c)) { m_openTable.Add(c); ++count; } } var d = new iPoint(cur.x + 1, cur.y + 1); var dd = GetBubble(d.x, d.y); if (dd != null && dd.go != null) { if (!m_closedTable.Contains(d)) { m_openTable.Add(d); ++count; } } var e = new iPoint(cur.x - 1, cur.y + 1); var ee = GetBubble(e.x, e.y); if (ee != null && ee.go != null) { if (!m_closedTable.Contains(e)) { m_openTable.Add(e); ++count; } } var f = new iPoint(cur.x + 1, cur.y - 1); var ff = GetBubble(f.x, f.y); if (ff != null && ff.go != null) { if (!m_closedTable.Contains(f)) { m_openTable.Add(f); ++count; } } } } finally { if (eraseList != null) { for (int j = 0; j < m_buffer.Count; ++j) { var _cells = GetLine(j); for (int i = 0; i < _cells.Length; ++i) { var b = _cells[i]; if (b != null && b.go != null && b.color != 0) { if (!m_closedTable.Contains(new iPoint(b.x, b.y))) { m_eraseList.Add(b); } } } } } m_openTable.Clear(); m_closedTable.Clear(); } }
static void calc_lon(Path pp) { int i, j, k, k1; int a, b, c, d; int[] ct = { 0, 0, 0, 0 }; int dir; iPoint[] constraint = new iPoint[2]; iPoint cur; iPoint off; iPoint dk; /* direction of k-k1 */ iPoint[] pt = pp.pt; int n = pt.Length; int[] Pivot = new int[n]; int[] nc = new int[n]; /* initialize the nc data structure. Point from each point to the furthest future point to which it is connected by a vertical or horizontal segment. We take advantage of the fact that there is always a direction change at 0 (due to the path decomposition algorithm). But even if this were not so, there is no harm, as in practice, correctness does not depend on the word "furthest" above. */ k = 0; for (i = n - 1; i >= 0; i--) { if (pt[i].x != pt[k].x && pt[i].y != pt[k].y) { k = i + 1; /* necessarily i<n-1 in this case */ } nc[i] = k; } pp.Lon = new int[n]; /* determine pivot points: for each i, let pivk[i] be the furthest k such that all j with i<j<k lie on a line connecting i,k. */ for (i = n - 1; i >= 0; i--) { ct[0] = ct[1] = ct[2] = ct[3] = 0; /* keep track of "directions" that have occurred */ dir = (3 + 3 * (pt[mod(i + 1, n)].x - pt[i].x) + (pt[mod(i + 1, n)].y - pt[i].y)) / 2; ct[dir]++; constraint[0].x = 0; constraint[0].y = 0; constraint[1].x = 0; constraint[1].y = 0; /* find the next k such that no straight line from i to k */ k = nc[i]; k1 = i; while (true) { dir = (3 + 3 * sign(pt[k].x - pt[k1].x) + sign(pt[k].y - pt[k1].y)) / 2; ct[dir]++; /* if all four "directions" have occurred, cut this path */ if ((ct[0] == 1) && (ct[1] == 1) && (ct[2] == 1) && (ct[3] == 1)) { Pivot[i] = k1; goto foundk; } cur.x = pt[k].x - pt[i].x; cur.y = pt[k].y - pt[i].y; /* see if current constraint is violated */ if (xprod(constraint[0], cur) < 0 || xprod(constraint[1], cur) > 0) { goto constraint_viol; } /* else, update constraint */ if (abs(cur.x) <= 1 && abs(cur.y) <= 1) { /* no constraint */ } else { off.x = cur.x + ((cur.y >= 0 && (cur.y > 0 || cur.x < 0)) ? 1 : -1); off.y = cur.y + ((cur.x <= 0 && (cur.x < 0 || cur.y < 0)) ? 1 : -1); if (xprod(constraint[0], off) >= 0) { constraint[0] = off; } off.x = cur.x + ((cur.y <= 0 && (cur.y < 0 || cur.x < 0)) ? 1 : -1); off.y = cur.y + ((cur.x >= 0 && (cur.x > 0 || cur.y < 0)) ? 1 : -1); if (xprod(constraint[1], off) <= 0) { constraint[1] = off; } } k1 = k; k = nc[k1]; if (!cyclic(k, i, k1)) { break; } } constraint_viol: /* k1 was the last "corner" satisfying the current constraint, and k is the first one violating it. We now need to find the last point along k1..k which satisfied the constraint. */ dk.x = sign(pt[k].x - pt[k1].x); dk.y = sign(pt[k].y - pt[k1].y); cur.x = pt[k1].x - pt[i].x; cur.y = pt[k1].y - pt[i].y; /* find largest integer j such that xprod(constraint[0], cur+j*dk) >= 0 and xprod(constraint[1], cur+j*dk) <= 0. Use bilinearity of xprod. */ a = xprod(constraint[0], cur); b = xprod(constraint[0], dk); c = xprod(constraint[1], cur); d = xprod(constraint[1], dk); /* find largest integer j such that a+j*b>=0 and c+j*d<=0. This can be solved with integer arithmetic. */ j = int.MaxValue; if (b < 0) { j = floordiv(a, -b); } if (d > 0) { j = min(j, floordiv(-c, d)); } Pivot[i] = mod(k1 + j, n); foundk: ; } /* for i */ /* clean up: for each i, let lon[i] be the largest k such that for all i' with i<=i'<k, i'<k<=pivk[i']. */ j = Pivot[n - 1]; pp.Lon[n - 1] = j; for (i = n - 2; i >= 0; i--) { if (cyclic(i + 1, Pivot[i], j)) { j = Pivot[i]; } pp.Lon[i] = j; } for (i = n - 1; cyclic(mod(i + 1, n), j, pp.Lon[i]); i--) { pp.Lon[i] = j; } }
public int MinY(iPoint[] Pts) { return Pts[Min()].y; }
public int MaxY(iPoint[] Pts) { return Pts[Max()].y; }
public static MathPoint MathPoint(this iPoint pt) { return(Mu.CreatePoint(pt.X, pt.Y, pt.Z)); }
/* */ /// <summary> /// Compute a path in the binary matrix. /// Start path at the point (x0,x1), which must be an upper left corner /// of the path. Also compute the area enclosed by the path. Return a /// new path_t object, or NULL on error (note that a legitimate path /// cannot have length 0). /// We omit turnpolicies and sign /// </summary> /// <param name="Matrix">Binary Matrix</param> /// <returns></returns> static Path findpath(bool[,] Matrix, iPoint Start) { ArrayList L = new ArrayList(); direction Dir = direction.North; int x; int y; int area = 0; int diry = -1; x = Start.x; y = Start.y; do { // area += x * diry; L.Add(new iPoint(x, y)); int _y = y; findNextTrace(Matrix, ref x, ref y, ref Dir); diry = _y - y; area += x * diry; } while ((x != Start.x) || (y != Start.y)); if (L.Count == 0) return null; Path result = new Path(); result.pt = new iPoint[L.Count]; result.area = area; for (int i = 0; i < L.Count; i++) result.pt[i] = (iPoint)L[i]; // Shift 1 to be compatible with Potrace if (result.pt.Length > 0) { iPoint P = result.pt[result.pt.Length - 1]; for (int i = result.pt.Length - 1; i >= 0; i--) { if (i > 0) result.pt[i] = result.pt[i - 1]; else result.pt[0] = P; } } result.MonotonIntervals = GetMonotonIntervals(result.pt); return result; }
public double DistanceDe3D(iPoint pt) { return(Math.Sqrt(Math.Pow(pt.X - X, 2) + Math.Pow(pt.Y - Y, 2) + Math.Pow(pt.Z - Z, 2))); }
public double DistanceDe2D(iPoint pt) { return(Math.Abs(pt.DistanceDe2D(Centre) - Rayon)); }
public iArc(iPoint centre, double rayon, iPointOnSpline p1, iPointOnSpline p2, iPointOnSpline p3) { Centre = centre; Rayon = rayon; P1 = p1; P2 = p2; P3 = p3; }
public iCercle(iPoint centre, double rayon) { Centre = centre; Rayon = rayon; }
/* calculate p1 x p2 */ static int xprod(iPoint p1, iPoint p2) { return p1.x * p2.y - p1.y * p2.x; }
public frmSetPoint(String IDStudent,iPoint Input) { InitializeComponent(); _iPoint=Input; _idStudent = IDStudent; }
private void canvas1_MouseLeftButtonDown(object sender, MouseButtonEventArgs e) { if (toolState == 0) { canvas1.CaptureMouse(); if (!activelyDrawing && toolState == 0) //just started to draw, save state first (in order to undo) { updateUndoList(); activelyDrawing = true; } cur_p.x = (short)e.GetPosition(canvas1).X; cur_p.y = (short)e.GetPosition(canvas1).Y; prev_p = cur_p; } else if (toolState == 2) { bm = new WriteableBitmap(canvas1, null); Globals.scb.Color = bm.GetPixel((int)e.GetPosition(canvas1).X, (int)e.GetPosition(canvas1).Y); border2.Background = Globals.scb; makeToast("Color Sampled", ""); toolState++; fillClick(null, null); //to move to pencil mode //NavigationService.Navigate(new Uri("/ColorPicker.xaml", UriKind.Relative)); } }