protected override void OnPaint(PaintEventArgs pe) { base.OnPaint(pe); Graphics g = CreateGraphics(); g.Clear(BackColor); int start_x = 0; int start_y = 0; float scale = 1; if (bmap != null) { scale = Math.Min((float)Width / bmap.Width, (float)Height / bmap.Height); start_x = (Width - (int)(bmap.Width * scale)) / 2; start_y = (Height - (int)(bmap.Height * scale)) / 2; g.DrawImage(bmap, start_x, start_y, bmap.Width * scale, bmap.Height * scale); computed_bmp_start_x = start_x; computed_bmp_start_y = start_y; } computed_bmp_start_x = start_x; computed_bmp_start_y = start_y; computed_scale = scale; if (highlight_map != null) { Brush b = new SolidBrush(highlight_color); int size = (int)Math.Ceiling(computed_scale); for (int i = 0; i < highlight_map.GetLength(0); i++) { for (int j = 0; j < highlight_map.GetLength(1); j++) { if (highlight_map[i, j]) { Rectangle dest = new Rectangle((int)(computed_bmp_start_x + j * computed_scale), (int)(computed_bmp_start_y + i * computed_scale), size, size); g.FillRectangle(b, dest); } } } } int real_start_x = start_x - (int)(computed_start_pixel.x * scale); int real_start_y = start_y - (int)(computed_start_pixel.y * scale); void drawRectangle(Rectangle r, Color c, bool fill = true) { float x = r.X; float y = r.Y; float w = r.Width; float h = r.Height; if (fill) { g.FillRectangle(new SolidBrush(c), real_start_x + x * scale, real_start_y + y * scale, w * scale, h * scale); } else { g.DrawRectangle(new Pen(c, 1), real_start_x + x * scale, real_start_y + y * scale, (w - 1) * scale, (h - 1) * scale); } } void drawCircle(int cx, int cy, int r, Color c, bool fill = true) { float x = cx - r; float y = cy - r; float w = 2 * r - 1; float h = 2 * r - 1; if (fill) { g.FillEllipse(new SolidBrush(c), real_start_x + x * scale, real_start_y + y * scale, w * scale, h * scale); } else { g.DrawEllipse(new Pen(c, 1), real_start_x + x * scale, real_start_y + y * scale, w * scale, h * scale); } } if (showO && m != null && (helirin == null || !helirin.Value.hasBonus)) { Rectangle?bonus = m.GetBonusPxRect(); if (bonus.HasValue) { drawRectangle(bonus.Value, Color.MediumPurple); } if (helirin != null && Settings.enable_moving_objects) { foreach (Piston p in m.Pistons) { drawRectangle(p.PreciseBoxAtTime(helirin.Value.frameNumber), Color.FromArgb(0xFF, 0x77, 0x22, 0x77), false); } foreach (Roller r in m.Rollers) { Roller.Ball b = r.PreciseBoxAtTime(helirin.Value.frameNumber); if (b != null) { drawCircle(b.cx, b.cy, b.r, Color.FromArgb(0xFF, 0x77, 0x77, 0x22), false); } } } } if (helirin != null) { GraphicalHelirin h = helirin.Value; Pen myPen = new Pen(Color.Black, 1); int offset_x = h.pixelX - Map.helirin_radius; int offset_y = h.pixelY - Map.helirin_radius; int size = Map.helirin_radius * 2; g.DrawEllipse(myPen, real_start_x + offset_x * scale, real_start_y + offset_y * scale, size * scale, size * scale); offset_x = h.pixelX - 2; offset_y = h.pixelY - 2; size = 4; g.DrawEllipse(myPen, real_start_x + offset_x * scale, real_start_y + offset_y * scale, size * scale, size * scale); Size o = new Size(real_start_x, real_start_y); Point p1 = new Point((int)(h.pixelX + Math.Sin(h.angle) * Map.helirin_radius), (int)(h.pixelY - Math.Cos(h.angle) * Map.helirin_radius)); Point p2 = new Point((int)(h.pixelX - Math.Sin(h.angle) * Map.helirin_radius), (int)(h.pixelY + Math.Cos(h.angle) * Map.helirin_radius)); p1 = new Point((int)(p1.X * scale), (int)(p1.Y * scale)); p2 = new Point((int)(p2.X * scale), (int)(p2.Y * scale)); g.DrawLine(myPen, Point.Add(p1, o), Point.Add(p2, o)); } }
public HelirinState Next(HelirinState st, Action a) { if (st == null) { return(null); } if (st.IsTerminal()) { return(st); } ActionEffect e = Controller.action_to_effect(a); st = st.ShallowCopy(); st.frameNumber += 1; if (st.life > Settings.full_life) { st.life = Settings.full_life; } if (st.invul > Settings.invul_frames) { st.invul = Settings.invul_frames; } // 1. Set input speed (XS and YS) depending on inputs int[] speeds = input_speeds; if (e.x != Direction1.None && e.y != Direction1.None) { speeds = input_speeds_2; } int speed = speeds[(int)e.speed]; int xs = (int)e.x * speed; int ys = (int)e.y * speed; // 2. Reduce bump speed / bump rotation (XB, YB and Rot_rate) / invulnerability short rot_diff = (short)(st.rot_srate - st.rot_rate); if (rot_diff < -rotation_rate_decr) { rot_diff = -rotation_rate_decr; } if (rot_diff > rotation_rate_decr) { rot_diff = rotation_rate_decr; } st.rot_rate = (short)(st.rot_rate + rot_diff); st.xb = st.xb * bump_speed_decrease_numerator / bump_speed_decrease_denominator; st.yb = st.yb * bump_speed_decrease_numerator / bump_speed_decrease_denominator; if (st.invul > 0) { st.invul--; } // 3. Move depending on speed (bump+input), rotate depending on rotation rate (Rot_rate) st.xpos += xs + st.xb; st.ypos += ys + st.yb; st.rot += st.rot_rate; // 4. Detection of healing/ending zones // Position seems to be converted to px with a shift: subpixels seem to be ignored even in negative positions. bool safe_zone = false; Map.Zone zone = map.IsPixelInZone(pos_to_px(st.xpos), pos_to_px(st.ypos)); if (zone == Map.Zone.Healing || zone == Map.Zone.Starting) { safe_zone = true; if (st.life < Settings.full_life) { st.life = Settings.full_life; } } if (zone == Map.Zone.Ending) { st.gs = st.gs == GameState.InGameWithBonus ? GameState.WinWithBonus : GameState.Win; return(st); } // At this point, we backup the rotation data (will be needed later) short rot_rate_bkp = st.rot_rate; // No need to backup st.rot because it will not change anymore // We also precompute all the helirin physical points and the collision mask // TODO: Optionally, use memoisation to avoid recomputing collision mask each time short[] pxs = new short[helirin_points.Length]; short[] pys = new short[helirin_points.Length]; uint collision_mask = 0; for (int i = 0; i < helirin_points.Length; i++) { int radius = helirin_points[i]; // Position seems to be converted to px BEFORE adding the result of the sin/cos (it seems to ignore subpixels, even in negative positions). short px = (short)(pos_to_px(st.xpos) - math.sin(radius, st.rot)); short py = (short)(pos_to_px(st.ypos) + math.cos(radius, st.rot)); pxs[i] = px; pys[i] = py; // Compute collision mask if (map.IsPixelInCollision(px, py)) { collision_mask |= ((uint)1 << i); } } // 5. Action of springs & bonus HashSet <int> spring_already_visited = new HashSet <int>(); bool invert_rotation = false; bool update_rot_rate = false; foreach (int i in helirin_points_order_for_springs) // Order is important for spring actions. { int radius = helirin_points[i]; short px = pxs[i]; short py = pys[i]; // Action of springs Map.Spring[] springs = map.IsPixelInSpring(px, py); foreach (Map.Spring spr in springs) { if (!spring_already_visited.Contains(spr.unique_id)) { spring_already_visited.Add(spr.unique_id); if (radius != 0) { update_rot_rate = true; // Invert rotation if at least one spring is in the right direction if (!invert_rotation) { short spring_angle = AngleOfSpring(spr.type); short helirin_angle = radius > 0 ? st.rot : (short)(st.rot + (0x10000 / 2)); short helirin_normal_angle = (short)(helirin_angle + Math.Sign(st.rot_srate) * (0x10000 / 4)); short diff = (short)(spring_angle - helirin_normal_angle); if (Math.Abs((int)diff) > 0x10000 / 4) { invert_rotation = true; } } } // Position bump if (spr.type == Map.SpringType.Up) { st.xb = 0; st.yb = -bump_speed_spring; } if (spr.type == Map.SpringType.Down) { st.xb = 0; st.yb = bump_speed_spring; } if (spr.type == Map.SpringType.Left) { st.xb = -bump_speed_spring; st.yb = 0; } if (spr.type == Map.SpringType.Right) { st.xb = bump_speed_spring; st.yb = 0; } st.xpos += st.xb; st.ypos += st.yb; } } // Action of bonus if (map.IsPixelInBonus(px, py) != Map.BonusType.None) { st.gs = GameState.InGameWithBonus; } } if (invert_rotation) { st.rot_srate = (short)(-st.rot_srate); } if (update_rot_rate) { st.rot_rate = (short)(Math.Sign(st.rot_srate) * rot_bump_rate_spring); if (st.rot_rate == 0) { st.rot_rate = -rot_bump_rate_spring; } } // 6. Action of moving objects uint object_collision_mask = 0; if (Settings.enable_moving_objects) { List <Roller.Ball> balls = new List <Roller.Ball>(); foreach (Roller r in map.Rollers) { Roller.Ball ball = r.PreciseBoxAtTime(st.frameNumber); if (ball != null) { balls.Add(ball); } } balls.Sort((x, y) => x < y ? -1 : (x > y ? 1 : 0)); foreach (Roller.Ball ball in balls) { uint elt_collision_mask = 0; for (int i = 0; i < helirin_points.Length; i++) { // For rollers, position of physical points must be recomputed to take into account last position/rotation changes // EDIT: Seems not... At least, spring actions should not affect it /*int radius = helirin_points[i]; * short px = (short)(pos_to_px(st.xpos) - math.sin(radius, st.rot)); * short py = (short)(pos_to_px(st.ypos) + math.cos(radius, st.rot));*/ short px = pxs[i]; short py = pys[i]; if (ball.InCollisionWith(px, py)) { elt_collision_mask |= ((uint)1 << i); } } if (elt_collision_mask != 0) { object_collision_mask |= elt_collision_mask; ObjectHitReact(st, elt_collision_mask, /*pxs[0], pys[0],*/ pos_to_px(st.xpos), pos_to_px(st.ypos), ball.cx, ball.cy); } } foreach (Piston p in map.Pistons) { Rectangle?box = null; uint elt_collision_mask = 0; for (int i = 0; i < helirin_points.Length; i++) { short px = pxs[i]; short py = pys[i]; if (p.dangerArea.Contains(px, py)) { if (box == null) { box = p.PreciseBoxAtTime(st.frameNumber); } if (box.Value.Contains(px, py)) { elt_collision_mask |= ((uint)1 << i); } } } if (elt_collision_mask != 0) { object_collision_mask |= elt_collision_mask; ObjectHitReact(st, elt_collision_mask, /*pxs[0], pys[0],*/ pos_to_px(st.xpos), pos_to_px(st.ypos), box.Value.X + (box.Value.Width - 1) / 2, box.Value.Y + (box.Value.Height - 1) / 2); } } } if (collision_mask != 0 || object_collision_mask != 0) // If collision with a wall OR a moving object { // 7. Damage and substract input speed (XS and YS) to position if (!safe_zone) { if (st.invul == 0) { st.invul = Settings.invul_frames; st.life--; } } st.xpos -= xs; st.ypos -= ys; if (collision_mask != 0) // If collision with a wall { // 8. Bump action // - Modify bump speed and rot rate (XB, YB and Rot_rate) accordingly if relevant // - If modified, apply this newly computed bump speed to position bool up_side = (collision_mask & up_mask) != 0; bool down_side = (collision_mask & down_mask) != 0; if (up_side && !down_side) { st.xb = -math.sin(auto_bump_speed, st.rot); st.yb = math.cos(auto_bump_speed, st.rot); } if (!up_side && down_side) { st.xb = math.sin(auto_bump_speed, st.rot); st.yb = -math.cos(auto_bump_speed, st.rot); } st.rot_rate = (short)(-Math.Sign(rot_rate_bkp) * rot_bump_rate); if (st.rot_rate == 0) { st.rot_rate = rot_bump_rate; } if (up_side != down_side) { st.xpos += st.xb; st.ypos += st.yb; } // 9. If mask has collision at one of the 3 lowest bits : // - Modify bump speed (XB and YB) depending on input (if any) // - If modified, apply this newly computed bump speed to position if ((collision_mask & middle_mask) != 0 && (e.x != Direction1.None || e.y != Direction1.None)) { int bump_speed = input_bump_speed; if (e.x != Direction1.None && e.y != Direction1.None) { bump_speed = input_bump_speed_2; } st.xb = -(int)e.x * bump_speed; st.yb = -(int)e.y * bump_speed; st.xpos += st.xb; st.ypos += st.yb; } } } // Lose? // TODO: Move up so that some useless computation can be avoided when losing if (st.life == 0) { st.gs = GameState.Lose; } return(st); }