/// <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
Resources.init(Content);
//states.push(new GameState(states, Content.Load<SharedContent.LevelModel>("Levels/DemoLevel")));
states.push(new MainMenu(states, Content));
renderer = new Renderer(gdm, Content);
base.Initialize();
}
public void render(Renderer r)
{
r.beginScreen();
Vector2 pos = 50 * Vector2.One;
foreach (PlayerIndex p in controllers)
{
r.renderText(String.Format("Player {0} is connected", p), pos, Color.White, false);
pos += 30 * Vector2.UnitY;
}
r.end();
}
/// <summary>
/// Ask relevant gamestate to draw itself.
/// </summary>
/// <param name="r">Renderer to use</param>
public void render(Renderer r)
{
if (isEmpty()) return;
gamestates[gamestates.Count - 1].render(r);
int next = 2;
while (next < gamestates.Count && gamestates[gamestates.Count - next].renderDown)
{
gamestates[gamestates.Count - next].render(r);
next++;
}
}
/// <summary>
/// Render the amount of time left of current level.
/// </summary>
/// <param name="r">Renderer to use.</param>
private void renderTimeBar(Renderer r)
{
r.beginScreen();
float left = 0.2f * r.Screenspace.Size.X;
float right = 0.8f * r.Screenspace.Size.X;
float top = 0.025f * r.Screenspace.Size.Y;
float bottom = 0.05f * r.Screenspace.Size.Y;
r.renderRect(new Vector2(left, top), new Vector2(right, bottom), Color.White);
float timeleft = (right - left) * this.leveltimeleft / this.leveltime + left;
r.renderRect(new Vector2(left, top), new Vector2(timeleft, bottom), Color.White, true);
}
/// <summary>
/// Render the health bars that belong to objects.
/// </summary>
/// <param name="r">Renderer to use.</param>
/// <param name="objects">Entities with health and maximum health.</param>
private void renderHBar(Renderer r, List<Entity> objects)
{
foreach (Entity e in objects)
{
if (e.CombatStats == null || e.Renderable == null) continue;
float w = e.Renderable.Size.X;
float health = 1.0f * e.CombatStats.Health / e.CombatStats.MaxHealth;
float top = e.Physics.Position.Y - e.Renderable.Size.Y / 2 - 15.0f;
Vector2 topleft = new Vector2(e.Physics.Position.X - w / 2, top);
Vector2 bottomRight = new Vector2(e.Physics.Position.X + w / 2, top + 10);
Vector2 lastOne = new Vector2(topleft.X + health * w, top + 10);
r.renderRect(topleft, bottomRight, Color.Red);
r.renderRect(topleft, lastOne, Color.Green, true);
}
}
/// <summary>
/// Render the ability cooldowns belonging to player.
/// </summary>
/// <param name="r">Renderer to use</param>
/// <param name="player">Player whose cooldowns to render</param>
/// <param name="rpos">Position to render them too</param>
private void renderCooldowns(Renderer r, Entity player, Vector2 rpos)
{
int end = Math.Max(player.Abilities.Count, 4);
for (int a = 1; a != end; ++a)
{
if (player.Abilities[a].Stats == null) continue;
float s = 1 - Math.Max(player.Abilities[a].Stats.CurrentCooldown / player.Abilities[a].Stats.Cooldown, 0);
this.pie.Scale = s * Vector2.One;
this.pie.Tint = abilityColors[a];
r.render(pie, rpos, dirs[a]);
}
for (int i = 0; i != player.Stats.Levels; ++i)
{
float s = (float)Math.Pow(1.1f, i);
this.ring.Scale = s * Vector2.One;
r.render(this.ring, rpos, Vector2.UnitX);
}
this.ring.Scale = Vector2.One;
}
/// <summary>
/// Renders all entities in param to renderer.
/// </summary>
/// <param name="r">Renderer to use.</param>
/// <param name="gameObjects">Entities to render.</param>
private void render(Renderer r, List<Entity> gameObjects)
{
foreach (Entity gameObject in gameObjects)
{
if (gameObject.Renderable == null)
continue;
r.render(gameObject.Renderable, gameObject.Physics);
}
}
/// <summary>
/// Renders this gamestate.
/// </summary>
/// <param name="r">Renderer to use.</param>
public void render(Renderer r)
{
r.begin(view);
r.render(bgRenderable, new Physics(0.0f));
render(r, projectiles);
render(r, hostiles);
renderHBar(r, hostiles);
render(r, nonInteractives);
render(r, players);
renderHBar(r, players);
render(r, gameObjectives);
renderHBar(r, gameObjectives);
render(r, hostileProjectiles);
renderTimeBar(r);
Vector2 rpos = new Vector2(50, r.Screenspace.Size.Y / (players.Count + 1));
foreach (Entity p in this.players)
{
renderCooldowns(r, p, rpos);
rpos.Y += r.Screenspace.Size.Y / (players.Count + 1);
}
int playerNo = 1;
foreach (Entity p in players)
{
Vector2 scorePos = new Vector2(r.Screenspace.Size.X - 215, 50 + playerNo * 25);
r.renderText("Player " + playerNo++ + " kills: " + p.Stats.Kills, scorePos, Color.White);
}
}
public void render(Renderer r)
{
r.beginScreen();
r.renderText("Player X paused the game.", 0.5f * Vector2.One, Color.White, false);
r.end();
}
public void render(Renderer renderer)
{
renderer.render(sprite, position, Velocity);
}
