public static EngineDirection GetDirection(this EngineGlyphType element)
        {
            switch (element)
            {
            case EngineGlyphType.ActionMoveN:
                return(EngineDirection.North);

            case EngineGlyphType.ActionMoveNE:
                return(EngineDirection.NorthEast);

            case EngineGlyphType.ActionMoveE:
                return(EngineDirection.East);

            case EngineGlyphType.ActionMoveSE:
                return(EngineDirection.SouthEast);

            case EngineGlyphType.ActionMoveS:
                return(EngineDirection.South);

            case EngineGlyphType.ActionMoveSW:
                return(EngineDirection.SouthWest);

            case EngineGlyphType.ActionMoveW:
                return(EngineDirection.West);

            case EngineGlyphType.ActionMoveNW:
                return(EngineDirection.NorthWest);

            case EngineGlyphType.SpecialCameleonN:
                return(EngineDirection.North);

            case EngineGlyphType.SpecialCameleonNE:
                return(EngineDirection.NorthEast);

            case EngineGlyphType.SpecialCameleonE:
                return(EngineDirection.East);

            case EngineGlyphType.SpecialCameleonSE:
                return(EngineDirection.SouthEast);

            case EngineGlyphType.SpecialCameleonS:
                return(EngineDirection.South);

            case EngineGlyphType.SpecialCameleonSW:
                return(EngineDirection.SouthWest);

            case EngineGlyphType.SpecialCameleonW:
                return(EngineDirection.West);

            case EngineGlyphType.SpecialCameleonNW:
                return(EngineDirection.NorthWest);

            default:
                throw new ArgumentOutOfRangeException(nameof(element), element, null);
            }
        }
 public static bool IsMoveAction(this EngineGlyphType element)
 {
     return(element == EngineGlyphType.ActionMoveN ||
            element == EngineGlyphType.ActionMoveNE ||
            element == EngineGlyphType.ActionMoveE ||
            element == EngineGlyphType.ActionMoveSE ||
            element == EngineGlyphType.ActionMoveS ||
            element == EngineGlyphType.ActionMoveSW ||
            element == EngineGlyphType.ActionMoveW ||
            element == EngineGlyphType.ActionMoveNW);
 }
 public static bool IsCameleon(this EngineGlyphType element)
 {
     return(element == EngineGlyphType.SpecialCameleonN ||
            element == EngineGlyphType.SpecialCameleonNE ||
            element == EngineGlyphType.SpecialCameleonE ||
            element == EngineGlyphType.SpecialCameleonSE ||
            element == EngineGlyphType.SpecialCameleonS ||
            element == EngineGlyphType.SpecialCameleonSW ||
            element == EngineGlyphType.SpecialCameleonW ||
            element == EngineGlyphType.SpecialCameleonNW);
 }
        public EngineScreenBuilder SetTileType(int x, int y, EngineGlyphType type)
        {
            if (x < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(x), x, "Cannot be less than 0");
            }
            if (y < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(y), y, "Cannot be less than 0");
            }
            if (x >= _screen.Width)
            {
                throw new ArgumentOutOfRangeException(nameof(x), x, $"Cannot be more than screen width ({_screen.Width})");
            }
            if (y >= _screen.Height)
            {
                throw new ArgumentOutOfRangeException(nameof(y), y, $"Cannot be more than screen height ({_screen.Height})");
            }

            _screen.Tiles[x, y] = new EngineTile(type);

            return(this);
        }
        public RendererGlyph(EngineGlyphType glyphType, int x, int y, int levelWidth, int levelHeight)
        {
            _glyphType = glyphType;
            _cog       = RendererAnimation.GetCogAnimation(GetCogTypeForGlyph(glyphType), (x + y) % 2 == 0);

            var plateIndex = GetPlateTypeForGlyph(glyphType);

            Logger.Debug($"Loading plate texture 'glyph_plate_{plateIndex}'");
            _plate = Gfx.sheet_Ingame[$"glyph_plate_{plateIndex}"];

            Logger.Debug($"Loading glyph 'glyph_{(int)glyphType}'");
            _glyph = Gfx.sheet_Ingame[$"glyph_{(int)glyphType}"];

            _position = new Vector2(
                (S.GlyphAreaWidth - levelWidth * S.GlyphImageEdge) / 2f + S.GlyphAreaMonitorOffsetX + x * S.GlyphImageEdge,
                (S.GlyphAreaHeight - levelHeight * S.GlyphImageEdge) / 2f + S.GlyphAreaMonitorOffsetY + y * S.GlyphImageEdge
                );

            _glyphPosition = new Vector2(
                _position.X + (S.GlyphImageEdge - _glyph.Width) / 2f,
                _position.Y + (S.GlyphImageEdge - _glyph.Height) / 2f
                );
        }
 public static bool IsModifier(this EngineGlyphType element)
 {
     return(element == EngineGlyphType.ModifierIgnore || element == EngineGlyphType.ModifierInvert);
 }
 public static bool IsNumeral(this EngineGlyphType element)
 {
     return(element == EngineGlyphType.NumeralOne || element == EngineGlyphType.NumeralTwo || element == EngineGlyphType.NumeralFour || element == EngineGlyphType.NumeralEight);
 }
 public static bool IsBomb(this EngineGlyphType element)
 {
     return(element == EngineGlyphType.Bomb);
 }
 public static bool IsSlicer(this EngineGlyphType element)
 {
     return(element == EngineGlyphType.SlicerStart || element == EngineGlyphType.SlicerEnd);
 }
 public static bool IsAction(this EngineGlyphType element)
 {
     return(element.IsMoveAction() || element == EngineGlyphType.ActionSpecial);
 }
        private int GetCogTypeForGlyph(EngineGlyphType glyphType)
        {
            switch (glyphType)
            {
            case EngineGlyphType.ActionSpecial: return(CogTraditional);

            case EngineGlyphType.ActionMoveN: return(CogTraditional);

            case EngineGlyphType.ActionMoveNE: return(CogTraditional);

            case EngineGlyphType.ActionMoveE: return(CogTraditional);

            case EngineGlyphType.ActionMoveSE: return(CogTraditional);

            case EngineGlyphType.ActionMoveS: return(CogTraditional);

            case EngineGlyphType.ActionMoveSW: return(CogTraditional);

            case EngineGlyphType.ActionMoveW: return(CogTraditional);

            case EngineGlyphType.ActionMoveNW: return(CogTraditional);

            case EngineGlyphType.NumeralOne: return(CogBladed);

            case EngineGlyphType.NumeralTwo: return(CogBladed);

            case EngineGlyphType.NumeralFour: return(CogBladed);

            case EngineGlyphType.NumeralEight: return(CogBladed);

            case EngineGlyphType.SpecialCameleonN: return(CogRound);

            case EngineGlyphType.SpecialCameleonNE: return(CogRound);

            case EngineGlyphType.SpecialCameleonE: return(CogRound);

            case EngineGlyphType.SpecialCameleonSE: return(CogRound);

            case EngineGlyphType.SpecialCameleonS: return(CogRound);

            case EngineGlyphType.SpecialCameleonSW: return(CogRound);

            case EngineGlyphType.SpecialCameleonW: return(CogRound);

            case EngineGlyphType.SpecialCameleonNW: return(CogRound);

            case EngineGlyphType.OperationMultiplier: return(CogBladed);

            case EngineGlyphType.OperationSubtract: return(CogBladed);

            case EngineGlyphType.ModifierInvert: return(CogShort);

            case EngineGlyphType.ModifierIgnore: return(CogShort);

            case EngineGlyphType.SlicerStart: return(CogThick);

            case EngineGlyphType.SlicerEnd: return(CogThick);

            case EngineGlyphType.Bomb: return(CogHalf);

            default:
                throw new ArgumentOutOfRangeException(nameof(glyphType), glyphType, null);
            }
        }
        private int GetPlateTypeForGlyph(EngineGlyphType glyphType)
        {
            switch (glyphType)
            {
            case EngineGlyphType.ActionSpecial: return(PlateSquare);

            case EngineGlyphType.ActionMoveN: return(PlateSquare);

            case EngineGlyphType.ActionMoveNE: return(PlateSquare);

            case EngineGlyphType.ActionMoveE: return(PlateSquare);

            case EngineGlyphType.ActionMoveSE: return(PlateSquare);

            case EngineGlyphType.ActionMoveS: return(PlateSquare);

            case EngineGlyphType.ActionMoveSW: return(PlateSquare);

            case EngineGlyphType.ActionMoveW: return(PlateSquare);

            case EngineGlyphType.ActionMoveNW: return(PlateSquare);

            case EngineGlyphType.NumeralOne: return(PlateCircle);

            case EngineGlyphType.NumeralTwo: return(PlateCircle);

            case EngineGlyphType.NumeralFour: return(PlateCircle);

            case EngineGlyphType.NumeralEight: return(PlateCircle);

            case EngineGlyphType.SpecialCameleonN: return(PlateDiamond);

            case EngineGlyphType.SpecialCameleonNE: return(PlateDiamond);

            case EngineGlyphType.SpecialCameleonE: return(PlateDiamond);

            case EngineGlyphType.SpecialCameleonSE: return(PlateDiamond);

            case EngineGlyphType.SpecialCameleonS: return(PlateDiamond);

            case EngineGlyphType.SpecialCameleonSW: return(PlateDiamond);

            case EngineGlyphType.SpecialCameleonW: return(PlateDiamond);

            case EngineGlyphType.SpecialCameleonNW: return(PlateDiamond);

            case EngineGlyphType.OperationMultiplier: return(PlateCircle);

            case EngineGlyphType.OperationSubtract: return(PlateCircle);

            case EngineGlyphType.ModifierInvert: return(PlatePentagon);

            case EngineGlyphType.ModifierIgnore: return(PlatePentagon);

            case EngineGlyphType.SlicerStart: return(PlateDeltoid);

            case EngineGlyphType.SlicerEnd: return(PlateDeltoid);

            case EngineGlyphType.Bomb: return(PlateHexagon);

            default:
                throw new ArgumentOutOfRangeException(nameof(glyphType), glyphType, null);
            }
        }
 public EngineTile(EngineGlyphType type)
 {
     Type = type;
 }