/// <summary>
/// Constructs a new OnlinePlayer instance.
/// </summary>
public OnlinePlayer(int gamerIndex, ContentManager content,
int screenWidth, int screenHeight)
{
number = gamerIndex;
if (gamerIndex == 0)
{
sprite = content.Load <Texture2D>("Sprites\\player1");
}
if (gamerIndex == 1)
{
sprite = content.Load <Texture2D>("Sprites\\player2");
}
if (gamerIndex == 2)
{
sprite = content.Load <Texture2D>("Sprites\\player3");
}
if (gamerIndex == 3)
{
sprite = content.Load <Texture2D>("Sprites\\player4");
}
if (gamerIndex > 3)
{
sprite = content.Load <Texture2D>("Sprites\\player" + ((int)(AAgameplayScreen.RandomFloat(1, 4))).ToString());
}
alive = true;
velocity = new Vector2(0, AAgameplayScreen.RandomFloat(-8, -12));
position = new Vector2(1280 / 2 - sprite.Width, 720);
center = new Vector2(sprite.Width / 2, sprite.Height / 2);
logpositions = new Vector2[18];
acceleration = new Vector2(0,
0.5f * .5f);
}
/// <summary>
/// InitializeParticle is overridden to add the appearance of wind.
/// </summary>
/// <param name="p">the particle to set up</param>
/// <param name="where">where the particle should be placed</param>
protected override void InitializeParticle(Particle p, Vector2 where)
{
base.InitializeParticle(p, where);
// the base is mostly good, but we want to simulate a little bit of wind
// heading to the right.
p.Acceleration.X += AAgameplayScreen.RandomFloat(10, 50);
}
/// <summary>
/// PickRandomDirection is overriden so that we can make the particles always
/// move have an initial velocity pointing up.
/// </summary>
/// <returns>a random direction which points basically up.</returns>
protected override Vector2 PickRandomDirection()
{
// Point the particles somewhere between 80 and 100 degrees.
// tweak this to make the smoke have more or less spread.
float radians = AAgameplayScreen.RandomFloat(
MathHelper.ToRadians(80), MathHelper.ToRadians(100));
Vector2 direction = Vector2.Zero;
// from the unit circle, cosine is the x coordinate and sine is the
// y coordinate. We're negating y because on the screen increasing y moves
// down the monitor.
direction.X = (float)Math.Cos(radians);
direction.Y = -(float)Math.Sin(radians);
return(direction);
}
// initialize is called by ParticleSystem to set up the particle, and prepares
// the particle for use.
public void Initialize(Vector2 position, Vector2 velocity, Vector2 acceleration,
float lifetime, float scale, float rotationSpeed)
{
// set the values to the requested values
this.Position = position;
this.Velocity = velocity;
this.Acceleration = acceleration;
this.Lifetime = lifetime;
this.Scale = scale;
this.RotationSpeed = rotationSpeed;
// reset TimeSinceStart - we have to do this because particles will be
// reused.
this.TimeSinceStart = 0.0f;
// set rotation to some random value between 0 and 360 degrees.
this.Rotation = AAgameplayScreen.RandomFloat(0, MathHelper.TwoPi);
}
/// <summary>
/// InitializeParticle randomizes some properties for a particle, then
/// calls initialize on it. It can be overriden by subclasses if they
/// want to modify the way particles are created. For example,
/// SmokePlumeParticleSystem overrides this function make all particles
/// accelerate to the right, simulating wind.
/// </summary>
/// <param name="p">the particle to initialize</param>
/// <param name="where">the position on the screen that the particle should be
/// </param>
protected virtual void InitializeParticle(Particle p, Vector2 where)
{
// first, call PickRandomDirection to figure out which way the particle
// will be moving. velocity and acceleration's values will come from this.
Vector2 direction = PickRandomDirection();
// pick some random values for our particle
float velocity =
AAgameplayScreen.RandomFloat(minInitialSpeed, maxInitialSpeed);
float acceleration =
AAgameplayScreen.RandomFloat(minAcceleration, maxAcceleration);
float lifetime =
AAgameplayScreen.RandomFloat(minLifetime, maxLifetime);
float scale =
AAgameplayScreen.RandomFloat(minScale, maxScale);
float rotationSpeed =
AAgameplayScreen.RandomFloat(minRotationSpeed, maxRotationSpeed);
// then initialize it with those random values. initialize will save those,
// and make sure it is marked as active.
p.Initialize(
where, velocity * direction, acceleration * direction,
lifetime, scale, rotationSpeed);
}
/// <summary>
/// PickRandomDirection is used by InitializeParticles to decide which direction
/// particles will move. The default implementation is a random vector in a
/// circular pattern.
/// </summary>
protected virtual Vector2 PickRandomDirection()
{
float angle = AAgameplayScreen.RandomFloat(0, MathHelper.TwoPi);
return(new Vector2((float)Math.Cos(angle), (float)Math.Sin(angle)));
}
