Example #1
0
        internal override bool MoveOn(DirectionEnum directionEnum, ForceEnum force)
        {
            switch (force)
            {
            case ForceEnum.PlayerPush:
                return(move());

            default:
                return(false);
            }
        }
Example #2
0
        internal override bool MoveOn(DirectionEnum directionEnum, ForceEnum force)
        {
            switch (force)
            {
            case ForceEnum.FallingObject:
                tile_.Explode(2);
                return(true);

            default:
                return(false);
            }
        }
Example #3
0
        public static string Abbreviation(this ForceEnum unitEnum)
        {
            switch (unitEnum)
            {
            case ForceEnum.Pounds: return("lb");

            case ForceEnum.Newtons: return("N");

            case ForceEnum.Kilonewtons: return("kN");

            default: throw new ArgumentOutOfRangeException(nameof(unitEnum), unitEnum, null);
            }
        }
Example #4
0
        public static double ConversionFactor(this ForceEnum unitEnum)
        {
            switch (unitEnum)
            {
            case ForceEnum.Pounds: return(1);

            case ForceEnum.Newtons: return(0.22480894309971);

            case ForceEnum.Kilonewtons: return(224.80894309971);

            default: throw new ArgumentOutOfRangeException(nameof(unitEnum), unitEnum, null);
            }
        }
Example #5
0
        internal Tile SlideNeighbour(DirectionEnum direction, Entity entity, ForceEnum force)
        {
            Tile successTile = neighbours[direction].MoveToNeighbour(DirectionEnum.Down, entity, force);

            if (successTile != null)
            {
                Entity_ = null;
                return(successTile);
            }
            else
            {
                return(null);
            }
        }
Example #6
0
        internal override bool MoveOn(DirectionEnum directionEnum, ForceEnum force)
        {
            switch (force)
            {
            case ForceEnum.PlayerPush:
                Game.Instance.player.addScore(100);
                Game.Instance.removeDiamondCount();
                tile_ = null;
                return(true);

            default:
                return(false);
            }
        }
Example #7
0
        internal override bool MoveOn(DirectionEnum directionEnum, ForceEnum force)
        {
            switch (force)
            {
            case ForceEnum.PlayerPush:
                if (open == false)
                {
                    return(false);
                }
                tile_ = null;
                return(true);

            default:
                return(false);
            }
        }
Example #8
0
        internal override bool MoveOn(DirectionEnum directionEnum, ForceEnum force)
        {
            switch (force)
            {
            case ForceEnum.PlayerPush:
                if (directionEnum == DirectionEnum.Up)
                {
                    return(false);
                }
                else
                {
                    return(move(directionEnum));
                }

            default:
                return(false);
            }
        }
Example #9
0
 internal Tile MoveOn(DirectionEnum direction, Entity entity, ForceEnum force)
 {
     if (Entity_ == null)
     {
         Entity_ = entity;
         return(this);
     }
     else
     {
         if (Entity_.MoveOn(direction, force))
         {
             Entity_ = entity;
             return(this);
         }
         else
         {
             return(null);
         }
     }
 }
Example #10
0
        internal override bool MoveOn(DirectionEnum directionEnum, ForceEnum force)
        {
            switch (force)
            {
            case ForceEnum.FireflyPush:
                alive = false;
                tile_.Explode(2);
                tile_ = null;
                return(true);

            case ForceEnum.FallingObject:
                alive = false;
                tile_.Explode(2);
                tile_ = null;
                return(true);

            default:
                return(false);
            }
        }
Example #11
0
        internal Tile MoveToNeighbour(DirectionEnum direction, Entity entity, ForceEnum force)
        {
            if (entity != Entity_)
            {
                if (Entity_ != null)
                {
                    return(null);
                }
            }
            Tile successTile = neighbours[direction].MoveOn(direction, entity, force);

            if (successTile != null)
            {
                Entity_ = null;
                return(successTile);
            }
            else
            {
                return(null);
            }
        }
Example #12
0
    public float this[int y, int x, ForceEnum e]
    {
        get
        {
            switch (e)
            {
            default:
            case ForceEnum.Attract:
                return(attract[y * Count + x]);

            case ForceEnum.MinR:
                return(minR[y * Count + x]);

            case ForceEnum.MaxR:
                return(maxR[y * Count + x]);
            }
        }
        set
        {
            switch (e)
            {
            default:
            case ForceEnum.Attract:
                attract[y * Count + x] = value;
                break;

            case ForceEnum.MinR:
                minR[y * Count + x] = value;
                break;

            case ForceEnum.MaxR:
                maxR[y * Count + x] = value;
                break;
            }
        }
    }
Example #13
0
 ForceType(ForceEnum unitEnum)
 {
     UnitEnum = unitEnum;
 }
Example #14
0
 internal override bool MoveOn(DirectionEnum directionEnum, ForceEnum force)
 {
     return(false);
 }
Example #15
0
 abstract internal bool MoveOn(DirectionEnum directionEnum, ForceEnum force);