Comment déplacer la balle dans des directions différentes?

Question

Maintenant, quand j'appuie sur la barre d'espace, elle va aller à gauche ou à droite, je veux que la balle passe directement la première fois.Ensuite, quand la balle frappe un mur, bloque ou file, je veux que la balle en quelque sorte. C'est mon premier projet de jeu scolaire, c'est un jeu de pong d'une ligne.

Editer: Modifier J'ai ajouté "boll_speed.X = random.Next (-1, 1);", et cela fonctionne parfaitement!

• linje = ligne
• liv = vit
• boll = balle
• Poäng = points
• Je ne pas utiliser "blockröd = blockred" en ce moment

• blockgrön = blockgreen

  public class Game1 : Game 
  { 
  GraphicsDeviceManager graphics; 
  SpriteBatch spriteBatch; 
  SpriteFont spritefont; 
  Texture2D linje_texture; 
  Texture2D boll_texture; 
  Texture2D blockröd_texture; 
  Texture2D blockgrön_texture; 
  Texture2D gameover_texture; 
  Rectangle linje_rect; 
  Rectangle boll_rect; 
  Rectangle blockröd_rect; 
  Rectangle blockgrön_rect; 
  Rectangle gameover_rect; 
  
  Vector2 linje_speed; 
  Vector2 boll_speed; 
  
  Random random; 
  
  int liv; 
  int poang; 
  int highscore; 
  
  List<Rectangle> block = new List<Rectangle>(); 
  
  bool Start = false; 
  
  public Game1() 
  { 
      graphics = new GraphicsDeviceManager(this); 
      Content.RootDirectory = "Content"; 
  
      graphics.PreferredBackBufferWidth = 760; 
      graphics.PreferredBackBufferHeight = 620; 
  } 
  
  protected override void Initialize() 
  { 
      linje_speed.X = 5f; 
      boll_speed.X = boll_speed.X = random.Next(-1, 1); 
      boll_speed.Y = 6f; 
      liv = 3; 
      poang = 0; 
  
      random = new Random(); 
  
      base.Initialize(); 
  } 
  
  protected override void LoadContent() 
  { 
      spriteBatch = new SpriteBatch(GraphicsDevice); 
      spritefont = Content.Load<SpriteFont>("Fonts/Myfont"); 
      linje_texture = Content.Load<Texture2D>("Pics/linje-lång"); 
      boll_texture = Content.Load<Texture2D>("Pics/boll"); 
      blockgrön_texture = Content.Load<Texture2D>("Pics/block-grön"); 
      blockröd_texture = Content.Load<Texture2D>("Pics/block-röd"); 
      gameover_texture = Content.Load<Texture2D>("Pics/GameOver"); 
      linje_rect = new Rectangle((Window.ClientBounds.Width - linje_texture.Width)/2, 580, linje_texture.Width, linje_texture.Height); 
      boll_rect = new Rectangle((Window.ClientBounds.Width - boll_texture.Width)/2, 556, boll_texture.Width, boll_texture.Height); 
      gameover_rect = new Rectangle((Window.ClientBounds.Width/2) - (gameover_texture.Width/2), (Window.ClientBounds.Height/2) - gameover_texture.Height/2, gameover_texture.Width, gameover_texture.Height); 
  
      block.Add(blockgrön_rect); 
      block.Add(blockröd_rect); 
      for (int i = 1; i < 5; i++) 
      { 
       for (int g = 1; g < 13; g++) 
       { 
        block.Add(new Rectangle((g * 63) - 60, (i * 40), blockgrön_texture.Width, blockgrön_texture.Height)); 
       } 
      } 
  } 
  
  protected override void UnloadContent() 
  { 
      // TODO: Unload any non ContentManager content here 
  } 
  
  protected override void Update(GameTime gameTime) 
  { 
      if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape)) 
       Exit(); 
      if (Start == true) 
      { 
       boll_rect.X += (int)boll_speed.X; 
       boll_rect.Y += (int)boll_speed.Y; 
      } 
  
      if(Start == false) 
      { 
       boll_rect.X = linje_rect.X + ((linje_texture.Width/2) - (boll_texture.Width/2)); 
      } 
      if (boll_rect.X > Window.ClientBounds.Width - boll_texture.Width || boll_rect.X < 0) 
       boll_speed.X *= -1; 
  
      if (boll_rect.Y > Window.ClientBounds.Height - boll_texture.Height || boll_rect.Y < 0) 
       boll_speed.Y *= -1; 
  
      if (boll_rect.Y > Window.ClientBounds.Height - boll_texture.Height) 
      { 
       liv -= 1; 
       Start = false; 
       boll_rect.X = (Window.ClientBounds.Width - boll_texture.Width)/2; 
       boll_rect.Y = 556; 
       linje_rect.X = (Window.ClientBounds.Width - linje_texture.Width)/2; 
       linje_rect.Y = 580; 
      } 
  
      KeyboardState ks = Keyboard.GetState(); 
      if (ks.IsKeyDown(Keys.Left)) 
      { 
       linje_rect.X -= (int)linje_speed.X; 
      } 
      else if (ks.IsKeyDown(Keys.Right)) 
      { 
       linje_rect.X += (int)linje_speed.X; 
      } 
      else if (ks.IsKeyDown(Keys.Space)) 
      { 
       Start = true; 
      } 
  
      if (linje_rect.X > Window.ClientBounds.Width - linje_texture.Width) 
       linje_rect.X = (Window.ClientBounds.Width - linje_texture.Width); 
  
      if (linje_rect.X < 0) 
       linje_rect.X = 0; 
  
      if (linje_rect.Intersects(boll_rect)) 
      { 
       boll_speed.Y *= -1; 
      } 
  
      base.Update(gameTime); 
  } 
  
  protected override void Draw(GameTime gameTime) 
  { 
      GraphicsDevice.Clear(Color.Black); 
  
      spriteBatch.Begin(); 
      if (liv > 0) 
      { 
       spriteBatch.Draw(linje_texture, linje_rect, Color.White); 
       spriteBatch.Draw(boll_texture, boll_rect, Color.White); 
       spriteBatch.DrawString(spritefont, "Liv kvar: " + liv, Vector2.Zero, Color.White); 
       spriteBatch.DrawString(spritefont, "Points: " + poang, new Vector2(350, 0), Color.White); 
       spriteBatch.DrawString(spritefont, "Highscore: " + highscore, new Vector2(660, 0), Color.White); 
       foreach (Rectangle g in block) 
       { 
        spriteBatch.Draw(blockgrön_texture, g, Color.White); 
       } 
      } 
      if (liv == 0) 
      { 
       spriteBatch.Draw(gameover_texture, gameover_rect, Color.White); 
      } 
      spriteBatch.End(); 
  
      base.Draw(gameTime); 
  } 
  } 
  

difficulté à ces pièces:

 if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape)) 
      Exit(); 
     if (Start == true) 
     { 
      boll_rect.X += (int)boll_speed.X; 
      boll_rect.Y += (int)boll_speed.Y; 
     } 

---

 if (boll_rect.X > Window.ClientBounds.Width - boll_texture.Width || boll_rect.X < 0) 
      boll_speed.X *= -1; 

     if (boll_rect.Y > Window.ClientBounds.Height - boll_texture.Height || boll_rect.Y < 0) 
      boll_speed.Y *= -1; 

---

 else if (ks.IsKeyDown(Keys.Space)) 
     { 
      Start = true; 
     } 

---

 if (linje_rect.Intersects(boll_rect)) 
     { 
      boll_speed.Y *= -1; 
      boll_speed.Y += random.Next(-100, 101)/100.0f; 
      boll_speed.X *= -1; 
      boll_speed.X += random.Next(-100, 101)/100.0f; 
     } 

Answer 1

Je vous penser à dire que vous voulez que la balle pour changer des directions aléatoires quand il atteint les limites ou la ligne de la fenêtre. Si oui:

Vous utilisez des valeurs constantes pour vos changements de direction. Ajoutez un randomizer pour multiplier votre boll_speed par.

Par exemple, dans pseudocode, au lieu de -1, faites aléatoire (-1).

Answer 2

Random.Next(-1) devrait vous donner une erreur hors limites.

Vous pouvez utiliser quelque chose comme Random.Next(-200, 0)/100.0f, qui renverra un nombre négatif entre -2 et 0 (y compris -2, à l'exclusion de 0).

Mais remarquez que cette multiplication entraînera un ralentissement de la balle au fil du temps. Il peut atteindre le double de la vitesse actuelle, mais il peut ralentir jusqu'à près de 0 en une seule étape. Donc, je préférerais d'abord inverser la vitesse de la balle dans la direction y et garder la même chose dans x si vous frappez des lignes horizontales, et inverser dans x et garder dans y si vous frappez des lignes verticales. Ensuite, faites une addition aléatoire d'une constante de zéro-signifie.

boll_speed.Y *= -1; 
boll_speed.Y += random.Next(-100, 101)/100.0f; // Add random number between -1 and 1 with 0.01 precision. 
// and nearly the same for X. Depending on the lines hit. 

Answer 3

Je vais vous donner l'idée générique. S'il vous plaît adapter à votre exemple

Disons que vous voulez déplacer dans toutes les directions sur la carte, imaginez maintenant votre conseil d'administration en tant que matrice bi-dimensionnelle (tous vos pixels a un x, représentation y sur cette carte)

Le (0,0) marque le coin supérieur gauche de votre tableau, et votre (largeur, hauteur) marque le coin inférieur droit.Votre balle est au milieu de la planche sur la position (x, y), où x> 0 et x < largeur (de la planche) et y> 0 et y < hauteur.

Vous avez 8 base de directions différentes sur l'image ci-dessous

Maintenant, il est temps de traduire ces directions à une structure logique. Vous devez créer un tableau pour cela, disons que nous voulons commencer à partir de la direction NW. Je vais créer un tableau avec les nombres que vous devez ajouter à votre position (x, y) afin de continuer dans la direction que vous choisissez. Si vous voyez que je suis de créer une matrice bidimentional

Maintenant, c'est le pseudo-code pour votre idée:

int[,] directions = new int[,]{{-1,-1,-1,0,1,1,1,0}, {-1,0,1,1,1,0,-1,-1}}; 

    public void Move(Game game) 
    { 
     Point currentPosition = GetYourCurrentPosition(); //the x, y 
     int direction = GetYourRandomDirection() //this should be a random number between 0 and 7, beucase the array for directions has 8 positions. 


      int xDirection = directions[0, direction]; 
      int yDirection = directions[1, direction]; 

      //move inside the board forever 
      while(true) 
      { 
       while(ICanMoveTo(currentPosition.X + xDirection, currentPosition.Y + yDirection) 
       { 
       //keep moving on the same direction 
       currentPosition.X += xDirection; 
       currentPosition.Y += yDirection; 
       } 

       //if you can't move anymore in the same direction, then change 
       direction = GetYourRandomDirection(); 
       xDirection = directions[0, direction]; 
       yDirection = directions[1, direction]; 
      } 
     }