From d9e27910cfc13c156961caf52658b2e189729482 Mon Sep 17 00:00:00 2001
From: NikolajDanger <nikolajgade@live.dk>
Date: Tue, 2 Nov 2021 00:05:00 +0100
Subject: [PATCH] :sparkles:

---
 .gitignore                |   3 +
 Content/Content.mgcb      |  24 +++
 Content/playing cards.png | Bin 0 -> 16149 bytes
 Entities/Card.cs          | 308 ++++++++++++++++++++++++++++++++++++++
 Entities/CardPosition.cs  |  30 ++++
 Entities/EmptyDeck.cs     |  43 ++++++
 Entities/IGameEntity.cs   |  15 ++
 Game1.cs                  |  52 -------
 Graphics/Sprite.cs        |  35 +++++
 Logic/GameLogic.cs        | 117 +++++++++++++++
 Program.cs                |   2 +-
 Solitaire.cs              | 166 ++++++++++++++++++++
 12 files changed, 742 insertions(+), 53 deletions(-)
 create mode 100644 .gitignore
 create mode 100644 Content/playing cards.png
 create mode 100644 Entities/Card.cs
 create mode 100644 Entities/CardPosition.cs
 create mode 100644 Entities/EmptyDeck.cs
 create mode 100644 Entities/IGameEntity.cs
 delete mode 100644 Game1.cs
 create mode 100644 Graphics/Sprite.cs
 create mode 100644 Logic/GameLogic.cs
 create mode 100644 Solitaire.cs

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..3afdc66
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,3 @@
+bin/
+obj/
+.vscode/
\ No newline at end of file
diff --git a/Content/Content.mgcb b/Content/Content.mgcb
index ddc4c36..641f3ac 100644
--- a/Content/Content.mgcb
+++ b/Content/Content.mgcb
@@ -13,3 +13,27 @@
 
 #---------------------------------- Content ---------------------------------#
 
+#begin playing cards.png
+/importer:TextureImporter
+/processor:TextureProcessor
+/processorParam:ColorKeyColor=255,0,255,255
+/processorParam:ColorKeyEnabled=True
+/processorParam:GenerateMipmaps=False
+/processorParam:PremultiplyAlpha=True
+/processorParam:ResizeToPowerOfTwo=False
+/processorParam:MakeSquare=False
+/processorParam:TextureFormat=Color
+/build:playing cards.png
+
+#begin playing cards.png
+/importer:TextureImporter
+/processor:TextureProcessor
+/processorParam:ColorKeyColor=255,0,255,255
+/processorParam:ColorKeyEnabled=True
+/processorParam:GenerateMipmaps=False
+/processorParam:PremultiplyAlpha=True
+/processorParam:ResizeToPowerOfTwo=False
+/processorParam:MakeSquare=False
+/processorParam:TextureFormat=Color
+/build:playing cards.png
+
diff --git a/Content/playing cards.png b/Content/playing cards.png
new file mode 100644
index 0000000000000000000000000000000000000000..92b966a8244ff7a437029f8dd12dedbe5a51624c
GIT binary patch
literal 16149
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

literal 0
HcmV?d00001

diff --git a/Entities/Card.cs b/Entities/Card.cs
new file mode 100644
index 0000000..631fe3c
--- /dev/null
+++ b/Entities/Card.cs
@@ -0,0 +1,308 @@
+using System.Linq;
+using System;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System.Collections.Generic;
+using Solitaire.Graphics;
+
+namespace Solitaire.Entities {
+    public class Card: CardPosition {
+        const int SelectedOffset = 3;
+        public int DefaultX;
+
+        public Sprite Sprite {get; private set;}
+        public Sprite BackSprite {get; private set;}
+        public Sprite FrontSprite {get; private set;}
+        public int Value;
+        public bool Hidden {get; private set;}
+        private bool Selected;
+        public CardPosition parent = null;
+
+        private double lastClicked;
+
+        public void setSprite() {
+            if (Hidden) {
+                Sprite = BackSprite;
+            } else {
+                Sprite = FrontSprite;
+            }
+        }
+
+        public Card(int value, bool hidden, Vector2 position, Texture2D spriteSheet): base(position) {
+            Offset = 13;
+            Value = value;
+            Hidden = hidden;
+            if (Hidden) {
+                Offset = 8;
+            }
+
+            Position = position;
+            DefaultX = (int)position.X;
+
+            Stationary = true;
+
+            BackSprite = new Sprite(spriteSheet, 320, 192, 32, 48);
+            FrontSprite = new Sprite(
+                spriteSheet,
+                (value % 11) * 32,
+                (value / 11) * 48,
+                32,
+                48
+            );
+
+            setSprite();
+        }
+
+        public void NewPosition(Vector2 position) {
+            Position = position;
+            DefaultX = (int)position.X;
+        }
+
+        public void Hide() {
+            Hidden = true;
+            setSprite();
+        }
+
+        public void UnHide() {
+            Hidden = false;
+            setSprite();
+        }
+
+        public override void Draw(SpriteBatch spriteBatch, GameTime gameTime) {
+            Sprite.Draw(spriteBatch, Position);
+        }
+
+        private bool inRectangle(Vector2 point, Rectangle rectangle) {
+            return (
+                point.X >= rectangle.Left &&
+                point.X <= rectangle.Right &&
+                point.Y > rectangle.Top &&
+                point.Y < rectangle.Bottom
+            );
+        }
+
+        public void SetSelected(Vector2 mPosition, bool mHolding) {
+            int height = 40;
+            if (child != null) {
+                height = Offset;
+            } else if (Selected) {
+                height += SelectedOffset;
+            }
+
+            Rectangle spritePosition = new Rectangle(
+                (int)Position.X, (int)Position.Y, 32, height
+            );
+            if ((!Hidden || child == null) && !mHolding && !Following && inRectangle(mPosition, spritePosition) && !Selected && (child == null || !((Card)child).Selected) && (Offset > 0 || child == null)) {
+                Selected = true;
+            } else if (!inRectangle(mPosition, spritePosition) && Selected) {
+                Selected = false;
+                if (child != null) {
+                    ((Card)child).SetSelected(mPosition, mHolding);
+                    if (((Card)child).Selected) {
+                        ((Card)child).SetPosition(mPosition);
+                    }
+                }
+                if (parent != null) {
+                    if (parent is Card) {
+                        ((Card)parent).SetSelected(mPosition, mHolding);
+                        if (((Card)parent).Selected) {
+                            ((Card)parent).SetPosition(mPosition);
+                        }
+                    }
+                }
+            }
+        }
+
+        public void SetPosition(Vector2 mPosition) {
+            int X;
+            int Y;
+
+            if (Following) {
+                X = (int)mPosition.X - 16;
+                Y = (int)mPosition.Y - 16;
+            } else {
+                X = (int)parent.Position.X;
+                Y = (int)parent.Position.Y + parent.Offset;
+            }
+
+            if (Selected && !Following) {
+                Y -= SelectedOffset;
+            }
+
+            Position = new Vector2(X, Y);
+
+        }
+
+        public void SetStationary(bool stationary) {
+            Stationary = stationary;
+            if (child != null) {
+                ((Card)child).SetStationary(stationary);
+            }
+        }
+
+        private bool IsCloser(CardPosition other, CardPosition closest) {
+            return (
+                other.Stationary &&
+                other.child == null &&
+                (
+                    closest == null ||
+                    Vector2.Distance(closest.Position, Position) > Vector2.Distance(other.Position, Position)
+                ) &&
+                ValidPlacement(other)
+            );
+        }
+
+        private bool ValidPlacement(CardPosition other) {
+            return (
+                other == parent ||
+                (
+                    !(other is Card) &&
+                    (
+                        (
+                            !other.TopPile &&
+                            (
+                                (
+                                    Deck && other.Deck
+                                ) ||
+                                (
+                                    !other.Deck &&
+                                    Value % 13 == 12
+                                )
+                            )
+                        ) ||
+                        (
+                            other.TopPile &&
+                            Value % 13 == 0
+                        )
+                    )
+                ) ||
+                (
+                    other is Card &&
+                    (
+                        (
+                            !other.Deck &&
+                            (
+                                (
+                                    other.TopPile &&
+                                    Value / 13 == ((Card)other).Value / 13 &&
+                                    Value - 1 == ((Card)other).Value
+                                ) ||
+                                (
+                                    (Value % 13 + 1 == ((Card)other).Value % 13) &&
+                                    ((Value / 13) % 2 != (((Card)other).Value / 13) % 2)
+                                )
+                            )
+                        ) ||
+                        (
+                            Deck && other.Deck && !((Card)other).Hidden
+                        )
+                    )
+                )
+            );
+        }
+
+        public override void Update(GameTime gameTime, Vector2 mPosition, bool mReleased, bool mHolding, List<IGameEntity> entities) {
+            SetSelected(mPosition, mHolding);
+
+            if (parent != null && !Following) {
+                DrawOrder = parent.DrawOrder + 1;
+            } else if (!Following) {
+                DrawOrder = 1;
+            }
+
+            if (Selected && mReleased && !Following) {
+                if (!Hidden) {
+                    lastClicked = gameTime.TotalGameTime.TotalSeconds;
+                    Following = true;
+                    SetStationary(false);
+                    Selected = false;
+                    DrawOrder = 1000;
+                } else {
+                    UnHide();
+                    if (Deck) {
+                        parent.child = null;
+                        Selected = false;
+                        SolitaireGame.logic.DeckRevealed.Last().child = this;
+                        parent = SolitaireGame.logic.DeckRevealed.Last();
+                        SolitaireGame.logic.DeckRevealed.Add(this);
+                        SolitaireGame.logic.DeckHidden.Remove(this);
+                        parent.Offset = 0;
+                    }
+                }
+            } else if (Following && mReleased) {
+                CardPosition closest = null;
+                CardPosition oldPosition = parent;
+
+                parent.child = null;
+
+                foreach (IGameEntity entity in entities) {
+                    if (entity is CardPosition) {
+                        if (IsCloser((CardPosition)entity, closest)) {
+                            closest = (CardPosition)entity;
+                        }
+                    }
+                }
+
+                if (closest != null && Vector2.Distance(closest.Position, Position) < 50) {
+                    if (ValidPlacement(closest)) {
+                        Following = false;
+                        SetStationary(true);
+                        closest.child = this;
+                        parent = closest;
+                        if (parent is Card && !((Card)parent).Hidden){
+                            parent.Offset = 13;
+                        }
+                        if (parent.TopPile) {
+                            TopPile = true;
+                            parent.Offset = 0;
+                        } else {
+                            TopPile = false;
+                        }
+
+                        if (Deck && !closest.Deck) {
+                            Deck = false;
+                            SolitaireGame.logic.DeckRevealed.Remove(this);
+                        }
+
+                        if (Deck) {
+                            parent.Offset = 0;
+                        }
+                    }
+                } else {
+                    Following = false;
+                    SetStationary(true);
+                    oldPosition.child = this;
+                    parent = oldPosition;
+                }
+
+                if (gameTime.TotalGameTime.TotalSeconds - lastClicked < 0.3 && parent == oldPosition) {
+                    foreach (IGameEntity entity in SolitaireGame.entities) {
+                        if (entity is CardPosition && ((CardPosition)entity).TopPile && ((CardPosition)entity).child == null) {
+                            if (
+                                (entity is Card && ((Card)entity).Value % 13 == Value % 13 - 1 && ((Card)entity).Value / 13 == Value / 13) ||
+                                (!(entity is Card) && Value % 13 == 0)
+                                ) {
+                                parent.child = null;
+                                ((CardPosition)entity).child = this;
+                                parent = ((CardPosition)entity);
+                                TopPile = true;
+                                parent.Offset = 0;
+
+                                if (Deck) {
+                                    Deck = false;
+                                    SolitaireGame.logic.DeckRevealed.Remove(this);
+                                }
+                                break;
+                            }
+                        }
+                    }
+                }
+            } else if (Following && (mPosition.X < 0 || mPosition.X > SolitaireGame.gameWidth || mPosition.Y < 0 || mPosition.Y > SolitaireGame.gameHeight)) {
+                Following = false;
+                SetStationary(true);
+            }
+
+            SetPosition(mPosition);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Entities/CardPosition.cs b/Entities/CardPosition.cs
new file mode 100644
index 0000000..51d44fd
--- /dev/null
+++ b/Entities/CardPosition.cs
@@ -0,0 +1,30 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System.Collections.Generic;
+
+namespace Solitaire.Entities {
+    public class CardPosition: IGameEntity {
+        const int SelectedOffset = 0;
+        public int Offset {get; set;} = 0;
+
+        public bool TopPile = false;
+        public bool Deck = false;
+
+        public Vector2 Position {get; set;}
+        public CardPosition child = null;
+        public bool Stationary = true;
+
+        public int DrawOrder {get; set;}
+        public bool Following {get; set;} = false;
+
+        public CardPosition(Vector2 position) {
+            Position = position;
+        }
+
+        public virtual void Draw(SpriteBatch spriteBatch, GameTime gameTime) {
+        }
+
+        public virtual void Update(GameTime gameTime, Vector2 mPosition, bool mReleased, bool mHolding, List<IGameEntity> entities) {
+        }
+    }
+}
\ No newline at end of file
diff --git a/Entities/EmptyDeck.cs b/Entities/EmptyDeck.cs
new file mode 100644
index 0000000..914fb86
--- /dev/null
+++ b/Entities/EmptyDeck.cs
@@ -0,0 +1,43 @@
+using Microsoft.Xna.Framework;
+using System.Collections.Generic;
+
+namespace Solitaire.Entities {
+    public class EmptyDeck: CardPosition {
+        public bool Selected;
+
+        public EmptyDeck(Vector2 position): base(position) {
+
+        }
+
+        private bool inRectangle(Vector2 point, Rectangle rectangle) {
+            return (
+                point.X >= rectangle.Left &&
+                point.X <= rectangle.Right &&
+                point.Y > rectangle.Top &&
+                point.Y < rectangle.Bottom
+            );
+        }
+
+        public void SetSelected(Vector2 mPosition, bool mHolding) {
+            int height = 48;
+
+            Rectangle spritePosition = new Rectangle(
+                (int)Position.X, (int)Position.Y, 32, height
+            );
+            if (child == null && inRectangle(mPosition, spritePosition) && !mHolding) {
+                Selected = true;
+            } else if ((!inRectangle(mPosition, spritePosition) && Selected) || child != null) {
+                Selected = false;
+            }
+        }
+
+        public override void Update(GameTime gameTime, Vector2 mPosition, bool mReleased, bool mHolding, List<IGameEntity> entities) {
+            SetSelected(mPosition, mHolding);
+
+            if (Selected && mReleased) {
+                SolitaireGame.logic.FlipDeck();
+            }
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/Entities/IGameEntity.cs b/Entities/IGameEntity.cs
new file mode 100644
index 0000000..1865987
--- /dev/null
+++ b/Entities/IGameEntity.cs
@@ -0,0 +1,15 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System.Collections.Generic;
+
+namespace Solitaire.Entities {
+    public interface IGameEntity {
+        int DrawOrder {get;}
+        bool Following {get;}
+        Vector2 Position {get;}
+        int Offset {get; set;}
+
+        void Update(GameTime gameTime, Vector2 mPosition, bool mReleased, bool mHolding, List<IGameEntity> entities);
+        void Draw(SpriteBatch spriteBatch, GameTime gameTime);
+    }
+}
\ No newline at end of file
diff --git a/Game1.cs b/Game1.cs
deleted file mode 100644
index 4d971c9..0000000
--- a/Game1.cs
+++ /dev/null
@@ -1,52 +0,0 @@
-using Microsoft.Xna.Framework;
-using Microsoft.Xna.Framework.Graphics;
-using Microsoft.Xna.Framework.Input;
-
-namespace Solitaire
-{
-    public class Game1 : Game
-    {
-        private GraphicsDeviceManager _graphics;
-        private SpriteBatch _spriteBatch;
-
-        public Game1()
-        {
-            _graphics = new GraphicsDeviceManager(this);
-            Content.RootDirectory = "Content";
-            IsMouseVisible = true;
-        }
-
-        protected override void Initialize()
-        {
-            // TODO: Add your initialization logic here
-
-            base.Initialize();
-        }
-
-        protected override void LoadContent()
-        {
-            _spriteBatch = new SpriteBatch(GraphicsDevice);
-
-            // TODO: use this.Content to load your game content here
-        }
-
-        protected override void Update(GameTime gameTime)
-        {
-            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
-                Exit();
-
-            // TODO: Add your update logic here
-
-            base.Update(gameTime);
-        }
-
-        protected override void Draw(GameTime gameTime)
-        {
-            GraphicsDevice.Clear(Color.CornflowerBlue);
-
-            // TODO: Add your drawing code here
-
-            base.Draw(gameTime);
-        }
-    }
-}
diff --git a/Graphics/Sprite.cs b/Graphics/Sprite.cs
new file mode 100644
index 0000000..fe20b90
--- /dev/null
+++ b/Graphics/Sprite.cs
@@ -0,0 +1,35 @@
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework;
+
+namespace Solitaire.Graphics {
+    public class Sprite {
+        public Texture2D Texture {get; private set;}
+
+        public int X { get; set; }
+        public int Y { get; set; }
+
+        public int Width {get; set; }
+        public int Height { get; set; }
+
+        public Color TintColor { get; set; } = Color.White;
+
+        public Sprite(Texture2D texture, int x, int y, int width, int height) {
+            Texture = texture;
+            X = x;
+            Y = y;
+            Width = width;
+            Height = height;
+        }
+
+
+        public void Draw(SpriteBatch spriteBatch, Vector2 position) {
+            spriteBatch.Draw(
+                Texture,
+                position,
+                new Rectangle(X, Y, Width, Height),
+                TintColor
+            );
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/Logic/GameLogic.cs b/Logic/GameLogic.cs
new file mode 100644
index 0000000..7d272af
--- /dev/null
+++ b/Logic/GameLogic.cs
@@ -0,0 +1,117 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System.Collections.Generic;
+using Solitaire.Entities;
+using System.Linq;
+
+namespace Solitaire.Logic {
+    public class GameLogic {
+        public List<int> deck;
+        public List<IGameEntity> Entities;
+        private Texture2D _SpriteSheet;
+
+        public List<CardPosition> DeckHidden = new List<CardPosition>();
+        public List<CardPosition> DeckRevealed = new List<CardPosition>();
+
+        private void Shuffle<T>(List<T> list) {
+            System.Random random = new System.Random();
+            int n = list.Count;
+            while (n > 1) {
+                int k = random.Next(n);
+                n--;
+                T temp = list[k];
+                list[k] = list[n];
+                list[n] = temp;
+            }
+        }
+
+        private List<int> GenerateDeck() {
+            List<int> newDeck = new List<int>();
+
+            int i = 0;
+            while (i < 52)
+            {
+                newDeck.Add(i++);
+            }
+
+            Shuffle(newDeck);
+            return newDeck;
+        }
+
+        private Card DrawCard() {
+            Card card = new Card(
+                deck[0], true, new Vector2(0,0), _SpriteSheet
+            );
+
+            deck.RemoveAt(0);
+
+            return card;
+        }
+
+        private void PlayCards() {
+            Card card;
+            CardPosition lastCard;
+            for (int i = 0; i < 7; i++) {
+                card = null;
+                lastCard = new CardPosition(new Vector2(14 + (i * 40),60));
+                Entities.Add(lastCard);
+                for (int n = 0; n <= i; n ++) {
+                    card = DrawCard();
+                    card.parent = lastCard;
+                    lastCard.child = card;
+                    Entities.Add((Card)card);
+                    lastCard = card;
+                }
+                card.UnHide();
+            }
+            CardPosition topPile;
+            for (int i = 0; i < 4; i++) {
+                topPile = new CardPosition(new Vector2(134 + (i * 40),8));
+                topPile.TopPile = true;
+                Entities.Add(topPile);
+            }
+
+            CardPosition deckHidden = new EmptyDeck(new Vector2(14, 8));
+            deckHidden.Deck = true;
+            deckHidden.DrawOrder = 100;
+            DeckHidden.Add(deckHidden);
+            Entities.Add(deckHidden);
+            CardPosition deckRevealed = new CardPosition(new Vector2(54, 8));
+            deckRevealed.Deck = true;
+            DeckRevealed.Add(deckRevealed);
+
+            while (deck.Count() > 0) {
+                card = DrawCard();
+                card.parent = DeckHidden.Last();
+                card.Offset = 0;
+                card.Deck = true;
+                DeckHidden.Last().child = card;
+                DeckHidden.Add(card);
+                Entities.Add(card);
+            }
+        }
+
+        public void FlipDeck() {
+            CardPosition card;
+            while (DeckRevealed.Count() > 1) {
+                card = DeckRevealed.Last();
+                card.child = null;
+                ((Card)card).parent = DeckHidden.Last();
+                DeckHidden.Last().child = card;
+                DeckRevealed.Remove(card);
+                DeckHidden.Add(card);
+                ((Card)card).Hide();
+                ((Card)card).SetPosition(new Vector2(0,0));
+                card.DrawOrder = ((Card)card).parent.DrawOrder + 1;
+            }
+        }
+
+        public GameLogic(List<IGameEntity> entities, Texture2D _spriteSheet) {
+            deck = GenerateDeck();
+            Entities = entities;
+
+            _SpriteSheet = _spriteSheet;
+            PlayCards();
+        }
+    }
+}
\ No newline at end of file
diff --git a/Program.cs b/Program.cs
index be34f3e..e57a8d1 100644
--- a/Program.cs
+++ b/Program.cs
@@ -7,7 +7,7 @@ namespace Solitaire
         [STAThread]
         static void Main()
         {
-            using (var game = new Game1())
+            using (var game = new SolitaireGame())
                 game.Run();
         }
     }
diff --git a/Solitaire.cs b/Solitaire.cs
new file mode 100644
index 0000000..d66bc1b
--- /dev/null
+++ b/Solitaire.cs
@@ -0,0 +1,166 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+using Solitaire.Entities;
+using Solitaire.Logic;
+
+namespace Solitaire
+{
+    public class SolitaireGame : Game
+    {
+        public const int gameWidth = 300;
+        public const int gameHeight = 300;
+
+        private GraphicsDeviceManager _graphics;
+        private SpriteBatch _spriteBatch;
+        private SpriteBatch _renderTargetBatch;
+        private RenderTarget2D renderTarget;
+        private Rectangle renderTargetRectangle;
+
+        private float renderRatio;
+
+        private MouseState mState;
+        public Vector2 mPosition;
+        public bool mClicked;
+        public bool mReleased;
+        public bool mHolding;
+
+        private Texture2D _spriteSheet;
+
+        public static GameLogic logic;
+
+
+        public static List<IGameEntity> entities;
+
+        private void setRenderRatio() {
+            float wRatio = Window.ClientBounds.Width / (float)gameWidth;
+            float hRatio = Window.ClientBounds.Height / (float)gameHeight;
+
+            if (wRatio > hRatio) {
+                renderRatio = hRatio;
+            } else {
+                renderRatio = wRatio;
+            }
+        }
+
+        private Rectangle renderRectangle() {
+            float drawnWidth = gameWidth * renderRatio;
+            float drawnHeight = gameHeight * renderRatio;
+
+
+            Rectangle rect =  new Rectangle(
+                (int)((Window.ClientBounds.Width - drawnWidth)/2),
+                (int)((Window.ClientBounds.Height - drawnHeight)/2),
+                (int)drawnWidth,
+                (int)drawnHeight
+            );
+
+            return rect;
+        }
+
+        public SolitaireGame()
+        {
+            _graphics = new GraphicsDeviceManager(this);
+            Content.RootDirectory = "Content";
+            IsMouseVisible = true;
+            this.Window.AllowUserResizing = true;
+            this.Window.ClientSizeChanged += new EventHandler<EventArgs>(Window_ClientSizeChanged);
+
+            void Window_ClientSizeChanged(object sender, EventArgs e) {
+                setRenderRatio();
+            }
+        }
+
+        protected override void Initialize()
+        {
+            _graphics.PreferredBackBufferWidth = gameWidth * 2;
+            _graphics.PreferredBackBufferHeight = gameHeight * 2;
+            _graphics.ApplyChanges();
+
+            setRenderRatio();
+
+            base.Initialize();
+        }
+
+        protected override void LoadContent()
+        {
+            _spriteBatch = new SpriteBatch(GraphicsDevice);
+            _renderTargetBatch = new SpriteBatch(GraphicsDevice);
+            renderTarget = new RenderTarget2D(
+                GraphicsDevice, gameWidth, gameHeight
+            );
+
+            _spriteSheet = Content.Load<Texture2D>("playing cards");
+
+            entities = new List<IGameEntity>();
+            logic = new GameLogic(entities, _spriteSheet);
+        }
+
+        protected override void Update(GameTime gameTime)
+        {
+            renderTargetRectangle = renderRectangle();
+
+            mState = Mouse.GetState();
+            mPosition = mState.Position.ToVector2();
+            mPosition.X -= renderTargetRectangle.Left;
+            mPosition.Y -= renderTargetRectangle.Top;
+            mPosition /= renderRatio;
+
+            if (mReleased) {
+                mReleased = false;
+            }
+
+            if (mState.LeftButton == ButtonState.Pressed && !mClicked) {
+                mClicked = true;
+            } else if (mState.LeftButton == ButtonState.Released && mClicked) {
+                mClicked = false;
+                mReleased = true;
+            }
+
+            entities.Sort(delegate(IGameEntity a, IGameEntity b) {
+                return a.DrawOrder.CompareTo(b.DrawOrder);
+            });
+
+            mHolding = false;
+            foreach (IGameEntity entity in entities) {
+                if (entity is Card && entity.Following) {
+                    mHolding = true;
+                }
+            }
+
+            foreach (IGameEntity entity in entities) {
+                entity.Update(gameTime, mPosition, mReleased, mHolding, entities);
+            }
+
+
+            base.Update(gameTime);
+        }
+
+
+        protected override void Draw(GameTime gameTime)
+        {
+            GraphicsDevice.Clear(Color.Black);
+
+            GraphicsDevice.SetRenderTarget(renderTarget);
+            GraphicsDevice.Clear(Color.Green);
+            _spriteBatch.Begin();
+            foreach (IGameEntity entity in entities) {
+                entity.Draw(_spriteBatch, gameTime);
+            }
+            _spriteBatch.End();
+            GraphicsDevice.SetRenderTarget(null);
+
+            _renderTargetBatch.Begin(SpriteSortMode.Deferred, BlendState.NonPremultiplied, SamplerState.PointClamp, DepthStencilState.Default, RasterizerState.CullNone);
+            _renderTargetBatch.Draw(
+                renderTarget,
+                renderTargetRectangle,
+                Color.White
+            );
+            _renderTargetBatch.End();
+
+            base.Draw(gameTime);
+        }
+    }
+}