Exemple #1
0
        public void Set()
        {
            var d = new Dictionary <string, SpriteLayer>();

            foreach (var layer in layers.layers)
            {
                foreach (var s in layer.Value)
                {
                    d.Add(s.name, layer.Key);
                }
            }
            for (int i = 0; i < transform.childCount; i++)
            {
                var trans = transform.GetChild(i);
                var go    = trans.gameObject;
                var sr    = go.GetComponent <SpriteRenderer>();
                if (sr == null)
                {
                    continue;
                }
                SpriteLayer layer = null;
                if (!d.TryGetValue(sr.sprite.name, out layer))
                {
                    continue;
                }
                layer.SetSprite(sr);
            }
        }
Exemple #2
0
        /// <summary>
        /// Called after the ShooterDemoUserInterface is created,
        /// </summary>
        public void Initialize()
        {
            uiLayer = new SpriteLayer(Game.RenderSystem, 1024);

            //	add console sprite layer to master view layer :
            Game.RenderSystem.SpriteLayers.Add(uiLayer);


            LoadContent();
            Game.Reloading += (s, e) => LoadContent();

            Game.GameClient.ClientStateChanged += GameClient_ClientStateChanged;

            Game.Frames.DefaultFont = Game.Content.Load <SpriteFont>(@"fonts\armata");

            StartMenu = menuGenerator.CreateMenu("startMenu", new StartPageOptions(Game));
            Game.Frames.RootFrame.Add(StartMenu);

            Game.Frames.RootFrame.Resize += (s, e) =>
            {
                Game.Frames.RootFrame.Remove(StartMenu);
                StartMenu = menuGenerator.CreateMenu("startMenu", new StartPageOptions(Game));
                Game.Frames.RootFrame.Add(StartMenu);
            };
        }
Exemple #3
0
    // Use this for initialization
    void Start()
    {
        layer = (SpriteLayer)0;
        Index = 0;

        CollisionMap2D.Instance.SetVisualsEnabled(true);
    }
 //public void createTileAtMousePos(Vector3 mousePos, SpriteLayer layer, int type) {
 //    var tileInstance = TileSpriteManager.Instance.GetInstance(type, layer, mousePos);
 //    currentLevel.layers[layer].SetValue(Vector2int.FromVector2(mousePos), (byte)(type + 1));
 //    resources.Add(tileInstance);
 //}
 public void createTileAtMousePos(Vector3 mousePos, SpriteLayer layer, string type)
 {
     var tileInstance = TileSpriteManager.Instance.GetInstance(type, layer, mousePos);
     int id = TileSpriteManager.Instance.GetIDForName(type, layer) + 1;
     currentLevel.layers[layer].SetValue(Vector2int.FromVector2(mousePos), (byte)(id + 1));
     resources.Add(tileInstance);
 }
        public RemoveSpriteCommand(SpriteLayer spriteLayer, Coordinate coordinate)
        {
            spriteLayer.ThrowIfNull("spriteLayer");

            _spriteLayer = spriteLayer;
            _coordinate = coordinate;
        }
Exemple #6
0
        public override void Show()
        {
            var spriteLayer = new SpriteLayer(GraphicsDevice, Game.Camera);

            ClearColor = Color.Black;

            var sprite = AssetManager
                         .Load <Texture>("astrid-logo.png")
                         .ToSprite();

            sprite.Color    = new Color(Color.White, 0.0f);
            sprite.Position = new Vector2(400, 240);
            spriteLayer.Sprites.Add(sprite);
            Layers.Add(spriteLayer);

            Animations
            .CreateSequence(sprite)
            .FadeIn(new TransitionParameters(0.5f, EasingFunctions.CubicEaseInOut))
            .Delay(1.0f)
            .FadeOut(new TransitionParameters(0.5f, EasingFunctions.CubicEaseInOut))
            .Execute(() => SetScreen(new TitleScreenDemo(_game)))
            .Play();

            base.Show();
        }
        /// <summary>
        /// LoadContent will be called once per game and is the place to load
        /// all of your content.
        /// </summary>
        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);

            //testImage = Content.Load<Texture2D>("Stupid");

            testScene = new Scene(GraphicsDevice, spriteBatch);
            layer1    = new SpriteLayer();
            layer2    = new SpriteLayer();

            tileSet  = Content.Load <Texture2D>("Tiles_64x64");
            testMap  = new TileMap("TileMaps/Map.tmx", "TileSets/Tiles.tsx", 1);
            testMap1 = new TileMap("TileMaps/Map.tmx", "TileSets/Tiles.tsx", 2);

            testMap1.Parent  = layer2;
            testMap.Parent   = layer1;
            testMap.TileSet  = tileSet;
            testMap1.TileSet = tileSet;
            testMap.Scale    = new Vector2(0.5f, 0.5f);
            testMap1.Scale   = new Vector2(0.5f, 0.5f);

            testScene.Layers.AddLast(layer1);
            testScene.Layers.AddLast(layer2);
        }
Exemple #8
0
    public void OnGUI()
    {
        activated = EditorGUILayout.Toggle("Activate", activated);
        dic       = (SpriteDictionary)EditorGUILayout.ObjectField("Sprite Dictionary", dic, typeof(SpriteDictionary), false);

        if (dic == null)
        {
            SpriteDictionary[] dicArr = Resources.FindObjectsOfTypeAll <SpriteDictionary>();
            if (dicArr != null && dicArr.Length > 0)
            {
                dic = dicArr[0];
            }
        }


        type              = (SpriteType)EditorGUILayout.EnumPopup("Type", type);
        spriteLayer       = (SpriteLayer)EditorGUILayout.EnumPopup("Layer", spriteLayer);
        color             = EditorGUILayout.ColorField(color);
        baseScale         = EditorGUILayout.FloatField("Base Scale", baseScale);
        scaleDiffrence    = EditorGUILayout.Slider("Scale Diffrence", scaleDiffrence, 0, 1);
        seperateScaleAxis = EditorGUILayout.Toggle("Seperate Scale Axis", seperateScaleAxis);
        rotation          = EditorGUILayout.Slider("Rotation", rotation, 0, 360);
        flipRandomX       = EditorGUILayout.Toggle("Flip Random X", flipRandomX);

        EditorGUILayout.MinMaxSlider("Distance", ref zMin, ref zMax, 0, 4);
        if (zMax > 0)
        {
            spriteLayer = SpriteLayer.PERSPECTIVE_BACKGROUND;
        }
    }
Exemple #9
0
 void DrawString(SpriteLayer layer, int x, int y, string text, Color color)
 {
                 #if USE_PROFONT
     consoleFont.DrawString(layer, text, x, y + consoleFont.BaseLine, color);
                 #else
     layer.DrawDebugString(x, y, text, color);
                 #endif
 }
        public SetSpriteCommand(SpriteLayer spriteLayer, Sprite sprite)
        {
            spriteLayer.ThrowIfNull("spriteLayer");
            sprite.ThrowIfNull("sprite");

            _spriteLayer = spriteLayer;
            _sprite = sprite;
        }
Exemple #11
0
 public bool LayersPaused(SpriteLayer layer)
 {
     if (layer.Paused)
     {
         return(true);
     }
     return(false);
 }
Exemple #12
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="rs"></param>
        /// <param name="editor"></param>
        public EditorHud(MapEditor editor)
        {
            this.rs     = editor.Game.RenderSystem;
            this.game   = editor.Game;
            this.editor = editor;

            spriteLayer = new SpriteLayer(rs, 2048);
            rs.SpriteLayers.Add(spriteLayer);
        }
 public void NewLayer(int x, int y, int size)
 {
     SpriteLayer newLayer = new SpriteLayer();
     newLayer.source = baseSheet;
     newLayer.x = x;
     newLayer.y = y;
     newLayer.size = size;
     layers.Add(newLayer);
 }
 public GameObject GetInstance(int id, SpriteLayer layer, Vector2 position)
 {
     var tileInstance = Instantiate(prefab);
     tileInstance.transform.parent = tileParent;
     tileInstance.GetComponent<SpriteRenderer>().sprite = GetSprite(id, layer);
     tileInstance.GetComponent<SpriteRenderer>().sortingLayerName = layer.ToString();
     tileInstance.transform.position = position;
     return tileInstance;
 }
Exemple #15
0
 public TileMap2D(SpriteLayer ly, string ln, bool autoSave = true)
     : this(autoSave)
 {
     levelname = ln;
     layer = ly;
     if (AutoSave) {
         maps = MapLoader2D.LoadAll(layer, levelname);
     }
 }
 public SpriteSheet(string displayName, string fileName, Stream stream, Gender gender, Race race, SpriteLayer layer)
 {
     DisplayName = displayName;
     Gender      = gender;
     SpriteLayer = layer;
     SpriteData  = ReadStream(stream);
     Race        = race;
     FullName    = fileName;
     Tags        = fileName.Split(new[] { '\\', '-', '_', '.', ' ' }, System.StringSplitOptions.RemoveEmptyEntries);
 }
Exemple #17
0
    public static string TileDirectoryPath(SpriteLayer layer, string levelname)
    {
        string path = LevelsDirectoryPath + levelname + "/" + layer + "/";

        if (!Directory.Exists(path)) {
            Directory.CreateDirectory(path);
        }

        return path;
    }
        public XElement Serialize(SpriteLayer spriteLayer, string elementName = "spriteLayer")
        {
            spriteLayer.ThrowIfNull("spriteLayer");
            elementName.ThrowIfNull("elementName");

            return new XElement(
                elementName,
                spriteLayer.Sprites.Select(arg => SpriteSerializer.Instance.Serialize(arg)),
                new XAttribute("boardId", spriteLayer.BoardId),
                new XAttribute("size", SizeSerializer.Instance.Serialize(spriteLayer.Size)));
        }
        private List <ISpriteSheet> GetBodyPartSprite(SpriteLayer layer, Gender gender, Race race, string tone)
        {
            var sprites = GetSprites(layer, race, gender).ToList();

            if (!string.IsNullOrEmpty(tone))
            {
                sprites = sprites.Where(s => s.Tags.Contains(tone)).ToList();
            }

            return(sprites);
        }
Exemple #20
0
 public SpriteLayer GetLayer(string mat, Color color )
 {
     foreach(SpriteLayer layer in LayerCache)
     {
         if (layer.Equals(mat, color))
             return layer;
     }
     SpriteLayer l = new SpriteLayer(mat, color);
     LayerCache.Add(l);
     return l;
 }
Exemple #21
0
        /// <summary>
        /// Draws entire interface
        /// </summary>
        /// <param name="gameTime"></param>
        void Draw(GameTime gameTime, SpriteLayer spriteLayer)
        {
            if (SkipUserInterface)
            {
                return;
            }

            spriteLayer.Clear();

            Frame.DrawNonRecursive(RootFrame, gameTime, spriteLayer);
        }
        private void AddClothesLayer(ICharacterSpriteDefinition character, SpriteLayer layer)
        {
            var sprites = GetSprites(layer, Race.Any, character.Gender).ToList();

            sprites = sprites.Where(s => !s.Tags.Contains("chain") && !s.Tags.Contains("leather") && !s.Tags.Contains("plate") &&
                                    !s.Tags.Contains("overskirt") && !s.Tags.Contains("overskirtDark")).ToList();

            if (sprites.Count > 0)
            {
                character.AddLayer(sprites[RandomHelper.Random.Next(0, sprites.Count)]);
            }
        }
Exemple #23
0
 public static byte[] Load(Vector2int mapLocation, SpriteLayer layer, string levelname)
 {
     if (File.Exists(TileDirectoryPath(layer, levelname) + mapLocation)) {
         string s;
         using (var reader = new StreamReader(TileDirectoryPath(layer, levelname) + mapLocation)) {
             s = reader.ReadLine();
         }
         return s.ConvertHexToByteArray();
     }
     else {
         return null;
     }
 }
Exemple #24
0
        /// <summary>
        /// Inits view
        /// </summary>
        public override void Initialize()
        {
            spriteLayer = new SpriteLayer(Game.RenderSystem, 1024);

            //	create root frame :
            var vp = Game.RenderSystem.DisplayBounds;

            RootFrame = new Frame(this, 0, 0, vp.Width, vp.Height, null, null, Color.Zero);
            Game.RenderSystem.DisplayBoundsChanged += RenderSystem_DisplayBoundsChanged;

            mouseProcessor.Initialize();
            touchProcessor.Initialize();
        }
Exemple #25
0
 //this constructer is used for sprites with a single frame
 public Sprite(Texture2D sprite, GameObject attached, Colour tint, float sortValue = 1, SpriteLayer layer = 0)
 {
     frames = new Texture2D[1] {
         sprite
     };
     textureRectangle = new Rectangle {
         height = sprite.height, width = sprite.width
     };
     attachedGameObject = attached;
     sort       = sortValue;
     this.layer = layer;
     this.tint  = tint;
 }
Exemple #26
0
        /// <summary>
        ///
        /// </summary>
        public override void Initialize()
        {
            testLayer = new SpriteLayer(GameEngine.GraphicsEngine, 1024);
            texture   = GameEngine.Content.Load <DiscTexture>("lena");
            debugFont = GameEngine.Content.Load <DiscTexture>("debugFont");

            testLayer.Clear();
            testLayer.Draw(texture, 10, 10 + 384, 256, 256, Color.White);

            testLayer.DrawDebugString(debugFont, 10, 276, "Lenna Soderberg", Color.White);

            GameEngine.GraphicsEngine.SpriteLayers.Add(testLayer);
        }
        public IEnumerable <ISpriteSheet> GetSprites(SpriteLayer layer, Race race, Gender gender)
        {
            var sprites = SpriteLibrary.Where(s => s.SpriteLayer == layer && (s.Gender == gender || s.Gender == Gender.Either));

            if (layer == SpriteLayer.Body)
            {
                return(sprites.Where(s => s.Race == race));
            }
            else
            {
                return(sprites.Where(s => s.Race == race || s.Race == Race.Any));
            }
        }
Exemple #28
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="gameTime"></param>
        /// <param name="sb"></param>
        static internal void DrawNonRecursive(Frame rootFrame, GameTime gameTime, SpriteLayer spriteLayer)
        {
            if (rootFrame == null)
            {
                return;
            }

            var stack = new Stack <DrawFrameItem>();
            var list  = new List <DrawFrameItem>();

            stack.Push(new DrawFrameItem(rootFrame, Color.White, rootFrame.GlobalRectangle, rootFrame.GetBorderedRectangle(), rootFrame.Text));


            while (stack.Any())
            {
                var currentDrawFrame = stack.Pop();

                if (!currentDrawFrame.Frame.IsDrawable)
                {
                    continue;
                }

                list.Add(currentDrawFrame);

                foreach (var child in currentDrawFrame.Frame.Children.Reverse())
                {
                    var color = currentDrawFrame.Color * child.OverallColor;
                    var inner = Clip(child.GetBorderedRectangle(), currentDrawFrame.InnerClip);
                    var outer = Clip(child.GlobalRectangle, currentDrawFrame.InnerClip);

                    if (MathUtil.IsRectInsideRect(child.GlobalRectangle, currentDrawFrame.InnerClip))
                    {
                        stack.Push(new DrawFrameItem(child, color, outer, inner, currentDrawFrame.Text + "-" + child.Text));
                    }
                }
            }



            for (int i = 0; i < list.Count; i++)
            {
                var drawFrame = list[i];

                spriteLayer.SetClipRectangle(i * 2 + 0, drawFrame.OuterClip, drawFrame.Color);
                spriteLayer.SetClipRectangle(i * 2 + 1, drawFrame.InnerClip, drawFrame.Color);

                drawFrame.Frame.DrawFrameBorders(spriteLayer, i * 2 + 0);
                drawFrame.Frame.DrawFrame(gameTime, spriteLayer, i * 2 + 1);
            }
        }
Exemple #29
0
    public SpriteLayer GetLayer(string mat, Color color)
    {
        foreach (SpriteLayer layer in LayerCache)
        {
            if (layer.Equals(mat, color))
            {
                return(layer);
            }
        }
        SpriteLayer l = new SpriteLayer(mat, color);

        LayerCache.Add(l);
        return(l);
    }
        private void AddArmorLayer(ICharacterSpriteDefinition character, SpriteLayer layer, ArmorType armorType)
        {
            var sprites = GetSprites(layer, Race.Any, character.Gender).ToList();

            if (layer != SpriteLayer.Greaves && layer != SpriteLayer.Shoulders)
            {
                sprites = sprites.Where(s => s.Tags.Contains(armorType.ToString(), StringComparer.OrdinalIgnoreCase)).ToList();
            }

            if (sprites.Count > 0)
            {
                character.AddLayer(sprites[RandomHelper.Random.Next(0, sprites.Count)]);
            }
        }
Exemple #31
0
    public static Dictionary<Vector2int, byte[]> LoadAll(SpriteLayer l, string levelname)
    {
        //create dictionary for layer l
        var dict = new Dictionary<Vector2int, byte[]>();

        //load each tile in layer l and place in dictionary
        foreach (var file in Directory.GetFiles(TileDirectoryPath(l, levelname))) {
            var name = Path.GetFileName(file);
            var stringSplit = name.Replace("(", "").Replace(")", "").Split(',');
            var vec = new Vector2int(int.Parse(stringSplit[0]), int.Parse(stringSplit[1]));
            dict[vec] = Load(vec, l, levelname);
        }
        return dict;
    }
Exemple #32
0
        int backwardsMultiplier = 1; //changed to -1 when the sprite animated backwards

        //this constructor is used for sprites with multiple frames
        public Sprite(Texture2D[] frames, float millisecondsEach, int startFrame, int lastFrame, GameObject attached, Colour tint, bool animated = true, float sortValue = 1, SpriteLayer layer = SpriteLayer.Midground)
        {
            this.isAnimated  = animated;
            timeCap          = millisecondsEach;
            this.frames      = frames;
            textureRectangle = new Rectangle {
                height = frames[0].height, width = frames[0].width
            };
            attachedGameObject = attached;
            this.startFrame    = startFrame;
            this.lastFrame     = lastFrame;
            sort       = sortValue;
            this.layer = layer;
            this.tint  = tint;
        }
 public Sprite[] GetAllSprites(SpriteLayer layer)
 {
     //if (layer == 0) {
     //    sprites = pathSprites.Values.Select(e => e.Sprite).ToArray();
     //} else if (layer == 1) {
     //    sprites = buildingSprites;
     //} else if (layer == 2) {
     //    sprites = doorSprites;
     //} else {
     //    sprites = envirSprites;
     //}
     return (from s in GetSpriteDataForLayer(layer)
             orderby s.Value.Index
             select s.Value.Sprite).ToArray();
 }
		public TextGisLayer(Game game, int capacity, GlobeCamera camera) : base(game)
		{
			GlobeCamera		= camera;
			TextSpriteLayer = new SpriteLayer(Game.RenderSystem, 2048);

			GeoTextArray		= new GeoText[capacity];
			LinesCountToDraw	= capacity;
			Font				= Game.Content.Load<DiscTexture>("conchars");
			//spriteFont		= Game.Content.Load<SpriteFont>(@"Fonts\textFont");

			MinZoom = 6380;
			MaxZoom = 6500;

			Scale		= 1.0f;
			MaxScale	= 1.5f;
		}
Exemple #35
0
        public void AddSprite(Sprite s, Int32 x, Int32 y, float t, bool additive)
        {
            // shift into object space
              const Int32 MidPoint = (Constants.RoomSize * Constants.TileSize) / 2;
              x = (-MidPoint + (Constants.TileSize / 2)) + x;
              y = (MidPoint - (Constants.TileSize / 2)) - (y - Constants.TileSize);

              SpriteLayer sl = new SpriteLayer();
              sl.uid = s.getUID();
              sl.x = (byte)x;
              sl.y = (byte)y;
              sl.trans = (byte)(t * 255.0f);
              sl.glow = (byte)(additive ? 1 : 0);

              layers.Add(sl);
        }
        private List <ISpriteSheet> GetSprites(string path, SpriteLayer layer, SearchOption option = SearchOption.AllDirectories, string filterRegex = ".*")
        {
            var sheets = new List <ISpriteSheet>();

            var files = ResourceManager.GetSprites(path, option);

            foreach (var file in files)
            {
                var name = Path.GetFileNameWithoutExtension(file);

                if (FilterValid(name, filterRegex))
                {
                    sheets.Add(new SpriteSheet(name, file, ResourceManager.GetImageStream(file), GetGender(file), GetRace(file), layer));
                }
            }

            return(sheets);
        }
Exemple #37
0
        private void DockingManager_Loaded(object sender, RoutedEventArgs e)
        {
            List <LayoutAnchorable> docks = new List <LayoutAnchorable>();

            docks.Add(Background);
            docks.Add(Breakpoints);
            docks.Add(CPU);
            //docks.Add(DisplayTiming);
            docks.Add(Interrupts);
            docks.Add(InstructionHistogram);
            docks.Add(IORegisters);
            docks.Add(Memory);
            docks.Add(MemoryImage);
            //docks.Add(SoundChannelInternals);
            //docks.Add(Spectogram);
            docks.Add(SpriteLayer);
            //docks.Add(Sprites);
            docks.Add(SoundRecording);
            docks.Add(TileMap);
            docks.Add(Window);

            foreach (LayoutAnchorable dock in docks)
            {
                dock.AutoHideWidth = 500;
                dock.FloatingWidth = 500;
            }

            Background.ToggleAutoHide();
            Breakpoints.ToggleAutoHide();
            CPU.ToggleAutoHide();
            //DisplayTiming.ToggleAutoHide();
            Interrupts.ToggleAutoHide();
            InstructionHistogram.ToggleAutoHide();
            IORegisters.ToggleAutoHide();
            Memory.ToggleAutoHide();
            MemoryImage.ToggleAutoHide();
            //SoundChannelInternals.ToggleAutoHide();
            //Spectogram.ToggleAutoHide();
            SpriteLayer.ToggleAutoHide();
            //Sprites.ToggleAutoHide();
            SoundRecording.ToggleAutoHide();
            TileMap.ToggleAutoHide();
            Window.ToggleAutoHide();
        }
Exemple #38
0
        public Board(
			Guid id,
			string name,
			string description,
			Size size,
			SpriteLayer backgroundLayer,
			SpriteLayer foregroundLayer,
			ActorInstanceLayer actorInstanceLayer,
			IEnumerable<BoardExit> exits,
			IEnumerable<Timer> timers,
			EventHandlerCollection eventHandlerCollection = null)
        {
            name.ThrowIfNull("name");
            description.ThrowIfNull("description");
            backgroundLayer.ThrowIfNull("backgroundLayer");
            foregroundLayer.ThrowIfNull("foregroundLayer");
            actorInstanceLayer.ThrowIfNull("actorInstanceLayer");
            exits.ThrowIfNull("exits");
            timers.ThrowIfNull("timers");

            if (backgroundLayer.BoardId != id)
            {
                throw new ArgumentException("Background layer must belong to board.", "backgroundLayer");
            }
            if (foregroundLayer.BoardId != id)
            {
                throw new ArgumentException("Foreground layer must belong to board.", "backgroundLayer");
            }
            if (actorInstanceLayer.BoardId != id)
            {
                throw new ArgumentException("Actor instance layer must belong to board.", "backgroundLayer");
            }

            _id = id;
            Name = name;
            Description = description;
            _size = size;
            _backgroundLayer = backgroundLayer;
            _foregroundLayer = foregroundLayer;
            _actorInstanceLayer = actorInstanceLayer;
            _exits = exits;
            _timers = timers;
            _eventHandlerCollection = eventHandlerCollection;
        }
Exemple #39
0
        /// <summary>
        ///
        /// </summary>
        public override void Initialize()
        {
            editBox.FeedHistory(GetHistory());

            consoleLayer       = new SpriteLayer(Game.RenderSystem, 1024);
            editLayer          = new SpriteLayer(Game.RenderSystem, 1024);
            consoleLayer.Order = 9999;
            consoleLayer.Layers.Add(editLayer);

            LoadContent();
            Game.Reloading += (s, e) => LoadContent();

            Game.GraphicsDevice.DisplayBoundsChanged += GraphicsDevice_DisplayBoundsChanged;
            LogRecorder.TraceRecorded  += TraceRecorder_TraceRecorded;
            Game.Keyboard.KeyDown      += Keyboard_KeyDown;
            Game.Keyboard.FormKeyPress += Keyboard_FormKeyPress;
            Game.Keyboard.FormKeyDown  += Keyboard_FormKeyDown;

            RefreshConsole();
            RefreshEdit();
        }
        public byte[] Serialize(SpriteLayer spriteLayer)
        {
            spriteLayer.ThrowIfNull("spriteLayer");

            var serializer = new CompactSerializer();

            serializer[0] = spriteLayer.BoardId.ToByteArray();
            serializer[1] = SizeSerializer.Instance.Seralize(spriteLayer.Size);

            var spriteSerializer = new CompactSerializer();
            int index = 0;

            foreach (Sprite sprite in spriteLayer.Sprites)
            {
                spriteSerializer[index++] = SpriteSerializer.Instance.Serialize(sprite);
            }

            serializer[2] = spriteSerializer.Serialize();

            return serializer.Serialize();
        }
Exemple #41
0
        /// <summary>
        /// Draws frame stuff
        /// </summary>
        void DrawFrameBorders(SpriteLayer spriteLayer, int clipRectIndex)
        {
            int gx = GlobalRectangle.X;
            int gy = GlobalRectangle.Y;
            int w  = Width;
            int h  = Height;
            int bt = BorderTop;
            int bb = BorderBottom;
            int br = BorderRight;
            int bl = BorderLeft;

            var whiteTex = Game.RenderSystem.WhiteTexture;

            var clr = BorderColor;

            spriteLayer.Draw(whiteTex, gx, gy, w, bt, clr, clipRectIndex);
            spriteLayer.Draw(whiteTex, gx, gy + h - bb, w, bb, clr, clipRectIndex);
            spriteLayer.Draw(whiteTex, gx, gy + bt, bl, h - bt - bb, clr, clipRectIndex);
            spriteLayer.Draw(whiteTex, gx + w - br, gy + bt, br, h - bt - bb, clr, clipRectIndex);

            spriteLayer.Draw(whiteTex, GetBorderedRectangle(), BackColor, clipRectIndex);
        }
Exemple #42
0
        /// <summary>
        ///
        /// </summary>
        protected virtual void DrawFrameImage(SpriteLayer spriteLayer, int clipRectIndex)
        {
            if (Image == null)
            {
                return;
            }

            var gp = GetPaddedRectangle();
            var bp = GetBorderedRectangle();

            if (ImageMode == FrameImageMode.Stretched)
            {
                spriteLayer.Draw(Image, bp, ImageColor, clipRectIndex);
                return;
            }

            if (ImageMode == FrameImageMode.Centered)
            {
                int x = bp.X + gp.Width / 2 - Image.Width / 2 + ImageOffsetX;
                int y = bp.Y + gp.Height / 2 - Image.Height / 2 + ImageOffsetY;
                spriteLayer.Draw(Image, x, y, Image.Width, Image.Height, ImageColor, clipRectIndex);
                return;
            }

            if (ImageMode == FrameImageMode.Tiled)
            {
                spriteLayer.Draw(Image, bp, new Rectangle(0, 0, bp.Width, bp.Height), ImageColor, clipRectIndex);
                return;
            }

            if (ImageMode == FrameImageMode.DirectMapped)
            {
                spriteLayer.Draw(Image, bp, bp, ImageColor, clipRectIndex);
                return;
            }
        }
Exemple #43
0
 public static RemoveSpriteCommand RemoveSprite(SpriteLayer spriteLayer, Coordinate coordinate)
 {
     return new RemoveSpriteCommand(spriteLayer, coordinate);
 }
Exemple #44
0
 public static void Save(Vector2int mapLocation, byte[] bytes, SpriteLayer layer, string levelname)
 {
     using (var writer = new StreamWriter(TileDirectoryPath(layer, levelname) + mapLocation.ToString())) {
         writer.WriteLine(bytes.ConvertToHexString());
     }
 }
 public int GetIDForName(string name, SpriteLayer layer)
 {
     return (from s in sprites[layer]
             where s.Value.Sprite.name == name
             select s.Key).FirstOrDefault();
 }
Exemple #46
0
    //place tile onscreen
    void tileCreateDestroy()
    {
        var mousePos = Input.mousePosition;
        mousePos = Camera.main.ScreenToWorldPoint(mousePos);
        mousePos.z = 0;
        mousePos.x = Mathf.RoundToInt(mousePos.x);
        mousePos.y = Mathf.RoundToInt(mousePos.y);

        var tListLength = TileSpriteManager.Instance.GetListLength(layer);

        if (Input.GetMouseButtonDown(0) && !UIUtil.MouseOverUI()) {
            Tile2DSceneResourceManager.Instance.createTileAtMousePos(mousePos, layer, type);
        }

        if (Input.GetMouseButtonDown(1) && !UIUtil.MouseOverUI()) {
            Tile2DSceneResourceManager.Instance.removeTileAtMousePos(mousePos, layer);
        }

        if (Input.GetKeyDown(KeyCode.Tab)) {
            Index = (Index + 1) % tListLength;
        }

        if (Input.GetKeyDown(KeyCode.Q)) {
            Index = (Index - 1) % tListLength;
        }

        if (Input.GetKeyDown(KeyCode.LeftControl)) {
            layer = (SpriteLayer)(((int)layer + 1) % 4);
            Index = 0;
        }
    }
 //public GameObject GetInstance(int type, SpriteLayer layer, Vector2 position) {
 //    var tileInstance = Instantiate(prefab);
 //    tileInstance.transform.parent = tileParent;
 //    tileInstance.GetComponent<SpriteRenderer>().sprite = GetSprite(type, (int)layer);
 //    tileInstance.GetComponent<SpriteRenderer>().sortingLayerName = layer.ToString();
 //    tileInstance.transform.position = position;
 //    //add box collider if tile is in Environment layer so that player cannot walk over this tile
 //    //if (layer == SpriteLayer.Building || layer == SpriteLayer.Door || layer == SpriteLayer.Environment) {
 //    //    tileInstance.AddComponent<BoxCollider2D>();
 //    //}
 //    return tileInstance;
 //}
 public string GetNameForIndex(int index, SpriteLayer layer)
 {
     return (from s in sprites[layer]
             where s.Value.Index == index
             select s.Value.Sprite.name).FirstOrDefault();
 }
 public void removeTileAtMousePos(Vector3 mousePos, SpriteLayer layer)
 {
     currentLevel.layers[layer].SetValue(Vector2int.FromVector2(mousePos), 0);
     LoadLevel(currentLevel);
 }
 Dictionary<int, SpriteData> GetSpriteDataForLayer(SpriteLayer layer)
 {
     if (!sprites.ContainsKey(layer)) {
         throw new Exception("Sprite layer is not for tiles");
     } else {
         return sprites[layer];
     }
 }
 public int GetListLength(SpriteLayer layer)
 {
     //if (layer == 0) {
     //    return pathSprites.Count;
     //} else if (layer == 1) {
     //    return buildingSprites.Length;
     //} else if (layer == 2) {
     //    return doorSprites.Length;
     //} else {
     //    return envirSprites.Length;
     //}
     return GetSpriteDataForLayer(layer).Count;
 }
 public Sprite GetSprite(int id, SpriteLayer layer)
 {
     Sprite sprite;
     Sprite[] sprites = GetAllSprites(layer);
     if (id >= 0 && id < sprites.Length) {
         sprite = sprites[id];
     } else {
         Debug.Log("index out of range");
         id = 0;
         sprite = sprites[id];
     }
     return sprite;
 }
Exemple #52
0
 //scale is a float because It is best for x and y scaling to be of equal magnitude otherwise it can lead to some bugs, so i just decided to make it always start with a scale with equal magnitude
 public GameObject(TextureName image, Vector2 position, float scale, float rotation = 0, GameObject parent = null, bool isDrawn = true, SpriteLayer layer = SpriteLayer.Midground)
 {
     Init(image, position, scale, rotation, parent, isDrawn, layer);
 }
Exemple #53
0
        void BugTextRJ(SpriteLayer layer, string text, int x, int y, Color color)
        {
            var r = hudFont.MeasureStringF(text, -4);

            hudFont.DrawString(layer, text, x - r.Width, y, color, -4);
        }
Exemple #54
0
        void BigTextLJ(SpriteLayer layer, string text, int x, int y, Color color)
        {
            var r = hudFont.MeasureStringF(text, -4);

            hudFont.DrawString(layer, text, x, y, color, 0, -4, true, false);
        }
Exemple #55
0
        void MicroTextRJ(SpriteLayer layer, string text, int x, int y, Color color)
        {
            var r = hudFontMicro.MeasureStringF(text, -1);

            hudFontMicro.DrawString(layer, text, x - r.Width, y, color, 0, -1);
        }
Exemple #56
0
        //all constructors are just using this (so I don't have to rewrite the same thing a billion times)
        protected void Init(TextureName image, Vector2 position, float scale, float rotation, GameObject parent, bool isDrawn = true, SpriteLayer layer = SpriteLayer.Midground)
        {
            this.isDrawn = isDrawn;

            id = idCounter;
            idCounter++;
            spriteManager = new Sprite(Game.GetTextureFromName(image), this, RLColor.WHITE, 1, layer);

            if (parent != null)
            {
                parent.AddChild(this);
            }

            //position and scale will be zero if no values are given
            localTransform = Matrix3.GetTranslation(position) * Matrix3.GetRotateZ(rotation) * Matrix3.GetScale(Vector2.one * scale);
            this.position  = position;
            this.rotation  = rotation;
            this.scale     = Vector2.one * scale;
            sortingOffset  = spriteManager.CurrentTexture().height / 2 * scale;
            UpdateTransforms();
        }
Exemple #57
0
        // SiDComponent
        public override void LoadFromByteStream(BinaryReader br, Int32 streamLength)
        {
            // check magic bytes
              byte[] magic = br.ReadBytes(Constants.SID_MAGIC_CODE.Length);
              String magicString = ASCIIEncoding.UTF8.GetString(magic, 0, Constants.SID_MAGIC_CODE.Length);
              if (magicString != Constants.SID_MAGIC_CODE)
              {
            throw new InvalidDataException("loading StateObject - data did not start with SID_MAGIC_CODE");
              }

              // validate version
              Int32 objectVersion = (Int32)br.ReadByte();

              // we support loading V2 assets
              if (objectVersion == 2)
              {
            upgradedFromV2 = true;
              }
              else
              {
            if (objectVersion != StateObjectVersionNumber)
            {
              throw new InvalidDataException(String.Format("loading StateObject - version mismatch (got {0}, expected {1})", objectVersion, StateObjectVersionNumber));
            }
              }

              Int32 numLayers = (Int32)br.ReadByte();
              for (Int32 i = 0; i < numLayers; i++)
              {
            SpriteLayer layer = new SpriteLayer();

            byte[] uidbytes = br.ReadBytes(6);
            layer.uid = new UID(uidbytes);

            layer.x = br.ReadByte();
            layer.y = br.ReadByte();
            layer.trans = br.ReadByte();

            // handle V3 glow byte
            if (!upgradedFromV2)
            {
              layer.glow = br.ReadByte();
            }
            else
            {
              layer.glow = 0;
            }

            layers.Add(layer);
              }

              Name = ByteUtils.readNullTermString11(br);
        }
    Texture2D GetTexture(int type, SpriteLayer layer)
    {
        return GetSpriteDataForLayer(layer)[type].Sprite.texture;

        //if (layer == SpriteLayer.Path) {
        //    return pathSprites[type].Sprite.texture;
        //} else if (layer == SpriteLayer.Building) {
        //    return buildingSprites[type].texture;
        //} else if (layer == SpriteLayer.Door) {
        //    return doorSprites[type].texture;
        //} else {
        //    return envirSprites[type].texture;
        //}
    }
Exemple #59
0
 public static SetSpriteCommand SetSprite(SpriteLayer spriteLayer, Sprite sprite)
 {
     return new SetSpriteCommand(spriteLayer, sprite);
 }