This sounds like a very n00b question, but bear with me here:
I'm trying to access the position of my bat (paddle) in my pong game and use it in my ball class. I'm doing this because I want a particle effect to go off at the point of contact where the ball hits the bat.
Each time the ball hits the bat, I receive an error stating that I haven't created an instance of the bat. I understand that I have to (or can use a static class), but I'm not sure of how to do so in this example.
I've included both my Bat and Ball classes.
namespace Pong
{
#region Using Statements
using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
#endregion
public class Ball
{
#region Fields
private readonly Random rand;
private readonly Texture2D texture;
private readonly SoundEffect warp;
private double direction;
private bool isVisible;
private float moveSpeed;
private Vector2 position;
private Vector2 resetPos;
private Rectangle size;
private float speed;
private bool isResetting;
private bool collided;
private Vector2 oldPos;
private ParticleEngine particleEngine;
private ContentManager contentManager;
private SpriteBatch spriteBatch;
private bool hasHitBat;
private AIBat aiBat;
private Bat bat;
#endregion
#region Constructors and Destructors
/// <summary>
///
Constructor for the ball
/// </summary>
public Ball(ContentManager contentManager, Vector2 ScreenSize)
{
moveSpeed = 15f;
speed = 0;
texture = contentManager.Load<Texture2D>(@"gfx/balls/redBall");
direction = 0;
size = new Rectangle(0, 0, texture.Width, texture.Height);
resetPos = new Vector2(ScreenSize.X / 2, ScreenSize.Y / 2);
position = resetPos;
rand = new Random();
isVisible = true;
hasHitBat = false;
// Everything to do with particles
List<Texture2D> textures = new List<Texture2D>();
textures.Add(contentManager.Load<Texture2D>(@"gfx/particle/circle"));
textures.Add(contentManager.Load<Texture2D>(@"gfx/particle/star"));
textures.Add(contentManager.Load<Texture2D>(@"gfx/particle/diamond"));
particleEngine = new ParticleEngine(textures, new Vector2());
}
#endregion
#region Public Methods and Operators
/// <summary>
/// Checks for the collision between the bat and the ball. Sends ball in the appropriate
/// direction
/// </summary>
public void BatHit(int block)
{
if (direction > Math.PI * 1.5f || direction < Math.PI * 0.5f)
{
hasHitBat = true;
particleEngine.EmitterLocation = new Vector2(aiBat.Position.X, aiBat.Position.Y);
switch (block)
{
case 1:
direction = MathHelper.ToRadians(200);
break;
case 2:
direction = MathHelper.ToRadians(195);
break;
case 3:
direction = MathHelper.ToRadians(180);
break;
case 4:
direction = MathHelper.ToRadians(180);
break;
case 5:
direction = MathHelper.ToRadians(165);
break;
}
}
else
{
hasHitBat = true;
particleEngine.EmitterLocation = new Vector2(bat.Position.X, bat.Position.Y);
switch (block)
{
case 1:
direction = MathHelper.ToRadians(310);
break;
case 2:
direction = MathHelper.ToRadians(345);
break;
case 3:
direction = MathHelper.ToRadians(0);
break;
case 4:
direction = MathHelper.ToRadians(15);
break;
case 5:
direction = MathHelper.ToRadians(50);
break;
}
}
if (rand.Next(2) == 0)
{
direction += MathHelper.ToRadians(rand.Next(3));
}
else
{
direction -= MathHelper.ToRadians(rand.Next(3));
}
AudioManager.Instance.PlaySoundEffect("hit");
}
/// <summary>
/// JEP - added method to slow down ball after powerup deactivates
/// </summary>
public void DecreaseSpeed()
{
moveSpeed -= 0.6f;
}
/// <summary>
/// Draws the ball on the screen
/// </summary>
public void Draw(SpriteBatch spriteBatch)
{
if (isVisible)
{
spriteBatch.Begin();
spriteBatch.Draw(texture, size, Color.White);
spriteBatch.End();
// Draws sprites for particles when contact is made
particleEngine.Draw(spriteBatch);
}
}
/// <summary>
/// Checks for the current direction of the ball
/// </summary>
public double GetDirection()
{
return direction;
}
/// <summary>
/// Checks for the current position of the ball
/// </summary>
public Vector2 GetPosition()
{
return position;
}
/// <summary>
/// Checks for the current size of the ball (for the powerups)
/// </summary>
public Rectangle GetSize()
{
return size;
}
/// <summary>
/// Grows the size of the ball when the GrowBall powerup is used.
/// </summary>
public void GrowBall()
{
size = new Rectangle(0, 0, texture.Width * 2, texture.Height * 2);
}
/// <summary>
/// Was used to increased the speed of the ball after each point is scored.
/// No longer used, but am considering implementing again.
/// </summary>
public void IncreaseSpeed()
{
moveSpeed += 0.6f;
}
/// <summary>
/// Check for the ball to return normal size after the Powerup has expired
/// </summary>
public void NormalBallSize()
{
size = new Rectangle(0, 0, texture.Width, texture.Height);
}
/// <summary>
/// Check for the ball to return normal speed after the Powerup has expired
/// </summary>
public void NormalSpeed()
{
moveSpeed += 15f;
}
/// <summary>
/// Checks to see if ball went out of bounds, and triggers warp sfx
/// </summary>
public void OutOfBounds()
{
// Checks if the player is still alive or not
if (isResetting)
{
AudioManager.Instance.PlaySoundEffect("warp");
{
// Used to stop the the issue where the ball hit sfx kept going off when detecting collison
isResetting = false;
AudioManager.Instance.Dispose();
}
}
}
/// <summary>
/// Speed for the ball when Speedball powerup is activated
/// </summary>
public void PowerupSpeed()
{
moveSpeed += 20.0f;
}
/// <summary>
/// Check for where to reset the ball after each point is scored
/// </summary>
public void Reset(bool left)
{
if (left)
{
direction = 0;
}
else
{
direction = Math.PI;
}
// Used to stop the the issue where the ball hit sfx kept going off when detecting collison
isResetting = true;
position = resetPos; // Resets the ball to the center of the screen
isVisible = true;
speed = 15f; // Returns the ball back to the
default speed, in case the speedBall was active
if (rand.Next(2) == 0)
{
direction += MathHelper.ToRadians(rand.Next(30));
}
else
{
direction -= MathHelper.ToRadians(rand.Next(30));
}
}
/// <summary>
/// Shrinks the ball when the ShrinkBall powerup is activated
/// </summary>
public void ShrinkBall()
{
size = new Rectangle(0, 0, texture.Width / 2, texture.Height / 2);
}
/// <summary>
/// Stops the ball each time it is reset. Ex: Between points / rounds
/// </summary>
public void Stop()
{
isVisible = true;
speed = 0;
}
/// <summary>
/// Updates position of the ball
/// </summary>
public void UpdatePosition()
{
size.X = (int)position.X;
size.Y = (int)position.Y;
oldPos.X = position.X;
oldPos.Y = position.Y;
position.X += speed * (float)Math.Cos(direction);
position.Y += speed * (float)Math.Sin(direction);
bool collided = CheckWallHit();
particleEngine.Update();
// Stops the issue where ball was oscillating on the ceiling or floor
if (collided)
{
position.X = oldPos.X + speed * (float)Math.Cos(direction);
position.Y = oldPos.Y + speed * (float)Math.Sin(direction);
}
}
#endregion
#region Methods
/// <summary>
/// Checks for collision with the ceiling or floor. 2*Math.pi = 360 degrees
/// </summary>
private bool CheckWallHit()
{
while (direction > 2 * Math.PI)
{
direction -= 2 * Math.PI;
return true;
}
while (direction < 0)
{
direction += 2 * Math.PI;
return true;
}
if (position.Y <= 0 || (position.Y > resetPos.Y * 2 - size.Height))
{
direction = 2 * Math.PI - direction;
return true;
}
return true;
}
#endregion
}
}
namespace Pong
{
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using System;
public class Bat
{
public Vector2 Position;
public float moveSpeed;
public Rectangle size;
private int points;
private int yHeight;
private Texture2D leftBat;
public float turbo;
public float recharge;
public float interval;
public bool isTurbo;
/// <summary>
///
Constructor for the bat
/// </summary>
public Bat(ContentManager contentManager, Vector2 screenSize, bool side)
{
moveSpeed = 7f;
turbo = 15f;
recharge = 100f;
points = 0;
interval = 5f;
leftBat = contentManager.Load<Texture2D>(@"gfx/bats/batGrey");
size = new Rectangle(0, 0, leftBat.Width, leftBat.Height);
// True means left bat, false means right bat.
if (side) Position = new Vector2(30, screenSize.Y / 2 - size.Height / 2);
else Position = new Vector2(screenSize.X - 30, screenSize.Y / 2 - size.Height / 2);
yHeight = (int)screenSize.Y;
}
public void IncreaseSpeed()
{
moveSpeed += .5f;
}
/// <summary>
/// The speed of the bat when Turbo is activated
/// </summary>
public void Turbo()
{
moveSpeed += 8.0f;
}
/// <summary>
/// Returns the speed of the bat back to normal after Turbo is deactivated
/// </summary>
public void DisableTurbo()
{
moveSpeed = 7.0f;
isTurbo = false;
}
/// <summary>
/// Returns the bat to the nrmal size after the Grow/Shrink powerup has expired
/// </summary>
public void NormalSize()
{
size = new Rectangle(0, 0, leftBat.Width, leftBat.Height);
}
/// <summary>
/// Checks for the size of the bat
/// </summary>
public Rectangle GetSize()
{
return size;
}
/// <summary>
/// Adds point to the player or the AI after scoring. Currently Disabled.
/// </summary>
public void IncrementPoints()
{
points++;
}
/// <summary>
/// Checks for the number of points at the moment
/// </summary>
public int GetPoints()
{
return points;
}
/// <summary>
/// Sets thedefault starting position for the bats
/// </summary>
/// <param name="position"></param>
public void SetPosition(Vector2 position)
{
if (position.Y < 0)
{
position.Y = 0;
}
if (position.Y > yHeight - size.Height)
{
position.Y = yHeight - size.Height;
}
this.Position = position;
}
/// <summary>
/// Checks for the current position of the bat
/// </summary>
public Vector2 GetPosition()
{
return Position;
}
/// <summary>
/// Controls the bat moving up the screen
/// </summary>
public void MoveUp()
{
SetPosition(Position + new Vector2(0, -moveSpeed));
}
/// <summary>
/// Controls the bat moving down the screen
/// </summary>
public void MoveDown()
{
SetPosition(Position + new Vector2(0, moveSpeed));
}
/// <summary>
/// Updates the position of the AI bat, in order to track the ball
/// </summary>
/// <param name="ball"></param>
public virtual void UpdatePosition(Ball ball)
{
size.X = (int)Position.X;
size.Y = (int)Position.Y;
}
/// <summary>
/// Resets the bat to the center location after a new game starts
/// </summary>
public void ResetPosition()
{
SetPosition(new Vector2(GetPosition().X, yHeight / 2 - size.Height));
}
/// <summary>
/// Used for the Growbat powerup
/// </summary>
public void GrowBat()
{
// Doubles the size of the bat collision
size = new Rectangle(0, 0, leftBat.Width * 2, leftBat.Height * 2);
}
/// <summary>
/// Used for the Shrinkbat powerup
/// </summary>
public void ShrinkBat()
{
// 1/2 the size of the bat collision
size = new Rectangle(0, 0, leftBat.Width / 2, leftBat.Height / 2);
}
/// <summary>
/// Draws the bats
/// </summary>
public virtual void Draw(SpriteBatch batch)
{
batch.Draw(leftBat, size, Color.White);
}
}
}
