0

我是唯一一个遇到这种情况的人吗？我只有一个小小的游戏，但由于 FPS 下降，它现在几乎无法玩了。

这是我的代码，如果有人想知道：

游戏1.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
using System.IO;

namespace Innovationally
{
enum GameState
{
    TITLESCREEN,
    HELPSCREEN,
    PLAYING,
    WON,
    LOST
}
public class Game1 : Microsoft.Xna.Framework.Game
{
    GraphicsDeviceManager graphics;
    SpriteBatch spriteBatch;
    GameState gameState = GameState.PLAYING;

    //PLAYER STATS
    public static Player player;
    KeyboardState currentKeyboardState;
    KeyboardState previousKeyboardState;
    float playerMoveSpeed;

    //COLLISION STATS
    Rectangle kollision;
    int bHit;

    //LEVEL STATS
    int level_number = 0;
    int loadlevel = 0;
    Texture2D hud, level0, level1, level2, level3, level4, level5;
    Vector2 levelPos;

    //ROOM STATS
    List<int> tile_life = new List<int>();
    Texture2D tile_gfx, stairsUp, stairsDown;
    List<Vector2> tile_position = new List<Vector2>();
    List<int> tile_type = new List<int>();
    List<int> tile_elev = new List<int>();
    int antlabb = 0;
    int antvapen = 0;
    int antpolis = 0;
    int antwavers = 0;
    int researchSpan;

    //MISC
    SpriteFont font;
    Loot loot;

    //GAMEPLAY STATS
    TimeSpan timeElapsed;

    public Game1()
    {
        graphics = new GraphicsDeviceManager(this);
        Content.RootDirectory = "Content";
        graphics.PreferredBackBufferHeight = 800;
        graphics.PreferredBackBufferWidth = 900;
    } 
    protected override void Initialize()
    {
        player = new Player();
        playerMoveSpeed = 4.0f;
        levelPos.X = 0;
        levelPos.Y = 0;
        loot = new Loot();
        researchSpan = 120;
        base.Initialize();
    }
    protected override void LoadContent()
    {
        spriteBatch = new SpriteBatch(GraphicsDevice);

        Vector2 playerPosition = new Vector2(430, 450);
        //LEVEL STATS
        LaddaLevel(level_number);
        level0 = Content.Load<Texture2D>("level0");
        level1 = Content.Load<Texture2D>("level1");
        level2 = Content.Load<Texture2D>("level2");
        level3 = Content.Load<Texture2D>("level3");
        level4 = Content.Load<Texture2D>("level4");
        level5 = Content.Load<Texture2D>("level5");
        hud = Content.Load<Texture2D>("hud");

        //ROOM STATS
        tile_gfx = Content.Load<Texture2D>("tile");
        stairsUp = Content.Load<Texture2D>("stairsUp");
        stairsDown = Content.Load<Texture2D>("stairsDown");

        font = Content.Load<SpriteFont>("SpriteFont1");
        player.Initialize(Content.Load<Texture2D>("Leftplayer"), playerPosition);

        //SOMEONE STOP THE MUSIC, MUSIC.
        MediaPlayer.Volume = 0.5f;
        MediaPlayer.IsRepeating = true;
        MediaPlayer.Play(Content.Load<Song>("barn-beat"));
    }
    public void LaddaLevel(int nummer)
    {
        StreamReader SR = new StreamReader(nummer.ToString());

        string bana = SR.ReadToEnd();
        SR.Close();
        int temp_positionY = 0;
        int temp_positionX = 0;

        tile_position.Clear(); 
        tile_type.Clear();    
        tile_life.Clear(); 

        for (int i = 0; i < bana.Length; i++)
        {
            switch (bana[i])
            {
                case ' ':
                    temp_positionX++;
                    break;
                case '0':
                    tile_life.Add(loot.myRnd.Next(8));
                    tile_position.Add(new Vector2((temp_positionX * 100), (temp_positionY * 100)));
                    temp_positionX++;
                    tile_type.Add(int.Parse(bana[i].ToString()));
                    break;
                case '8': 
                    tile_position.Add(new Vector2((temp_positionX * 100), (temp_positionY * 100)));
                    temp_positionX++;
                    tile_type.Add(int.Parse(bana[i].ToString()));
                    tile_life.Add(8);
                    break;
                case '9': 
                    tile_position.Add(new Vector2((temp_positionX * 100), (temp_positionY * 100)));
                    temp_positionX++;
                    tile_type.Add(int.Parse(bana[i].ToString()));
                    tile_life.Add(9);
                    break;
                case '\n':
                    temp_positionY++;
                    temp_positionX = 0;
                    break;
            }
        }
    }
    protected override void UnloadContent()
    {
    }
    protected override void Update(GameTime gameTime)
    {
        if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
            this.Exit();
        previousKeyboardState = currentKeyboardState;
        currentKeyboardState = Keyboard.GetState();
        if (currentKeyboardState.IsKeyDown(Keys.Escape) && previousKeyboardState.IsKeyUp(Keys.Escape))
            this.Exit();

        switch (gameState)
        {
            case GameState.TITLESCREEN:
                if (currentKeyboardState.IsKeyDown(Keys.S) && previousKeyboardState.IsKeyUp(Keys.S))
                    gameState = GameState.PLAYING;
                if (currentKeyboardState.IsKeyDown(Keys.H) && previousKeyboardState.IsKeyUp(Keys.H))
                    gameState = GameState.HELPSCREEN;
                break;
            case GameState.HELPSCREEN:
                if (currentKeyboardState.IsKeyDown(Keys.B) && previousKeyboardState.IsKeyUp(Keys.B))
                    gameState = GameState.TITLESCREEN;
                break;
            case GameState.PLAYING:
                timeElapsed += gameTime.ElapsedGameTime;
                UpdatePlayer(gameTime);
                UpdateResearchCenters(gameTime);
                UpdateCollisions(gameTime);
                break;
            case GameState.LOST:
                if (currentKeyboardState.IsKeyDown(Keys.S) && previousKeyboardState.IsKeyUp(Keys.S))
                {
                    loadlevel = 0;
                    gameState = GameState.PLAYING;
                }
                break;
        }
        base.Update(gameTime);
    }
    private void UpdatePlayer(GameTime gameTime)
    {

        if (currentKeyboardState.IsKeyDown(Keys.Left))
        {
            player.angle = (float)Math.PI * 1.5f;
            player.Position.X -= playerMoveSpeed;
        }
        if (currentKeyboardState.IsKeyDown(Keys.Right))
        {
            player.angle = (float)Math.PI / 2;
            player.Position.X += playerMoveSpeed;
        }
        if (currentKeyboardState.IsKeyDown(Keys.Up))
        {
            player.angle = (float)Math.PI * 2;
            player.Position.Y -= playerMoveSpeed;
        }
        if (currentKeyboardState.IsKeyDown(Keys.Down))
        {
            player.angle = (float)Math.PI;
            player.Position.Y += playerMoveSpeed;
        }
        if (player.health <= 0)
            gameState = GameState.LOST;
    }
    public void UpdateResearchCenters(GameTime gameTime)
    {
        researchSpan -= gameTime.ElapsedGameTime.Seconds;

        if (researchSpan <= 0)
        {
            loot.RandomResearch();
            researchSpan = 120;
        }
    }
    public void UpdateCollisions(GameTime gameTime)
    {
        Rectangle playerBox = new Rectangle((int)player.Position.X - 20, (int)player.Position.Y - 20, 40, 37);
        Rectangle levelBox = new Rectangle(0, 0, 900, 800);

        for (int i = 0; i < tile_position.Count; i++)
        {
            Rectangle tileBox = new Rectangle((int)tile_position[i].X, (int)tile_position[i].Y, 100, 100);
            if (playerBox.Intersects(tileBox))
            {
                if (tile_life[i] <= 9)
                {
                    if (tile_life[i] == 9 && currentKeyboardState.IsKeyDown(Keys.Space)) 
                    {
                        loadlevel += 1;
                        LaddaLevel(loadlevel);
                    }
                    else if (tile_life[i] == 8 && currentKeyboardState.IsKeyDown(Keys.Space))
                    {
                        loadlevel -= 1;
                        LaddaLevel(loadlevel);
                    }
                    else if (tile_life[i] == 7 && currentKeyboardState.IsKeyDown(Keys.Space))
                    {
                        loot.RandomLoot();
                        tile_life[i] = 70; 
                    }
                    else if ((tile_life[i] == 6 || tile_life[i] == 60) && currentKeyboardState.IsKeyDown(Keys.Space) && (player.mvgelever >= 1 || player.problemelever >= 1 || player.normalaelever >= 1))
                    {
                        if (player.mvgelever >= 1)
                        {
                            player.mvgelever -= 1;
                            tile_elev.Add(1);
                        }
                        else if (player.normalaelever >= 1)
                        {
                            player.normalaelever -= 1;
                            tile_elev.Add(2);
                        }
                        else if (player.problemelever >= 1)
                        {
                            player.problemelever -= 1;
                            tile_elev.Add(3);
                        }
                        tile_life[i] = 60;
                        antlabb += 1;

                    }
                    if (tile_life[i] == 60 && currentKeyboardState.IsKeyDown(Keys.Space))
                        {
                            antlabb -= 1;
                            if (tile_elev.Contains(1))
                                player.mvgelever += 1;
                            if (tile_elev.Contains(2))
                                player.normalaelever += 1;
                            if (tile_elev.Contains(3))
                                player.problemelever += 1;
                            tile_life[i] = 6;
                        }
                }
            }
        }
        //Överlappar vi?
        kollision = Intersection(playerBox, levelBox);

        if (kollision.Width > 0 && kollision.Height > 0)
        {
            Rectangle r1 = Normalize(playerBox, kollision);
            Rectangle r2 = Normalize(levelBox, kollision);
            if (loadlevel == 0)
                bHit = TestCollision(player.PlayerTexture, r1, level0, r2);
            if (loadlevel == 1)
                bHit = TestCollision(player.PlayerTexture, r1, level1, r2);
            if (loadlevel == 2)
                bHit = TestCollision(player.PlayerTexture, r1, level2, r2);
            if (loadlevel == 3)
                bHit = TestCollision(player.PlayerTexture, r1, level3, r2);
            if (loadlevel == 4)
                bHit = TestCollision(player.PlayerTexture, r1, level4, r2);
            if (loadlevel == 5)
                bHit = TestCollision(player.PlayerTexture, r1, level5, r2);
        }
        else
        {
            bHit = 0;
        }

        if (bHit == 1 || bHit == 2)
        {
            if (player.angle == (float)Math.PI)
                player.Position.Y -= playerMoveSpeed;
            if (player.angle == (float)Math.PI * 2)
                player.Position.Y += playerMoveSpeed;
            if (player.angle == (float)Math.PI / 2)
                player.Position.X -= playerMoveSpeed;
            if (player.angle == (float)Math.PI * 1.5f)
                player.Position.X += playerMoveSpeed;
        }
    }
    public static Rectangle Intersection(Rectangle r1, Rectangle r2)
    {
        int x1 = Math.Max(r1.Left, r2.Left);
        int y1 = Math.Max(r1.Top, r2.Top);
        int x2 = Math.Min(r1.Right, r2.Right);
        int y2 = Math.Min(r1.Bottom, r2.Bottom);

        if ((x2 >= x1) && (y2 >= y1))
        {
            return new Rectangle(x1, y1, x2 - x1, y2 - y1);
        }
        return Rectangle.Empty;
    }

    public static Rectangle Normalize(Rectangle reference, Rectangle overlap)
    {
        //Räkna ut en rektangel som kan användas relativt till referensrektangeln
        return new Rectangle(
          overlap.X - reference.X,
          overlap.Y - reference.Y,
          overlap.Width,
          overlap.Height);
    }

    public static int TestCollision(Texture2D t1, Rectangle r1, Texture2D t2, Rectangle r2)
    {
        //Beräkna hur många pixlar som finns i området som ska undersökas
        int pixelCount = r1.Width * r1.Height;
        uint[] texture1Pixels = new uint[pixelCount];
        uint[] texture2Pixels = new uint[pixelCount];

        //Kopiera ut pixlarna från båda områdena
        t1.GetData(0, r1, texture1Pixels, 0, pixelCount);
        t2.GetData(0, r2, texture2Pixels, 0, pixelCount);

        //Jämför om vi har några pixlar som överlappar varandra i områdena
        for (int i = 0; i < pixelCount; ++i)
        {
            if (((texture1Pixels[i] & 0xff000000) > 0) && (texture2Pixels[i] == 0xffC3C3C3))
            {
                return 1;
            }
            if (((texture1Pixels[i] & 0xff000000) > 0) && (texture2Pixels[i] == 0xff000000))
            {
                return 2;
            }
            if (((texture1Pixels[i] & 0xff000000) > 0) && (texture2Pixels[i] == 0xff000000))
            {
                return 1;
            }

        }
        return 0;
    }
    private void DrawHud()
    {
        string timeString = "TIME: " + timeElapsed.Minutes.ToString("00") + ":" + timeElapsed.Seconds.ToString("00");

        spriteBatch.Draw(hud, new Vector2(0, 0), Color.White);
        spriteBatch.DrawString(font, timeString, new Vector2(15, 35), Color.White);
        spriteBatch.DrawString(font, "Level " + (loadlevel + 1), new Vector2(15, 10), Color.White);
        spriteBatch.DrawString(font, "" + player.mvgelever, new Vector2(739, 55), Color.White);
        spriteBatch.DrawString(font, "" + player.problemelever, new Vector2(799, 55), Color.White);
        spriteBatch.DrawString(font, "" + player.normalaelever, new Vector2(859, 55), Color.White);
        spriteBatch.DrawString(font, "" + antwavers, new Vector2(454, 55), Color.White);
        spriteBatch.DrawString(font, "" + antpolis, new Vector2(514, 55), Color.White);
        spriteBatch.DrawString(font, "" + antvapen, new Vector2(574, 55), Color.White);
        spriteBatch.DrawString(font, "" + antlabb, new Vector2(633, 55), Color.White);
        spriteBatch.DrawString(font, "" + player.coins, new Vector2(359, 55), Color.White);
        spriteBatch.DrawString(font, "" + player.nyckel, new Vector2(328, 55), Color.White);
        spriteBatch.DrawString(font, "" + player.bombs, new Vector2(296, 55), Color.White);
        spriteBatch.DrawString(font, "RESEARCH IN: " + researchSpan, new Vector2(15, 55), Color.White);
    }
    protected override void Draw(GameTime gameTime)
    {
        GraphicsDevice.Clear(Color.CornflowerBlue);

        spriteBatch.Begin();
        switch (gameState)
        {
            case GameState.TITLESCREEN:
                break;
            case GameState.PLAYING:
                if (loadlevel == 0)
                    spriteBatch.Draw(level0, new Vector2(0, 0), Color.White);
                if (loadlevel == 1)
                    spriteBatch.Draw(level1, new Vector2(0, 0), Color.White);
                if (loadlevel == 2)
                    spriteBatch.Draw(level2, new Vector2(0, 0), Color.White);
                if (loadlevel == 3)
                    spriteBatch.Draw(level3, new Vector2(0, 0), Color.White);
                if (loadlevel == 4)
                    spriteBatch.Draw(level4, new Vector2(0, 0), Color.White);
                if (loadlevel == 5)
                    spriteBatch.Draw(level5, new Vector2(0, 0), Color.White);
                for (int i = 0; i < tile_position.Count; i++)
                {
                    switch (tile_life[i])
                    {
                        case 0: spriteBatch.Draw(tile_gfx, tile_position[i], Color.White);
                            break;
                        case 1: spriteBatch.Draw(tile_gfx, tile_position[i], Color.HotPink);
                            break;
                        case 2: spriteBatch.Draw(tile_gfx, tile_position[i], Color.YellowGreen);
                            break;
                        case 3: spriteBatch.Draw(tile_gfx, tile_position[i], Color.Purple);
                            break;
                        case 4: spriteBatch.Draw(tile_gfx, tile_position[i], Color.Yellow);
                            break;
                        case 5: spriteBatch.Draw(tile_gfx, tile_position[i], Color.Silver);
                            break;
                        case 6: spriteBatch.Draw(tile_gfx, tile_position[i], Color.Gold);
                            break;
                        case 60: spriteBatch.Draw(tile_gfx, tile_position[i], Color.Gold);
                            spriteBatch.Draw(player.PlayerTexture, new Vector2(tile_position[i].X + 40, tile_position[i].Y + 40), Color.White);
                            break;
                        case 7: spriteBatch.Draw(tile_gfx, tile_position[i], Color.Orange);
                            break;
                        case 70: spriteBatch.Draw(tile_gfx, tile_position[i], Color.DarkOrange);
                            break;
                        case 8: spriteBatch.Draw(stairsDown, tile_position[i], Color.White);
                            break;
                        case 9: spriteBatch.Draw(stairsUp, tile_position[i], Color.White);
                            break;
                    }
                }
                DrawHud();
                player.Draw(spriteBatch);
                break;
        }
        spriteBatch.End();
        base.Draw(gameTime);
    }
}
}

播放器类（Player.cs）：

using System;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;

namespace Innovationally
{
public class Player
{
    public Texture2D PlayerTexture;
    public Vector2 Position;
    public bool Active;
    public float angle;
    public int coins { get; set; }
    public int bombs { get; set; }
    public int normalaelever { get; set; }
    public int health { get; set; }
    public int damage { get; set; }
    public int maximumhealth { get; set; }
    public int problemelever { get; set; }
    public int mvgelever { get; set; }
    public int elever { get; set; }
    public int nyckel { get; set; }
    public int Width
    {
        get { return PlayerTexture.Width; }
    }
    public int Height
    {
        get { return PlayerTexture.Height; }
    }
    public void Initialize(Texture2D texture, Vector2 position)
    {
        PlayerTexture = texture;
        Position = position;
        Active = true;
        elever = 0;
        mvgelever = 0;
        normalaelever = 0;
        coins = 0;
        bombs = 0;
        health = 100;
        maximumhealth = 100;
        damage = 20;
        nyckel = 1;
        angle = (float)Math.PI * 2;
    }
    public void Draw(SpriteBatch spriteBatch)
    {
        spriteBatch.Draw(PlayerTexture, Position, null, Color.White, angle, new Vector2(PlayerTexture.Width / 2, PlayerTexture.Height / 2), 1f, SpriteEffects.None, 0f);
    }
}
}

最后，Loot.cs：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Innovationally
{
class Loot
{
    Player player = Game1.player;
    public Random myRnd = new Random();
    public int primarylootnumber;
    public int secondarylootnumber;
    public int tertiarylootnumber;
    public void RandomLoot()
    {
        primarylootnumber = myRnd.Next(1, 11);
        switch (primarylootnumber)
        {
            case 1:player.coins++;
                break;
            case 2:player.coins += 3;
                break;
            case 3:player.coins += 5;
                break;
            case 4:player.normalaelever += 1;
                break;
            case 5:player.normalaelever += 2;
                break;
            case 6:player.health += 10;
                break;
            case 7:player.health += 30;
                break;
            case 8:player.health += 50;
                break;
            case 9:player.damage += 5;
                break;
            case 10:player.damage += 10;
                break;
        }
        secondarylootnumber = myRnd.Next(1, 11);
        switch (primarylootnumber)
        {
            case 1:player.maximumhealth += 10;
                break;
            case 2:player.coins += 10;
                break;
            case 3:player.damage += 15;
                break;
            case 4:player.mvgelever += 1;
                break;
            case 5:player.problemelever += 1;
                break;
        }
        tertiarylootnumber = myRnd.Next(1, 31);
        switch (primarylootnumber)
        {
            case 10:
                player.mvgelever += 1;
                player.problemelever += 1;
                break;
            case 20:player.coins += 50;
                break;
            case 30:player.maximumhealth += 30;
                break;
        }

    }
    public void RandomResearch()
    {
        primarylootnumber = myRnd.Next(1, 6);
        switch (primarylootnumber)
        { 
            case 1:player.maximumhealth += 30;
                break;
            case 2: player.damage += 20;
                break;
            case 3:
                break;
            case 4:
                break;
            case 5:
                break;
        }
    }
}
}
4

2 回答 2

1

目前我能看到的唯一危险信号是：

t1.GetData(0, r1, texture1Pixels, 0, pixelCount);
t2.GetData(0, r2, texture2Pixels, 0, pixelCount);

这些调用具有很高的开销。如果您要进行逐像素碰撞检测，我建议您缓存或预计算像素数据，而不是每帧都从纹理中检索数据。

编辑：

这是您可能希望如何检索像素数据的玩具实现（未测试！）。希望这足以让你开始。

这里有两个用于获取纹理数据的迷你函数。初始化游戏时，使用“PixelMaps”传入所有纹理（例如，在数组中）。然后，您将拥有一个字典，可用于执行像素数据的查找。您将需要使用从纹理和您正在测试的矩形中闪烁的信息来选择正确的像素。

    public static uint[] Pixels(Texture2D texture)
    {
        uint[] data = new uint[texture.Width * texture.Height];
        texture.GetData(data);
        return data;
    }
    public static Dictionary<Texture2D, uint[]> PixelMaps(IEnumerable<Texture2D> textures)
    {
        return textures.ToDictionary(t => t, Pixels);
    }

TestCollision 函数现在可能看起来像这样（我试图使代码尽可能接近原始代码）。

    public static int TestCollision(uint[] t1,
        int t1Width,
        Rectangle r,
        uint[] t2)
    {
        for(var x = r.X; x < r.X + r.Width; x++)
            for (var y = r.Y; y < r.Y + r.Height; y++)
            {
                var i = x + (y * t1Width);
                if (((t1[i] & 0xff000000) > 0) && (t2[i] == 0xffC3C3C3))
                {
                    return 1;
                }
                if (((t1[i] & 0xff000000) > 0) && (t2[i] == 0xff000000))
                {
                    return 2;
                }
                if (((t1[i] & 0xff000000) > 0) && (t2[i] == 0xff000000))
                {
                    return 1;
                }
            }
        return 0;
    }

希望这足以让你开始！玩得开心 ：）

编辑2：

好的，更多信息，再次尝试不要过多地更改您的代码，我们开始：

为像素图引入一个新的私有成员。例如：

Dictionary<Texture2D, uint[]> pixelMaps;

在你的 init 函数中试试这个（顺便说一句，我也会使用枚举作为键将级别放在字典中，查找它。你永远不应该有像 0,1,2,3 这样的字段/属性，只是尖叫我需要某种列表/数组/关联数据结构。）：

       //LEVEL STATS
  level0 = Content.Load<Texture2D>("level0");
  level1 = Content.Load<Texture2D>("level1");
  level2 = Content.Load<Texture2D>("level2");
  level3 = Content.Load<Texture2D>("level3");
  level4 = Content.Load<Texture2D>("level4");
  level5 = Content.Load<Texture2D>("level5");
  //As you can see I'm using the new PixelMaps function here... 
  pixelMaps = PixelMaps(new[] { level0, level1, level2, level3, level4, level5 });

当你来测试碰撞时，你可以这样做：

var playerMap = pixelMaps[player.PlayerTexture];
var level0Map = pixelMaps[level0];
if (loadlevel == 0)
     bHit = TestCollision(playerMap, r1, level0Map);
于 2013-06-11T16:40:23.470 回答
0

解决这个问题（以及许多其他问题）的最好和最快的方法是使用分析器。它将能够向您展示哪些方法（可能还有行，ANTS支持这一点）完成时间最长。缩小范围后，您就可以弄清楚如何解决这些个别问题。

至于您发布的代码，我不得不同意 thedajaw 的观点，即碰撞代码有很大的优化空间。每帧获取纹理数据绝不是一个好主意，应该在游戏开始时完成一次并存储在一个变量中以供以后使用。

总的来说，我认为其余的都很好，但看看分析器显示了什么。一些小的结构问题（可以使用其他 ifs 代替 ifs，可以更好地处理事情等）

我建议阅读我在一个类似主题上问过的这个问题。

于 2013-06-12T01:51:24.973 回答