private void _create()
{
int ms = Math.Max(_parent.LevelHeight, (int)(_parent.LevelWidth / 1.8));
if (ms < 25)
{
_zoom = 3;
}
else if (ms < 45)
{
_zoom = 2;
}
else
{
_zoom = 1;
}
Image = new GBitmap(_parent.LevelWidth * _zoom, _parent.LevelHeight * _zoom);
for (int i = 0; i < _parent.LevelWidth; i++)
{
for (int j = 0; j < _parent.LevelHeight; j++)
{
Set(_parent._getTopElement(i, j));
}
}
}
internal void _drawEntityOnScreen(GEntity t)
{
int sx = t.iX, sy = t.iY;
t.X = 0;
t.Y = 0;
GBitmap g = new GBitmap(GTile.WIDTH, GTile.HEIGHT);
t.Render(g);
t.X = sx;
t.Y = sy;
g.ScreenWidth = (int)(DisplayWidth - sx + _tileOffsetX * GTile.HEIGHT);
g.ScreenHeight = (int)(DisplayHeight - sy + _tileOffsetY * GTile.WIDTH);
if (g.ScreenWidth > GTile.WIDTH)
{
g.ScreenWidth = GTile.WIDTH;
}
if (g.ScreenHeight > GTile.HEIGHT)
{
g.ScreenHeight = GTile.HEIGHT;
}
int x = sx + OffsetX - _tileOffsetX * GTile.WIDTH;
int y = sy + OffsetY - _tileOffsetY * GTile.HEIGHT;
if (g.ScreenHeight < 0 || g.ScreenWidth < 0 || x < OffsetX || y < OffsetY)
{
return;
}
Screen.Blit(g.GetClippedImage(), x, y);
}
public override void Render(GBitmap screen)
{
if (IsFocused)
{
if (_isLastAddition > 0)
{
GFont.Write(screen, "<", 2, X, Y);
GFont.Write(screen, " >", 1, X, Y + GFont.GetLetterDimension(2) / 4);
}
else if (_isLastSubtraction > 0)
{
GFont.Write(screen, "<", 1, X, Y + GFont.GetLetterDimension(2) / 4);
GFont.Write(screen, " >", 2, X, Y);
}
else
{
GFont.Write(screen, "< >", 2, X, Y);
}
}
int xOffset = 0;
if (Value.ToString().Length < 3)
{
xOffset = GFont.GetStringWidth(" ", 2) / 2;
}
if (Value.ToString().Length < 2)
{
xOffset += GFont.GetStringWidth(" ", 2) / 2;
}
GFont.Write(screen, " " + Value, 2, X + xOffset, Y);
}
public override void Render(GBitmap screen)
{
if (Enabled)
{
screen.Blit(Art.GRAPHICS[4 - (int)Team, 18], iX, iY);
}
}
private void RunGame(object Sender, EventArgs e)
{
Screen = new GBitmap(120 * 30, 120 * 30);
GSettings.Load();
this.Input = new InputHandler(this);
AddScreen(new MenuGuiScreen(Input));
AddScreen(new JoinGuiScreen(Input));
AddScreen(new InstructionsGuiScreen(Input));
AddScreen(new CreditsGuiScreen(Input));
AddScreen(new GameGuiScreen(Input));
AddScreen(new GameModeGuiScreen(Input));
AddScreen(new MapEditorSelectScreen(Input));
AddScreen(new CreateMapGuiScreen(Input));
AddScreen(new OpenMapGuiScreen(Input));
AddScreen(new MapEditorGuiScreen(Input, Screen));
AddScreen(new LevelSelectGuiScreen(Input));
AddScreen(new SettingsGuiScreen(Input));
AddScreen(new MapEditorHelpGuiScreen(Input));
AddScreen(new MapWarehouseGuiScreen(Input));
SetCurrentScreen(0);
SetCurrentScreen(11);
SetSize(GSettings.List.ScreenWidth, GSettings.List.ScreenHeight);
}
public override void Render(GBitmap screen)
{
Screen = screen;
if (_showAsker)
{
screen.Fill(255, 0, 0, 0);
_asker.Render(screen);
}
if (_clearScreen || (_minimizedLevel != null && !_minimizedLevelWasRendered))
{
screen.Fill(255, 0, 0, 0);
_mapEditor.Render(screen);
base.Render(screen);
}
if (_minimizedLevel != null && !_minimizedLevelWasRendered)
{
_minimizedLevelWasRendered = true;
screen.FillRect(Color.FromArgb(200, 0, 0, 0), 0, 0, screen.Width, screen.Height);
int cx = (GameComponent.GetScreenWidth() - _minimizedLevel.Width) / 2;
int cy = (GameComponent.GetScreenHeight() - _minimizedLevel.Height) / 2;
screen.Blit(_minimizedLevel, cx, cy);
}
_clearScreen = false;
}
public override void Render(GBitmap screen)
{
if (Enabled)
{
if (HasFocus)
{
screen.DrawRect(Color.White, 2, iX - 2, iY - 2, 32, 32);
screen.FillCircle(Color.FromArgb(100, 255, 255, 255), EntityRange.iX - EntityRange.R / 2 + W / 2, EntityRange.iY - EntityRange.R / 2 + H / 2, EntityRange.R, EntityRange.R);
Color col = Color.Green;
if (Health < MaxHealth * 1 / 3)
{
col = Color.Red;
}
else if (Health < MaxHealth * 2 / 3)
{
col = Color.Yellow;
}
screen.FillRect(col, iX, iY + H + 6, (int)((double)Health / MaxHealth * 30), 4);
}
screen.Blit(Art.GRAPHICS[9, 1], iX, iY);
GFont.Write(screen, "" + EntityRange.Owner, 1, iX - screen.XOffset, iY - screen.YOffset);
}
}
private void Init(string c, GBitmap t)
{
this.Capture = c;
this.Thumbnail = t;
this.Width = Thumbnail.Width;
this.Height = Thumbnail.Height + GFont.GetLetterDimension(1) + 10;
}
public override void Update()
{
if (_showAsker)
{
_asker.Update();
}
if (Input.Esc.Down)
{
_showAsker = true;
}
if (Input.Q.Down && _minimizedLevel == null)
{
_minimizedLevel = _mapEditor.GetFitImage(GameComponent.GetScreenWidth(), GameComponent.GetScreenHeight());
}
else
{
_mapEditor.Update();
if (_minimizedLevel != null)
{
_minimizedLevelWasRendered = false;
_clearScreen = true;
}
}
if (!Input.Q.Down)
{
_minimizedLevel = null;
}
}
public static void WriteCenterLine(GBitmap screen, string message, int size, int yo)
{
int w = GetStringWidth(message, size);
int h = GetLetterDimension(size);
Write(screen, message, size, screen.ScreenWidth / 2 - w / 2, screen.ScreenHeight / 2 - h + yo);
}
public override void Render(GBitmap screen)
{
if (Enabled)
{
if (HasFocus)
{
screen.DrawRect(Color.White, 1, iX, iY, 30, 30);
screen.FillCircle(Color.FromArgb(100, 255, 255, 255), iX - SRange / 2 + W / 2, iY - SRange / 2 + H / 2, SRange, SRange);
Color col = Color.Green;
if (Health < MaxHealth * 1 / 3)
{
col = Color.Red;
}
else if (Health < MaxHealth * 2 / 3)
{
col = Color.Yellow;
}
screen.FillRect(col, iX, iY + H + 6, (int)((double)Health / MaxHealth * 30), 4);
}
Art.GRAPHICS[0, 15].ChangeHue(UnitColors.GetUnitHue(Owner));
screen.Blit(Art.Rotate(Art.GRAPHICS[0, 15], (int)Direction * 90), iX, iY);
}
}
public void RenderAnimation(GBitmap screen)
{
if (CurrentAnimState <= AnimationStates)
{
screen.Blit(Art.GRAPHICS[ImgXStart + CurrentAnimState, ImgYStart], iX, iY);
}
}
private void RenderPlayer(GBitmap screen, ref int yo, string name, int kills, int deaths, int col1, int col2, int col3)
{
GFont.Write(screen, name, 1, col1, yo);
GFont.Write(screen, "" + kills, 1, col2, yo);
GFont.Write(screen, "" + deaths, 1, col3, yo);
yo += 10;
}
public void Render(GBitmap Screen)
{
_clear(Screen);
int rx = (X - _parent._tileOffsetX) * GTile.WIDTH + _parent.OffsetX + 1;
int ry = (Y - _parent._tileOffsetY) * GTile.HEIGHT + _parent.OffsetY + 1;
Screen.DrawRect(_rectColor, 2, rx, ry, (GTile.WIDTH * Width) - 2, (GTile.HEIGHT * Height) - 2);
}
public override void Render(GBitmap screen)
{
screen.Fill(175, 0, 0, 0);
Modes mode = GameLevel.GetMode();
int colWidth = 195;
int nameColSx = screen.ScreenWidth / 2 - colWidth / 2;
int killsColSx = nameColSx + 100;
int deathsColSx = killsColSx + 50;
int yo = 20;
GFont.WriteXCenter(screen, "statistics", 2, yo);
yo += 40;
if (mode == Modes.Deathmatch)
{
RenderColTitle(screen, ref yo, nameColSx, killsColSx, deathsColSx);
foreach (Player player in Players)
{
RenderPlayer(screen, ref yo, player.Name, player.Kills, player.Deaths, nameColSx, killsColSx, deathsColSx);
}
}
else
{
int xo = -(screen.ScreenWidth - colWidth) / 4 - 15;
int col2Yo = yo;
GFont.Write(screen, "team of blu", 1, nameColSx + xo, yo);
yo += 20;
RenderColTitle(screen, ref yo, nameColSx + xo, killsColSx + xo, deathsColSx + xo);
foreach (Player player in Players)
{
if (player.Team == Teams.Blu)
{
RenderPlayer(screen, ref yo, player.Name, player.Kills, player.Deaths, nameColSx + xo, killsColSx + xo, deathsColSx + xo);
}
}
xo = -1 * xo;
yo = col2Yo;
GFont.Write(screen, "team of red", 1, nameColSx + xo, yo);
yo += 20;
RenderColTitle(screen, ref yo, nameColSx + xo, killsColSx + xo, deathsColSx + xo);
foreach (Player player in Players)
{
if (player.Team == Teams.Red)
{
RenderPlayer(screen, ref yo, player.Name, player.Kills, player.Deaths, nameColSx + xo, killsColSx + xo, deathsColSx + xo);
}
}
}
}
public override void Render(GBitmap screen)
{
if (!AskIsOn)
{
screen.Fill(175, 0, 0, 0);
Menu.Render(screen);
}
base.Render(screen);
}
private void RenderGameGui(GBitmap screen)
{
screen.FillRect(Color.Black, screen.XOffset, screen.ScreenHeight - 45 + screen.YOffset, screen.ScreenWidth, 45);
screen.Blit(Art.GRAPHICS[1, 18], 10 + screen.XOffset, screen.ScreenHeight - 30 + screen.YOffset);
string HSign = "" + GameLevel.CurrentPlayer.Health;
GFont.Write(screen, HSign, 1, new Point(31, screen.ScreenHeight - 26));
int ax = 31 + GFont.GetStringWidth(HSign, 1) + 10;
string ASign = "" + GameLevel.CurrentPlayer.Ammunition;
screen.Blit(Art.GRAPHICS[0, 18], ax + screen.XOffset, screen.ScreenHeight - 30 + screen.YOffset);
GFont.Write(screen, ASign, 1, ax + 16 + 5, screen.ScreenHeight - 26);
int xPaddingBonuses = 5;
int xPaddingInventory = 22 - 1;
int w = 24;
int h = 4;
int xBonuses = screen.ScreenWidth - w - 13;
int xInventory = screen.ScreenWidth / 2 - ((w + xPaddingInventory) * GameLevel.CurrentPlayer.Inventory.Count) / 2;
for (int i = GameLevel.CurrentPlayer.PickedBonuses.Count - 1; i >= 0; --i)
{
Bonus B = GameLevel.CurrentPlayer.PickedBonuses[i];
screen.Blit(Art.GRAPHICS[B.ImageIndex, 19], xBonuses - 3 + screen.XOffset, screen.ScreenHeight - 29 - 8 + screen.YOffset);
if (B.Active)
{
int bw = (w - 2) - (int)((double)B.GetLifeSpan() / B.GetDuration() * (w - 2));
screen.FillRect(Color.Green, xBonuses + 1 + screen.XOffset, screen.ScreenHeight - 9 - h - 1 + screen.YOffset, bw, h);
}
xBonuses -= w + xPaddingBonuses;
}
foreach (InvItem I in GameLevel.CurrentPlayer.Inventory)
{
if (I.IsSelected())
{
screen.FillRect(Color.FromArgb(200, 113, 123, 140), xInventory - 7 - 5 * 2 + screen.XOffset, screen.ScreenHeight - 29 - 8 - 7 + screen.YOffset, 45, 44);
}
GFont.Write(screen, "" + I.ActivationKey, 1, new Point(xInventory - 7 - 5, screen.ScreenHeight - 29 + 9 - 5));
screen.Blit(Art.GRAPHICS[I.ImageIconIndex, 19], xInventory - 3 + screen.XOffset, screen.ScreenHeight - 29 - 8 + screen.YOffset);
if (I.Amount > 1)
{
string AmSign = "" + I.Amount;
GFont.Write(screen, AmSign, 1, new Point(xInventory + w / 2 - GFont.GetStringWidth(AmSign, 1) / 2, screen.ScreenHeight - 7 - 2));
}
xInventory += w + xPaddingInventory;
}
}
public override void Render(GBitmap screen)
{
if (CurrentAnimState <= AnimationStates)
{
Directions Dir = GEntity.GetOppositeDirection(Direction);
int[] Offsets = GetSparkOffsets(Dir);
screen.Blit(Art.Rotate(Art.GRAPHICS[ImgXStart + CurrentAnimState, ImgYStart], (int)Dir * 90), iX + Offsets[0], iY + Offsets[1]);
}
}
public override void Render(GBitmap screen)
{
int BulletType = 1;
if (AP)
{
BulletType = 0;
}
screen.Blit(Art.GRAPHICS[(int)Direction, BulletType], iX, iY);
}
public MapEditorGuiScreen(InputHandler Input, GBitmap screen)
: base(Input, false, false, false, false)
{
_asker = new Asker(Input, "Save map before exit?", new string[] { "yes", "no", "cencel" });
_asker.SetCallback(0, _askerYes);
_asker.SetCallback(1, _askerNo);
_asker.SetCallback(2, _askerCencel);
Screen = screen;
NonClearableScreen = true;
}
public static void Write(GBitmap screen, string message, int size, int x, int y)
{
message = message.ToLower();
int currentLetterSize = GetLetterDimension(size);
for (int i = 0; i < message.Length; ++i)
{
int Letter = Alphabet.IndexOf(message[i]);
screen.Blit(_getLetterBitmap(Letter, size), x + i * currentLetterSize + screen.XOffset, y + screen.YOffset);
}
}
public override void Render(GBitmap screen)
{
int x = X + InsideMargin;
for (int i = 0; i < Items.Count; i++)
{
if (i == SelectedItem)
{
screen.DrawRect(Color.White, 4, x - 2, Y + InsideMargin - 2, Items[i].Width + 4, Items[i].Height + 4);
}
screen.Blit(Items[i], x, Y + InsideMargin);
x += Items[i].Width + InsideMargin;
}
}
public override void Render(GBitmap screen)
{
for (int i = 0; i < Items.Length; ++i)
{
string Output = Items[i];
if (i == Selected)
{
Output = "> " + Output + " <";
}
GFont.WriteXCenter(screen, Output, FontSize, StartY + i * 20);
}
}
private void RenderColTitle(GBitmap screen, ref int yo, int col1, int col2, int col3)
{
string nameSign = "name";
GFont.Write(screen, nameSign, 1, col1, yo);
string killsSign = "kills";
GFont.Write(screen, killsSign, 1, col2, yo);
string deathsSign = "deaths";
GFont.Write(screen, deathsSign, 1, col3, yo);
yo += 20;
}
public override void Render(GBitmap screen)
{
int XStart = 0;
if (Type == DispenseBeamType.Heal)
{
XStart = 11;
}
if (Type == DispenseBeamType.Ammunition)
{
XStart = 14;
}
screen.Blit(Art.GRAPHICS[XStart + BeamState, 1], iX, iY);
}
internal void _createBackground()
{
_background = new GBitmap(LevelWidth * GTile.WIDTH, LevelHeight * GTile.HEIGHT);
foreach (GEntity item in Tiles)
{
item.Render(_background);
}
foreach (GEntity item in Entities)
{
if (item != null)
{
item.Render(_background);
}
}
}
private void GenerateBackground()
{
Background = new GBitmap(CurrentLevelWidth * GTile.WIDTH, CurrentLevelHeight * GTile.HEIGHT);
foreach (GTile Tile in Tiles)
{
if (Tile.IsStatic)
{
Tile.Render(Background);
}
}
foreach (GEntity Entity in Entities)
{
if (Entity.IsStatic)
{
Entity.Render(Background);
}
}
}
public override void Render(GBitmap screen)
{
if (Enabled)
{
if (HasFocus)
{
screen.DrawRect(Color.White, 1, iX, iY, 30, 30);
screen.FillCircle(Color.FromArgb(100, 255, 255, 255), ExplosionRange.iX - R / 2 + WIDTH / 2, ExplosionRange.iY - R / 2 + HEIGHT / 2, ExplosionRange.W, ExplosionRange.H);
}
screen.Blit(Art.GRAPHICS[7, 1], iX, iY);
if (Countdown)
{
GFont.Write(screen, "" + (EXPL_DELAY - SkippedExplTicks), 1, iX + screen.XOffset, iY + screen.YOffset);
}
}
}
private void _clear(GBitmap Screen)
{
for (int i = X - 1; i < X + Width + 1; i++)
{
for (int j = Y - 1; j < Y + Height + 1; j++)
{
var t = _parent._getTopElement(i, j);
if (t != null)
{
if (typeof(Flag) == t.GetType() || typeof(Spawner) == t.GetType())
{
_parent._drawEntityOnScreen(_parent._getTile(i, j));
}
_parent._drawEntityOnScreen(t);
}
}
}
}
public override void Render(GBitmap screen)
{
int yo = Y;
foreach (string line in Lines)
{
if (X > 0)
{
GFont.Write(screen, line, 1, X, yo);
}
else
{
GFont.WriteXCenter(screen, line, 1, yo);
}
yo += 15;
}
}
