Example #1
0
        public static string effect_to_string(ActionEffect e)
        {
            string res = "";

            // Speed
            if (e.speed == Speed.Speed1)
            {
                res += "A";
            }
            else if (e.speed == Speed.Speed2)
            {
                res += "AB";
            }

            // Direction
            if (e.y == Direction1.Backward)
            {
                res += "U";
            }
            else if (e.y == Direction1.Forward)
            {
                res += "D";
            }

            if (e.x == Direction1.Backward)
            {
                res += "L";
            }
            else if (e.x == Direction1.Forward)
            {
                res += "R";
            }

            return(res);
        }
Example #2
0
        public static ActionEffect action_to_effect(Action a)
        {
            ActionEffect res = new ActionEffect();

            res.speed = Speed.Speed0;
            res.x     = Direction1.None;
            res.y     = Direction1.None;

            if (a != Action.NoButton)
            {
                int i = (int)a - 1;
                res.speed = (Speed)(i / 8);

                int dir = i % 8;
                switch (dir)
                {
                case 0:
                    res.y = Direction1.Backward;
                    break;

                case 1:
                    res.y = Direction1.Forward;
                    break;

                case 2:
                    res.x = Direction1.Backward;
                    break;

                case 3:
                    res.x = Direction1.Forward;
                    break;

                case 4:
                    res.y = Direction1.Backward;
                    res.x = Direction1.Backward;
                    break;

                case 5:
                    res.y = Direction1.Backward;
                    res.x = Direction1.Forward;
                    break;

                case 6:
                    res.y = Direction1.Forward;
                    res.x = Direction1.Backward;
                    break;

                case 7:
                    res.y = Direction1.Forward;
                    res.x = Direction1.Forward;
                    break;
                }
            }
            return(res);
        }
Example #3
0
        public static Action effect_to_action(ActionEffect e)
        {
            Action res = Action.NoButton;

            if (e.y == Direction1.Backward)
            {
                if (e.x == Direction1.Backward)
                {
                    res = Action.UpLeft1;
                }
                if (e.x == Direction1.None)
                {
                    res = Action.Up1;
                }
                if (e.x == Direction1.Forward)
                {
                    res = Action.UpRight1;
                }
            }
            if (e.y == Direction1.None)
            {
                if (e.x == Direction1.Backward)
                {
                    res = Action.Left1;
                }
                if (e.x == Direction1.Forward)
                {
                    res = Action.Right1;
                }
            }
            if (e.y == Direction1.Forward)
            {
                if (e.x == Direction1.Backward)
                {
                    res = Action.DownLeft1;
                }
                if (e.x == Direction1.None)
                {
                    res = Action.Down1;
                }
                if (e.x == Direction1.Forward)
                {
                    res = Action.DownRight1;
                }
            }

            res = change_action_speed(res, e.speed);
            return(res);
        }
Example #4
0
        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);
        }