Exemple #1
0
        protected override void Draw(ref PlayerDrawSet drawInfo)
        {
            Player drawPlayer = drawInfo.drawPlayer;

            if (!WingsLayerData.TryGetValue(drawPlayer.wings, out DrawLayerData data))
            {
                return;
            }

            Color color = drawPlayer.GetImmuneAlphaPure(data.Color(drawInfo) * drawInfo.stealth * (1f - drawInfo.shadow), drawInfo.shadow);             //Wing glowmasks need the additional stealth/shadow multiplier for some reason

            Texture2D texture = data.Texture.Value;

            Vector2 directions = drawPlayer.Directions;
            Vector2 offset     = new Vector2(0f, 7f);
            Vector2 position   = drawInfo.Position - Main.screenPosition + new Vector2(drawPlayer.width / 2, drawPlayer.height - drawPlayer.bodyFrame.Height / 2) + offset;

            int num11     = 0;
            int num12     = 0;
            int numFrames = 4;

            position += new Vector2(num12 - 9, num11 + 2) * directions;
            position  = position.Floor();
            Rectangle frame    = new Rectangle(0, texture.Height / numFrames * drawPlayer.wingFrame, texture.Width, texture.Height / numFrames);
            DrawData  drawData = new DrawData(texture, position.Floor(), frame, color, drawPlayer.bodyRotation, new Vector2(texture.Width / 2, texture.Height / numFrames / 2), 1f, drawInfo.playerEffect, 0)
            {
                shader = drawInfo.cWings
            };

            drawInfo.DrawDataCache.Add(drawData);
        }
    public static List <Vector3Int> DebugQueryCollider(EDir dir, Vector2 fTargetHead, float size = TANK_BORDER_SIZE)
    {
        var     ret          = new List <Vector3Int>();
        Vector2 borderDir    = GetBorderDir(dir);
        var     fBorder1     = fTargetHead + borderDir * size;
        var     fBorder2     = fTargetHead - borderDir * size;
        var     isColHead    = HasCollider(fTargetHead);
        var     isColBorder1 = HasCollider(fBorder1);
        var     isColBorder2 = HasCollider(fBorder2);

        ret.Add(new Vector3Int(fTargetHead.Floor().x, fTargetHead.Floor().y, isColHead ? 1 : 0));
        ret.Add(new Vector3Int(fBorder1.Floor().x, fBorder1.Floor().y, isColBorder1 ? 1 : 0));
        ret.Add(new Vector3Int(fBorder2.Floor().x, fBorder2.Floor().y, isColBorder2 ? 1 : 0));
        return(ret);
    }
Exemple #3
0
    public static bool HasCollider(Vector2 pos)
    {
        var iPos = pos.Floor();
        var id   = LevelManager.Instance.Pos2TileID(iPos, true);

        return(id != 0);
    }
Exemple #4
0
    // Called when the node enters the scene tree for the first time.
    public override void _Ready()
    {
        // Randomize seed
        RNG.Randomize();
        // Set the starting tile to middle of bounds
        Vector2 startTile = new Vector2((MinTileBound + MaxTileBound) / 2);

        startTile = startTile.Floor();
        // Create random walkers
        RandomWalker randomWalker = new RandomWalker(startTile, this);
        // Run simulation
        int numSteps = 0;

        while (this.GetUsedCells().Count < MaxCells && numSteps < MaxSteps)
        {
            randomWalker.Step();
            numSteps++;
        }
        // Fill in unused areas with walls
        Vector2 padTiles  = (Godot.OS.WindowSize / this.CellSize).Ceil();
        Rect2   floorRect = this.GetUsedRect();

        for (float i = floorRect.Position[0] - padTiles[0]; i < floorRect.End[0] + padTiles[0]; i++)
        {
            for (float j = floorRect.Position[1] - padTiles[1]; j < floorRect.End[1] + padTiles[1]; j++)
            {
                Vector2 curPos = new Vector2(i, j);
                if (this.GetCellv(curPos) == InvalidCell)
                {
                    this.SetCellv(curPos, 1);
                }
            }
        }
    }
Exemple #5
0
        public static void RenderPlayer(On.Celeste.Player.orig_Render orig, Player self)
        {
            Vector2 renderPos = self.Sprite.RenderPosition;

            if (Settings.SkateboardEnabled)
            {
                self.Sprite.RenderPosition += SkateboardPlayerOffset;
            }
            if (Settings.DuckToDabEnabled && self.Ducking)
            {
                self.Sprite.RenderPosition += DabPlayerOffset;
            }

            orig(self);

            if (Settings.SkateboardEnabled)
            {
                Skateboard.Draw(
                    renderPos.Floor() + new Vector2(self.Facing == Facings.Left ? 9 : -8, -4),
                    Vector2.Zero, Color.White,
                    new Vector2(self.Facing == Facings.Left ? -1 : 1, 1)
                    );
            }

            if (Settings.SkateboardEnabled)
            {
                self.Sprite.RenderPosition -= SkateboardPlayerOffset;
            }
            if (Settings.DuckToDabEnabled && self.Ducking)
            {
                self.Sprite.RenderPosition -= DabPlayerOffset;
            }
        }
 public void DrawPlayerName_WhenPlayerIsOnScreen(SpriteBatch spriteBatch)
 {
     _pos = _pos.Floor();
     DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.get_Value(), _name, new Vector2(_pos.X - 2f, _pos.Y), Color.Black, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
     DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.get_Value(), _name, new Vector2(_pos.X + 2f, _pos.Y), Color.Black, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
     DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.get_Value(), _name, new Vector2(_pos.X, _pos.Y - 2f), Color.Black, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
     DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.get_Value(), _name, new Vector2(_pos.X, _pos.Y + 2f), Color.Black, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
     DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.get_Value(), _name, _pos, _color, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
 }
Exemple #7
0
        private Vector2 GetPaletteOnCursor()
        {
            Vector2 mousePos   = Mouse.GetState().Position.ToVector2();
            Vector2 palettePos = new Vector2(paletteViewport.X, paletteViewport.Y);
            Vector2 tilePos    = (mousePos - palettePos + new Vector2(0, 0)) / Tile.SIZE;

            tilePos.Floor();
            return(tilePos);
        }
Exemple #8
0
        private Vector2 GetTileOnCursor()
        {
            Vector2 translation = new Vector2(camera.Transform.Translation.X, camera.Transform.Translation.Y);
            Vector2 mousePos    = Mouse.GetState().Position.ToVector2();
            Vector2 tilePos     = (mousePos - translation) / (Tile.SIZE * Game1.Scale);

            tilePos.Floor();
            return(tilePos);
        }
Exemple #9
0
        public void Process(RenderContext context, EcsContext ecs)
        {
            ecs.Query((ref Drawable d, ref Transform t) =>
            {
                var spriteBatch  = context.SpriteBatch;
                var pos          = t.ScenePos.Floored();
                var bounds       = d.DrawBounds != Rectangle.Empty ? d.DrawBounds : new Rectangle(Point.Zero, t.Size.ToPoint());
                bounds.Location += pos.ToPoint();

                if (d.ScissorArea.HasValue)
                {
                    var r = d.ScissorArea.Value;
                    r.Offset(pos - Vector2.Floor(_camera));

                    if (r != _currentScissor)
                    {
                        spriteBatch.End();
                        spriteBatch.Begin(transformMatrix: _matrix, samplerState: _samplerState,
                                          rasterizerState: new RasterizerState()
                        {
                            ScissorTestEnable = true
                        });
                        _currentScissor = r;
                    }

                    spriteBatch.GraphicsDevice.ScissorRectangle = new Rectangle(
                        Vector2.Transform(r.Location.ToVector2(), _matrix).ToPoint(),
                        Vector2.Transform(r.Size.ToVector2(), _matrix).ToPoint());
                }
                else if (_currentScissor != null)
                {
                    spriteBatch.End();
                    spriteBatch.Begin(transformMatrix: _matrix, samplerState: _samplerState);
                    _currentScissor = null;
                }

                if (bounds.Intersects(_viewport) || bounds == Rectangle.Empty)
                {
                    var drawContext = new DrawContext()
                    {
                        SpriteBatch = spriteBatch,
                        Position    = pos - _camera.Floored(),
                        Size        = t.Size,
                        Modulate    = d.Modulate != null ? d.Modulate : _disabledModulate
                    };
                    //d.AltPriority = (ulong)Math.Abs(pos.X);
                    d.Draw?.Invoke(spriteBatch, drawContext);
                    //CustomDrawing.DrawRect(bounds.Location.ToVector2() - scene.Camera.Position.Floor(), bounds.Size.ToVector2(), Color.Red * 0.5f);

                    /*if (d.ScissorArea.HasValue)
                     * {
                     *  var s = d.ScissorArea.Value;
                     *  CustomDrawing.DrawRect(s.Location.ToVector2() + pos - scene.Camera.Position.Floor(), s.Size.ToVector2(), Color.Blue * 0.5f);
                     * }*/
                }
            });
        }
 public PlayerOffScreenCache(string name, Vector2 pos, Color color, Vector2 npDistPos, string npDist, Player thePlayer, Vector2 theMeasurement)
 {
     nameToShow           = name;
     namePlatePos         = pos.Floor();
     namePlateColor       = color;
     distanceDrawPosition = npDistPos.Floor();
     distanceString       = npDist;
     player      = thePlayer;
     measurement = theMeasurement;
 }
    public static bool IsOutOfBound(Vector2 fpos, Vector2 min, Vector2 max)
    {
        var pos = fpos.Floor();

        if (pos.x < min.x || pos.x > max.x ||
            pos.y < min.y || pos.y > max.y
            )
        {
            return(true);
        }

        return(false);
    }
    public static bool HasCollider(Vector2 pos)
    {
        var iPos = pos.Floor();
        var id   = LevelManager.Instance.Pos2TileID(iPos, true);

        // 还需要检验炸弹
        if (GameManager.Instance.GetBombFormPos(iPos) != null)
        {
            return(true);
        }

        return(id != 0);
    }
        protected override void Draw(ref PlayerDrawSet drawInfo)
        {
            //Mostly copied from vanilla
            Player drawPlayer = drawInfo.drawPlayer;

            Asset <Texture2D> asset   = wingTexture;
            Texture2D         texture = asset.Value;

            Vector2 directions = drawPlayer.Directions;
            Vector2 offset     = new Vector2(0f, 7f);
            Vector2 position   = drawInfo.Position - Main.screenPosition + new Vector2(drawPlayer.width / 2, drawPlayer.height - drawPlayer.bodyFrame.Height / 2) + offset;

            int           num11         = 0;
            int           num12         = 0;
            ClickerPlayer clickerPlayer = drawPlayer.GetModPlayer <ClickerPlayer>();
            int           numFrames     = ClickerPlayer.EffectHotWingsFrameMax;

            float fade = 1f;

            const int fadeStart = ClickerPlayer.EffectHotWingsTimerFadeStart;
            int       timer     = clickerPlayer.effectHotWingsTimer;

            if (timer < fadeStart)
            {
                fade = (float)timer / fadeStart;
            }

            Color mainColor = Color.Lerp(drawInfo.colorArmorBody, Color.White * fade, 0.4f);

            Color color = /*drawInfo.colorArmorBody*/ drawPlayer.GetImmuneAlpha(mainColor, drawInfo.shadow);

            position += new Vector2(num12 - 9, num11 + 2) * directions;
            position  = position.Floor();
            Rectangle frame = new Rectangle(0, asset.Height() / numFrames * clickerPlayer.effectHotWingsFrame, asset.Width(), asset.Height() / numFrames);
            DrawData  data  = new DrawData(texture, position.Floor(), frame, color, drawPlayer.bodyRotation, new Vector2(asset.Width() / 2, asset.Height() / numFrames / 2), 1f, drawInfo.playerEffect, 0);

            //data.shader = drawInfo.cWings;
            drawInfo.DrawDataCache.Add(data);
        }
        public override void Render()
        {
            Vector2 position = sprite.Position;

            sprite.Position = position.Floor();

            if (sprite.CurrentAnimationID != "pop" && sprite.Visible)
            {
                sprite.DrawOutline(1);
            }
            base.Render();
            sprite.Position = position;
        }
            public void DrawPlayerHead()
            {
                float   num1             = 20f;
                float   num2             = -27f - (float)(((double)this.measurement.X - 85.0) / 2.0);
                Color   headBordersColor = Main.GetPlayerHeadBordersColor(this.player);
                Vector2 vec = new Vector2(this.namePlatePos.X, this.namePlatePos.Y - num1);

                vec.X -= 22f + num2;
                vec.Y += 8f;
                Vector2 position = vec.Floor();

                Main.MapPlayerRenderer.DrawPlayerHead(Main.Camera, this.player, position, 1f, 0.8f, headBordersColor);
            }
Exemple #16
0
 public Anchors(float w, float h)
 {
     Width        = w;
     Height       = h;
     TopLeft      = Vector2.Floor(new Vector2(-w, -h) / 2);
     TopCenter    = Vector2.Floor(new Vector2(0, -h) / 2);
     TopRight     = Vector2.Floor(new Vector2(+w, -h) / 2);
     MidLeft      = Vector2.Floor(new Vector2(-w, 0) / 2);
     MidCenter    = Vector2.Floor(new Vector2(0, 0) / 2);
     MidRight     = Vector2.Floor(new Vector2(+w, 0) / 2);
     BottomLeft   = Vector2.Floor(new Vector2(-w, +h) / 2);
     BottomCenter = Vector2.Floor(new Vector2(0, +h) / 2);
     BottomRight  = Vector2.Floor(new Vector2(+w, +h) / 2);
 }
Exemple #17
0
        public static Vector2 GetFeasibleDropPos(Map map, Vector2 pos)
        {
            var realPos = pos.Floor() + Vector2.One * 0.5F;

            foreach (var dir in Direction.Values)
            {
                var offset = realPos + dir.Offset.ToVector2();
                if (IsFeasibleDropPos(map, offset))
                {
                    return(offset);
                }
            }
            return(Vector2.Zero);
        }
Exemple #18
0
        public void DrawRect(int renderQueue, Material material, Vector2 p0, Vector2 p1, Color color, float depth)
        {
            var points = new Vector2[4];

            points[0] = p0.Floor();
            points[2] = p1.Floor();
            points[1] = new Vector2(points[2].X, points[0].Y);
            points[3] = new Vector2(points[0].X, points[2].Y);

            for (var i = 0; i < points.Length; i++)
            {
                DrawLine(renderQueue, material, points[i], points[(i + 1) % points.Length], color, 1f, depth);
            }
        }
Exemple #19
0
        public void FloorTest()
        {
            const int max = 1000;

            var r = new Random(102);

            for (var i = 0; i < 30; i++)
            {
                var v = new Vector2(r.NextFloat() * max, r.NextFloat() * max);
                var c = v.Floor();
                Assert.AreEqual(Math.Floor(v.X), c.X);
                Assert.AreEqual(Math.Floor(v.Y), c.Y);
            }
        }
        public Room Room(Vector2 coordinates)
        {
            Vector2I v = new Vector2I(Vector2.Floor(coordinates));

            if (v.X < 0 || v.X >= Rooms.Length)
            {
                return(null);
            }
            if (v.Y < 0 || v.Y >= Rooms[0].Length)
            {
                return(null);
            }
            return(Rooms[v.X][v.Y]);
        }
            public void DrawPlayerHead()
            {
                float num  = 20f;
                float num2 = -27f;

                num2 -= (measurement.X - 85f) / 2f;
                Color   playerHeadBordersColor = Main.GetPlayerHeadBordersColor(player);
                Vector2 vector = new Vector2(namePlatePos.X, namePlatePos.Y - num);

                vector.X -= 22f + num2;
                vector.Y += 8f;
                vector    = vector.Floor();
                Main.MapPlayerRenderer.DrawPlayerHead(Main.Camera, player, vector, 1f, 0.8f, playerHeadBordersColor);
            }
        public string AreaName(Vector2 coordinates)
        {
            Vector2I v = new Vector2I(Vector2.Floor(coordinates));

            if (v.X < 0 || v.X >= Rooms.Length)
            {
                return(null);
            }
            if (v.Y < 0 || v.Y >= Rooms[0].Length)
            {
                return(null);
            }
            return(AreaNames[v.X][v.Y]);
        }
Exemple #23
0
        public TopBarMenu(TopBar parent, string label, int menuButtonNum = 1)
            : base(parent.parent, (int)parent.parent.UIFontSmall.MeasureString(label).X + 10, parent.Height - 4,
                   parent.GetNextPos((int)parent.parent.UIFontSmall.MeasureString(label).X + 10), Parameters.Filled, parent.parent.BaseColor, null, 0)
        {
            this.label  = label;
            labelOffset = Pos + (new Vector2(Width, Height) - this.parent.UIFontSmall.MeasureString(label)) / 2;
            labelOffset.Floor();

            MenuVisible   = false;
            menuButtons   = new List <TopBarMenuButton>(menuButtonNum);
            buttonOffset  = Pos + new Vector2(0, Height + 3);
            buttonSpacing = new Vector2(0, MenuButtonHeight);

            ConnectInput();
        }
        /// <summary> generate noise </summary>
        public static float noiseA(Vector2 p)
        {
            Vector2 ip = p.Floor();
            Vector2 u  = p.Fract();

            u = u * u * (new Vector2(3, 3) - 2.0f * u);

            float res =
                ObjectExtensionsNumbersBool.Mix(
                    ObjectExtensionsNumbersBool.Mix(randA(ip), randA(ip + new Vector2(1.0f, 0.0f)), u.X),
                    ObjectExtensionsNumbersBool.Mix(randA(ip + new Vector2(0.0f, 1.0f)), randA(ip + new Vector2(1.0f, 1.0f)), u.X),
                    u.Y);

            return(res * res);
        }
Exemple #25
0
        void RenderOverlay(Widget widget)
        {
            var size = RootWidget.Size;

            widget.PrepareRendererState();
            var veilColor = ColorTheme.Current.TimelineOverview.Veil;
            var zoom      = ContentWidget.Scale;
            var a         = Vector2.Floor(timeline.Offset * zoom);
            var b         = a + Vector2.Floor(new Vector2(timeline.Ruler.RootWidget.Width, timeline.Roll.RootWidget.Height) * zoom);

            b = Vector2.Min(size, b);
            Renderer.DrawRect(0, 0, a.X, size.Y, veilColor);
            Renderer.DrawRect(b.X, 0, size.X, size.Y, veilColor);
            Renderer.DrawRect(a.X, 0, b.X, a.Y, veilColor);
            Renderer.DrawRect(a.X, b.Y, b.X, size.Y, veilColor);
            Renderer.DrawRectOutline(a, b, ColorTheme.Current.TimelineOverview.Border);
        }
Exemple #26
0
        public void Round()
        {
            Vector2 vector2 = new Vector2(0.4f, 0.6f);

            // CEILING

            Vector2 ceilMember = vector2;

            ceilMember.Ceiling();

            Vector2 ceilResult;

            Vector2.Ceiling(ref vector2, out ceilResult);

            Assert.AreEqual(new Vector2(1.0f, 1.0f), ceilMember);
            Assert.AreEqual(new Vector2(1.0f, 1.0f), Vector2.Ceiling(vector2));
            Assert.AreEqual(new Vector2(1.0f, 1.0f), ceilResult);

            // FLOOR

            Vector2 floorMember = vector2;

            floorMember.Floor();

            Vector2 floorResult;

            Vector2.Floor(ref vector2, out floorResult);

            Assert.AreEqual(new Vector2(0.0f, 0.0f), floorMember);
            Assert.AreEqual(new Vector2(0.0f, 0.0f), Vector2.Floor(vector2));
            Assert.AreEqual(new Vector2(0.0f, 0.0f), floorResult);

            // ROUND

            Vector2 roundMember = vector2;

            roundMember.Round();

            Vector2 roundResult;

            Vector2.Round(ref vector2, out roundResult);

            Assert.AreEqual(new Vector2(0.0f, 1.0f), roundMember);
            Assert.AreEqual(new Vector2(0.0f, 1.0f), Vector2.Round(vector2));
            Assert.AreEqual(new Vector2(0.0f, 1.0f), roundResult);
        }
Exemple #27
0
        private void Draw(SpriteBatch sb)
        {
            Texture2D     value  = TextureAssets.Extra[48].get_Value();
            SpriteEffects effect = SpriteEffects.None;
            Vector2       vector = GetPosition(out effect);

            vector = vector.Floor();
            bool      flag   = lifeTime < 6 || lifeTimeStart - lifeTime < 6;
            Rectangle value2 = value.Frame(8, 38, (!flag) ? 1 : 0);
            Vector2   origin = new Vector2(value2.Width / 2, value2.Height);

            if (Main.player[Main.myPlayer].gravDir == -1f)
            {
                origin.Y = 0f;
                effect  |= SpriteEffects.FlipVertically;
                vector   = Main.ReverseGravitySupport(vector);
            }
            sb.Draw(value, vector, value2, Color.White, 0f, origin, 1f, effect, 0f);
            if (flag)
            {
                return;
            }
            if (emote >= 0)
            {
                if ((emote == 87 || emote == 89) && effect.HasFlag(SpriteEffects.FlipHorizontally))
                {
                    effect   &= ~SpriteEffects.FlipHorizontally;
                    vector.X += 4f;
                }
                sb.Draw(value, vector, value.Frame(8, 38, emote * 2 % 8 + frame, 1 + emote / 4), Color.White, 0f, origin, 1f, effect, 0f);
            }
            else if (emote == -1)
            {
                value = TextureAssets.NpcHead[metadata].get_Value();
                float num = 1f;
                if ((float)value.Width / 22f > 1f)
                {
                    num = 22f / (float)value.Width;
                }
                if ((float)value.Height / 16f > 1f / num)
                {
                    num = 16f / (float)value.Height;
                }
                sb.Draw(value, vector + new Vector2(effect.HasFlag(SpriteEffects.FlipHorizontally) ? 1 : (-1), -value2.Height + 3), null, Color.White, 0f, new Vector2(value.Width / 2, 0f), num, effect, 0f);
            }
        }
Exemple #28
0
        protected override void DrawSelf(SpriteBatch spriteBatch)
        {
            CalculatedStyle dimensions = GetDimensions();

            if (ScaleToFit)
            {
                spriteBatch.Draw(_texture.get_Value(), dimensions.ToRectangle(), Color);
                return;
            }
            Vector2 vector  = _texture.get_Value().Size();
            Vector2 vector2 = dimensions.Position() + vector * (1f - ImageScale) / 2f + vector * NormalizedOrigin;

            if (RemoveFloatingPointsFromDrawPosition)
            {
                vector2 = vector2.Floor();
            }
            spriteBatch.Draw(_texture.get_Value(), vector2, null, Color, Rotation, vector * NormalizedOrigin, ImageScale, SpriteEffects.None, 0f);
        }
Exemple #29
0
        protected override void DrawSelf(SpriteBatch spriteBatch)
        {
            CalculatedStyle dimensions = this.GetDimensions();

            if (this.ScaleToFit)
            {
                spriteBatch.Draw(this._texture.Value, dimensions.ToRectangle(), this.Color);
            }
            else
            {
                Vector2 vector2_1 = this._texture.Value.Size();
                Vector2 vector2_2 = dimensions.Position() + vector2_1 * (1f - this.ImageScale) / 2f + vector2_1 * this.NormalizedOrigin;
                if (this.RemoveFloatingPointsFromDrawPosition)
                {
                    vector2_2 = vector2_2.Floor();
                }
                spriteBatch.Draw(this._texture.Value, vector2_2, new Rectangle?(), this.Color, this.Rotation, vector2_1 * this.NormalizedOrigin, this.ImageScale, SpriteEffects.None, 0.0f);
            }
        }
Exemple #30
0
        public override void Update()
        {
            base.Update();

            if (LockCameraToLevelBounds)
            {
                if (
                    Camera.Bounds.Left < LevelRenderer.Bounds.Left || Camera.Bounds.Top < LevelRenderer.Bounds.Top ||
                    Camera.Bounds.Right > LevelRenderer.Bounds.Right || Camera.Bounds.Bottom > LevelRenderer.Bounds.Bottom
                    )
                {
                    Camera.Position = Vector2.Clamp(Camera.Bounds.Location, LevelRenderer.Bounds.Location, LevelRenderer.Bounds.Location + LevelRenderer.Bounds.Size - Camera.Bounds.Size) + (Camera.Bounds.Size * 0.5f);
                }
            }

            if (LockCameraToZoomPixels)
            {
                Camera.Position = Vector2.Floor(Camera.Position);
            }
        }
Exemple #31
0
        public Cell this[Vector2 xy]
        {
            get
            {
                xy.Floor();
                if ((xy.X <     0) || (xy.Y <     0) ||
                    (xy.X >= Size) || (xy.Y >= Size))
                    return null;

                return Cells[(int)xy.X, (int)xy.Y];
            }
        }