spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C#-Quelltext

                        double wi_probability = 0.001;
                        if (rand.NextDouble() < wi_probability)
                        {
                            Color[] data = new Color[texture.Width * texture.Height];
                            texture.GetData(data);


                            data[randomNumber] = Color.White;

                            texture.SetData(data);
                        }

C#-Quelltext

namespace StrategicGame
{
    /// <summary>
    /// This is the main type for your game
    /// </summary>
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch generalSpriteBatch;

        Vector4 battlefield = new Vector4();

        int _g;

        Dictionary<int, string> seasons = new Dictionary<int, string>();
        int currentSeasonIndex = 1;
        KeyboardState oldState;
        List<Tile> battlefieldList = new List<Tile>();
        Dictionary<string, Texture2D> textureList;
        Dictionary<string, SpriteFont> fontList;

        Random rand = new Random();

        Vector2 numberPosition = new Vector2(25, 25);

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

        /// <summary>
        /// Allows the game to perform any initialization it needs to before starting to run.
        /// This is where it can query for any required services and load any non-graphic
        /// related content.  Calling base.Initialize will enumerate through any components
        /// and initialize them as well.
        /// </summary>
        protected override void Initialize()
        {
            // TODO: Add your initialization logic here

            base.Initialize();
        }

        /// <summary>
        /// LoadContent will be called once per game and is the place to load
        /// all of your content.
        /// </summary>
        protected override void LoadContent()
        {
            textureList = ContentLoader.LoadListContent<Texture2D>(Content, "Sprites");
            fontList = ContentLoader.LoadListContent<SpriteFont>(Content, "Fonts");

            generalSpriteBatch = new SpriteBatch(GraphicsDevice);

            battlefield.X = 0;
            battlefield.Y = 0;
            battlefield.W = 100; //width
            battlefield.Z = 100; //height


            seasons.Add(1, "Spring");
            seasons.Add(2, "Summer");
            seasons.Add(3, "Autumn");
            seasons.Add(4, "Winter");



            Texture2D grass = new Texture2D(GraphicsDevice, 1, 1);
            grass = textureList["grass"];

            Color[] dataPainted = new Color[textureList["grass"].Width * textureList["grass"].Height];
            textureList["grass"].GetData(dataPainted);

            _g = dataPainted.GetHashCode();

            double texHeight = grass.Height, texWidth = grass.Width;

            double numberOfTilesVertical = (double)GraphicsDevice.Viewport.Height / (double)texHeight;
            double numberOfTilesHorizontal = (double)GraphicsDevice.Viewport.Width / (double)texWidth;

            double digitsAfterDotVert = Math.Round(numberOfTilesVertical - Math.Round(numberOfTilesVertical, 0), 3), digitsAfterDotHori = Math.Round(numberOfTilesHorizontal - Math.Round(numberOfTilesHorizontal, 0), 3);

            numberOfTilesVertical = numberOfTilesVertical - digitsAfterDotVert;
            numberOfTilesHorizontal = numberOfTilesHorizontal - digitsAfterDotHori;

            texHeight = (double)GraphicsDevice.Viewport.Height / numberOfTilesVertical;
            texWidth = (double)GraphicsDevice.Viewport.Width / numberOfTilesHorizontal;
            Vector2 proportions = new Vector2(((float)texWidth / (float)grass.Width), ((float)texHeight / (float)grass.Height));

            for (int i = 0; i < numberOfTilesHorizontal; i++)
            {
                for (int j = 0; j < numberOfTilesVertical; j++)
                {
                    float posX = (float)texWidth * i;
                    float posY = (float)texHeight * j;
                    Tile _tile = new Tile();
                    _tile.Position = new Vector2(posX, posY);
                    _tile.Proportions = proportions;
                    _tile.Texture = grass;
                    _tile.Texture.Name = "grass";
                    battlefieldList.Add(_tile);
                }
            }

        }

        /// <summary>
        /// UnloadContent will be called once per game and is the place to unload
        /// all content.
        /// </summary>
        protected override void UnloadContent()
        {
            // TODO: Unload any non ContentManager content here
        }

        /// <summary>
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input, and playing audio.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Update(GameTime gameTime)
        {
            // Allows the game to exit
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();

            UpdateInput(gameTime);
            GraphicsDevice.Textures[0] = null;

            for (int i = 0; i < battlefieldList.Count; i++)
            {
                Tile _tile = new Tile(battlefieldList[i]);
                Texture2D texture = _tile.Texture;
                int randomNumber = rand.Next(0, texture.Width * texture.Height);
                switch (seasons[currentSeasonIndex])
                {
                    case "Spring":
                        double sp_probability = 0.000001;
                        if (rand.NextDouble() < sp_probability)
                        {
                            Color[] data = new Color[texture.Width * texture.Height];
                            texture.GetData(data);
                            data[randomNumber] = Color.White;
                            texture.SetData(data);
                        }
                        break;
                    case "Summer":
                        double su_probability = 1;
                        if (rand.NextDouble() < su_probability)
                        {
                            Texture2D originalTexture = new Texture2D(GraphicsDevice, 1, 1);
                            originalTexture = textureList[texture.Name];
                            Color[] dataPainted = new Color[texture.Width * texture.Height];
                            Color[] dataOriginal = new Color[originalTexture.Width * originalTexture.Height];



                            //texture.GetData(dataPainted);
                            originalTexture.GetData(dataOriginal);
                            int sdfgsdf = dataOriginal.GetHashCode();
                            //Color dO = dataOriginal[randomNumber];
                            //dataPainted[randomNumber] = dO;
                            //texture.SetData(dataPainted);
                            texture = originalTexture;
                        }
                        break;
                    case "Autumn":
                        double au_probability = 0.001;
                        if (rand.NextDouble() < au_probability)
                        {
                            Color[] data = new Color[texture.Width * texture.Height];
                            texture.GetData(data);
                            data[randomNumber] = Color.Blue;
                            texture.SetData(data);
                        }
                        break;
                    case "Winter":
                        double wi_probability = 0.001;
                        if (rand.NextDouble() < wi_probability)
                        {
                            Color[] data = new Color[texture.Width * texture.Height];
                            texture.GetData(data);


                            data[randomNumber] = Color.White;

                            texture.SetData(data);
                        }
                        break;

                }
                battlefieldList[i] = _tile;
            }


            // TODO: Add your update logic here

            base.Update(gameTime);
        }

        private void UpdateInput(GameTime gameTime)
        {
            KeyboardState newState = Keyboard.GetState();

            if (oldState != newState && newState.IsKeyDown(Keys.Up))
            {
                currentSeasonIndex += 1;
                if (currentSeasonIndex > seasons.Count)
                {
                    currentSeasonIndex = 1;
                }
            }
            else if (oldState != newState && newState.IsKeyDown(Keys.Down))
            {
                currentSeasonIndex -= 1;
                if (currentSeasonIndex <= 0)
                {
                    currentSeasonIndex = seasons.Count;
                }
            }

            oldState = newState;

        }

        /// <summary>
        /// This is called when the game should draw itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);

            generalSpriteBatch.Begin();

            for (int i = 0; i < battlefieldList.Count; i++)
            {
                generalSpriteBatch.Draw(battlefieldList[i].Texture, battlefieldList[i].Position, null, Color.White, 0f, battlefieldList[i].Proportions / 2, battlefieldList[i].Proportions, SpriteEffects.None, battlefieldList[i].drawIndex);
            }

            generalSpriteBatch.DrawString(fontList["SpriteFont1"], currentSeasonIndex.ToString(), numberPosition, Color.White, 0, fontList["SpriteFont1"].MeasureString(currentSeasonIndex.ToString()) / 2, 1.0f, SpriteEffects.None, 1.0f);

            generalSpriteBatch.End();

            base.Draw(gameTime);
        }
    }
}