MonoGame | One framework for creating powerful crossplatform games. | Game Engine library

The package abcdefg_1.0.8.0_x86_x64_bundle.appxupload can’t be encrypted because it targets 
the Windows.Mobile platform, which does not support encryption. The package will be encrypted 
in your sandbox environments, but it will be published unencrypted to the Store.

The Target Device Family in the AppxManifest is set to Windows.Universal but that
means that your game can’t be encrypted due to Windows.Mobile not supporting it. Please set 
the Target Device Family to Windows.Xbox and Windows.Desktop
instead so that your build can be encrypted and then resubmit the new build.

Validation error: FrameworkDependencyVersionConflict - 10.0.0.0, Microsoft.VCLibs.140.00 14.0.30704.0, 10.0.10042.0
Validation error: FrameworkDependencyVersionConflict - 10.0.0.0, Microsoft.VCLibs.140.00 14.0.30704.0, 10.0.10042.0
Validation error: FrameworkDependencyVersionConflict - 10.0.0.0, Microsoft.NET.Native.Framework.2.2 2.2.29512.0, 10.0.10049.0
Validation error: FrameworkDependencyVersionConflict - 10.0.0.0, Microsoft.NET.Native.Framework.2.2 2.2.29512.0, 10.0.10049.0
Validation error: FrameworkDependencyVersionConflict - 10.0.0.0, Microsoft.NET.Native.Runtime.2.2 2.2.28604.0, 10.0.10049.0
Validation error: FrameworkDependencyVersionConflict - 10.0.0.0, Microsoft.NET.Native.Runtime.2.2 2.2.28604.0, 10.0.10049.0

protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);

            _spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);

            int sizeOfSprites = 64;
            float scale = .25f;
            foreach (Cell cell in _map.GetAllCells())
            {
            // error in the line below    
            Microsoft.Xna.Framework.Rectangle position = new Microsoft.Xna.Framework.Rectangle(cell.X * sizeOfSprites * scale, cell.Y * sizeOfSprites * scale);
                if (cell.IsWalkable)
                {
                    _spriteBatch.Draw(floorSprite, position, null, Color.White, 0f, new Vector2(scale, scale), 0.0f, 0f);
                }
                else
                {
                    _spriteBatch.Draw(wallSprite, position, null, Color.White, 0f, new Vector2(scale, scale), 0.0f, 0f);
                }
            }

            _spriteBatch.End();

            base.Draw(gameTime);
        }

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using System;
using System.Collections.Generic;

namespace TSA3
{
    public class Game1 : Game
    {
        private GraphicsDeviceManager graphics;
        private SpriteBatch spriteBatch;

        // Platform
        Platform platform;
        Texture2D platformTexture;
        Rectangle platformRectangle;
        Color platformColor;

        // Ball
        Ball ball;
        Texture2D ballTexture;
        Rectangle ballRectangle;
        Color ballColor;
        bool ballDirectionX = true, ballDirectionY = true;

        // Enemy
        Enemy enemy;
        Texture2D enemyTexture;
        Rectangle enemyRectangle;
        Color enemyColor;

        Random random = new Random();

        public const int ScreenW = 1200, ScreenH = 720;

        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
            IsMouseVisible = true;

        }

        protected override void Initialize()
        {
            graphics.PreferredBackBufferWidth = ScreenW;
            graphics.PreferredBackBufferHeight = ScreenH;
            graphics.ApplyChanges();

            Window.AllowUserResizing = false;
            Window.AllowAltF4 = true;
            Window.Title = "Arkanoid";

            // Platform
            platformTexture = Content.Load<Texture2D>("platform");
            platformRectangle = new Rectangle(0, Window.ClientBounds.Height - 50, 100, 30);
            platformColor = Color.White;

            // Ball
            ballTexture = Content.Load<Texture2D>("ball");
            ballRectangle = new Rectangle(0, 0, 20, 20);
            ballColor = Color.DarkBlue;

            // Enemy
            enemyTexture = Content.Load<Texture2D>("enemyPiece");
            enemyRectangle = new Rectangle(Window.ClientBounds.Width / 2, Window.ClientBounds.Height / 2, 200, 200);
            enemyColor = Color.White;

            base.Initialize();
        }

        protected override void LoadContent()
        {
            // Player
            platform = new Platform(platformTexture, platformRectangle, platformColor, Window.ClientBounds.Width - 100);

            // Ball
            ball = new Ball(ballTexture, ballRectangle, ballColor, Window.ClientBounds.Width - 20, Window.ClientBounds.Height - 20, ballDirectionX, ballDirectionY);

            // Enemy
            enemy = new Enemy(enemyTexture, enemyRectangle, enemyColor);

            spriteBatch = new SpriteBatch(GraphicsDevice);

        }

        float spawn = 0;

        protected override void Update(GameTime gameTime)
        {
            spawn += (float)gameTime.ElapsedGameTime.TotalSeconds;

            ball.ballBounce(platform.PlatformRectangle);

            Keys[] k = Keyboard.GetState().GetPressedKeys();
            foreach (Keys key in k)
            {
                platform.platformMovement(key);
                break;
            }

            if (Keyboard.GetState().IsKeyDown(Keys.Space) && !ball.StartGame)
                ball.StartGame = true;

            ball.ballCollision(platform.PlatformRectangle);
            ball.enemyCollision(enemy.enemyRectangle);

            base.Update(gameTime);
        }


        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);

            spriteBatch.Begin();
            spriteBatch.Draw(ball.BallTexture, ball.BallRectangle, ball.BallColor);
            spriteBatch.Draw(platform.PlatformTexture, platform.PlatformRectangle, platform.PlatformColor);
            spriteBatch.Draw(enemy.enemyTexture, enemy.enemyRectangle, enemy.enemyColor);
            spriteBatch.End();


            base.Draw(gameTime);
        }
    }
}

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using System;
using System.Collections.Generic;
using System.Text;

namespace TSA3
{
    public class Ball
    {
        Texture2D ballTexture;
        Rectangle ballRectangle;
        Color ballColor;

        int boundaryX, boundaryY;
        bool ballDirectionX, ballDirectionY;
        bool startGame;

        public const int BALL_SPEED = 7;

        public Ball(Texture2D ballTexture, Rectangle ballRectangle, Color ballColor, int boundaryX, int boundaryY, bool ballDirectionX, bool ballDirectionY)
        {
            this.ballTexture = ballTexture;
            this.ballRectangle = ballRectangle;
            this.ballColor = ballColor;
            this.boundaryX = boundaryX;
            this.boundaryY = boundaryY;
            this.ballDirectionX = ballDirectionX;
            this.ballDirectionY = ballDirectionY;

            startGame = false;
        }

        public Texture2D BallTexture { get => ballTexture; }
        public Rectangle BallRectangle { get => ballRectangle; }
        public Color BallColor { get => ballColor; }
        public bool StartGame { get => startGame; set => startGame = value; }

        public void ballBounce(Rectangle platformRectangle)
        {
            if (startGame)
            {
                if (ballRectangle.X <= 0)
                    ballDirectionX = true;
                else if (ballRectangle.X >= boundaryX)
                    ballDirectionX = false;

                if (ballRectangle.Y <= 0)
                {
                    ballDirectionY = true;
                }
                else if (ballRectangle.Y >= boundaryY)
                {
                    startGame = false;
                }

                if (ballDirectionX)
                    ballRectangle.X += BALL_SPEED;
                else
                    ballRectangle.X -= BALL_SPEED;

                if (ballDirectionY)
                    ballRectangle.Y += BALL_SPEED;
                else
                    ballRectangle.Y -= BALL_SPEED;
            }
            else
            {
                ballRectangle.Location = new Point(platformRectangle.X + (platformRectangle.Width / 2) - 10, platformRectangle.Y - (ballRectangle.Height - 5));
            }
        }

        public void ballCollision(Rectangle platform)
        {
            if (ballRectangle.Intersects(platform))
                ballDirectionY = false;    
        }

        public void enemyCollision(Rectangle enemyRectangle)
        {
            if (ballRectangle.Intersects(enemyRectangle))
                ballDirectionY = false;
        }


    }
}

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using System;
using System.Collections.Generic;
using System.Text;

namespace TSA3
{
    public class Enemy
    {
        public Texture2D enemyTexture;
        public Rectangle enemyRectangle;
        public Color enemyColor;

        public bool isVisible = true;

        Random random = new Random();

        public Enemy(Texture2D enemyTexture, Rectangle enemyRectangle, Color enemyColor)
        {
            this.enemyTexture = enemyTexture;
            this.enemyRectangle = enemyRectangle;
            this.enemyColor = enemyColor;
        }

        public Texture2D EnemyTexture { get => enemyTexture; }
        public Rectangle EnemyRectangle { get => enemyRectangle; }
        public Color EnemyColor { get => enemyColor; }
    }
}

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using System;
using System.Collections.Generic;
using System.Text;

namespace TSA3
{
    public class Platform
    {
        Texture2D platformTexture;
        Rectangle platformRectangle;
        Color platformColor;

        int boundaryX;

        public const int PLATFORM_SPEED = 10;

        public Platform(Texture2D platformTexture, Rectangle platformRectangle, Color platformColor, int boundaryX)
        {
            this.platformTexture = platformTexture;
            this.platformRectangle = platformRectangle;
            this.platformColor = platformColor;
            this.boundaryX = boundaryX;
        }

        public Texture2D PlatformTexture { get => platformTexture; }
        public Rectangle PlatformRectangle { get => platformRectangle; }
        public Color PlatformColor { get => platformColor; }

        public void platformMovement(Keys controls)
        {
            if (controls == Keys.A && platformRectangle.X > 0)
                platformRectangle.X -= PLATFORM_SPEED;

            if (controls == Keys.D && platformRectangle.X < boundaryX)
                platformRectangle.X += PLATFORM_SPEED;
        }

    }
}

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;

namespace Test
{
    public class Game1 : Game
    {
        private GraphicsDeviceManager _graphics;
        private SpriteBatch _spriteBatch;
        
        Texture2D realisticSturgeonSprite;

        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);

            
            realisticSturgeonSprite = Content.Load<Texture2D>("Sturgeon");
        }

        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);
            Texture2D rect = new Texture2D(_graphics.GraphicsDevice, 80, 30);

            Color[] data = new Color[80 * 30];
            for (int i = 0; i < data.Length; i++) data[i] = Color.Chocolate;
            rect.SetData(data);

            Vector2 coor = new Vector2(10, 20);
            _spriteBatch.Begin();
            _spriteBatch.Draw(rect, coor, Color.White);
            _spriteBatch.Draw(realisticSturgeonSprite, new Vector2(50, 60), Color.White);
            _spriteBatch.Draw(sturgeonSprite, new Vector2(80, 90), Color.White);
            _spriteBatch.End();
            

            base.Draw(gameTime);
        }
    }
}

double targetY; //this is the radians Y our camera is going to slowly rotate to
double currentY; //this is our current camera radians Y
float rotateSpeed = 5; //this value lets us slow down how fast we rotate towards targetY

double direction = Math.Cos(targetY) * Math.Sin(currentY) - Math.Cos(currentY) * Math.Sin(targetY);

double distance = Math.Min(currentY - targetY, (MathHelper.Pi * 2) - currentY - targetY);

if (direction > 0) 
{
    //rotating left towards targetY
    currentY -= distance / rotateSpeed;
}
else 
{
    //rotating right towards targetY
    currentY += distance / rotateSpeed;
}

if (currentY < targetY)
{
    //simply add currentY by the distance between currentY and targetY / divide it by how slow you want to rotate.
    currentY += (targetY - currentY) / rotateSpeed;
}
if (currentY > targetY)
{
    //simply minus currentY by the distance between currentY and targetY / divide it by how slow you want to rotate.
    currentY -= Math.Abs(targetY- currentY) / rotateSpeed;
}

float newRotation = targetY;

if (targetY < MathHelper.ToRadians(180) && currentY > MathHelper.ToRadians(180))
{
    newRotation = targetY + MathHelper.ToRadians(360);
}
if (targetY > MathHelper.ToRadians(180) && currentY < MathHelper.ToRadians(180))
{
    newRotation = targetY - MathHelper.ToRadians(360);
}
if (currentY < newRotation)
{
    currentY += (newRotation - currentY) / rotateSpeed;
}
if (currentY > newRotation)
{
    currentY -= Math.Abs(newRotation - currentY) / rotateSpeed;
}