void DeactivatedEvent(object sender, EventArgs args)
{
try
{
// The following code saves the game state to a buffer
// so it can be retrieved if context is lost.
// There doesn't seem to be a way to call this soon enough
// before the context is lost, however.
// Currently this is not called, because we do not call
// base.OnDeactivated in our override OnDeactivated method.
Render.UnsetDevice();
if (AutoSaveOnTab && !FocusSaved && World != null)
{
World.SaveInBuffer();
FocusSaved = true;
}
FakeMinimize();
}
catch (Exception e)
{
Program.LogDump(e);
}
}
public bool CellAvailable_1x1(vec2 GridCoord, float TerritoryRange = float.MaxValue)
{
Render.UnsetDevice();
bool Available = false;
var _data = DataGroup.CurrentData.GetData <data>(GridCoord, new vec2(1, 1));
color clr = color.TransparentBlack;
if (_data != null)
{
Available = true;
var here = _data[0];
bool occupied = here.direction > 0;
Available = !occupied;
}
if (Available && TerritoryRange < float.MaxValue)
{
var _dist = DataGroup.DistanceToPlayers.GetData <PlayerTuple>(GridCoord, new vec2(1, 1));
var distance_to = _dist[0];
var distance = GetPlayerVal(distance_to, MyPlayerNumber);
bool in_territory = distance < TerritoryRange;
Available = in_territory;
}
return(Available);
}
void PostPaintUpdate()
{
PaintTiles_UpdateData.Apply(DataGroup.Tiles, DataGroup.CurrentUnits, DataGroup.CurrentData, Output: DataGroup.Temp1);
CoreMath.Swap(ref DataGroup.Temp1, ref DataGroup.CurrentData);
PaintTiles_UpdateUnits.Apply(DataGroup.Tiles, DataGroup.CurrentUnits, Output: DataGroup.Temp1);
CoreMath.Swap(ref DataGroup.Temp1, ref DataGroup.CurrentUnits);
PaintTiles_UpdateTiles.Apply(DataGroup.Tiles, DataGroup.SelectField, Output: DataGroup.Temp1);
CoreMath.Swap(ref DataGroup.Temp1, ref DataGroup.Tiles);
Render.UnsetDevice();
DataGroup.Geo.Clear();
DataGroup.AntiGeo.Clear();
DataGroup.MockTiles.Clear();
DataGroup.OuterGeo.Clear();
DataGroup.TempGeo.Clear();
DataGroup.GeoInfo.Clear();
foreach (var dir in Dir.Vals)
{
DataGroup.Dirward[dir].Clear();
}
UpdateGeo(false);
UpdateGeo(true);
}
private void BlackOverlay(float s)
{
float a = 1920f / 1080f;
var q = new RectangleQuad();
q.SetupVertices(new vec2(-a, -1), new vec2(a, 1), vec2.Zero, vec2.Ones);
q.SetColor(new color(1f, 1f, 1f, 1f));
DrawSolid.Using(new vec4(0, 0, 1, 1), ScreenAspect, new color(0f, 0f, 0f, s));
q.Draw(GameClass.Graphics);
Render.UnsetDevice();
}
public void DoGoldMineCount(PlayerInfo[] PlayerInfo)
{
CountUnitTypeForAllPlayers.Apply(CurrentData, CurrentUnits, UnitType.GoldMine, Output: Multigrid[0]);
var count = (PlayerTuple)MultigridReduce(CountReduce_4x1byte.Apply);
PlayerInfo[1][UnitType.GoldMine].Count = Int(count.PlayerOne);
PlayerInfo[2][UnitType.GoldMine].Count = Int(count.PlayerTwo);
PlayerInfo[3][UnitType.GoldMine].Count = Int(count.PlayerThree);
PlayerInfo[4][UnitType.GoldMine].Count = Int(count.PlayerFour);
Render.UnsetDevice();
}
public void Migrate()
{
Render.UnsetDevice();
//DataGroup.Corpses.Clear();
UnitMigrate.Apply(DataGroup.CurrentUnits, Output: DataGroup.Temp1);
CoreMath.Swap(ref DataGroup.Temp1, ref DataGroup.CurrentUnits);
UnitMigrate.Apply(DataGroup.PreviousUnits, Output: DataGroup.Temp1);
CoreMath.Swap(ref DataGroup.Temp1, ref DataGroup.PreviousUnits);
Render.UnsetDevice();
}
public void LoadStateFromBuffer(byte[] bytes)
{
Render.UnsetDevice();
var uncompressedBytes = bytes.Explode();
var ms = new MemoryStream(uncompressedBytes);
var reader = new BinaryReader(ms);
LoadCurrentState(reader);
reader.Close();
ms.Close();
}
public void LoadFromBuffer()
{
lock (DataGroup)
{
Render.UnsetDevice();
var ms = new MemoryStream(WorldBytes);
var reader = new BinaryReader(ms);
Load(reader);
reader.Close();
ms.Close();
}
}
public void PlaceBuilding(int PlayerNum, int TeamNum, vec2 GridCoord, float Building, ref bool placed)
{
placed = false;
if (!CheckBuildingAvailability(GridCoord, PlayerNum, TeamNum, Building, TempCanPlace))
{
return;
}
Render.UnsetDevice();
Create.PlaceBuilding(DataGroup, GridCoord, Building, Player.Vals[PlayerNum], Team.Vals[TeamNum]);
placed = true;
AddBuildBuildingEffect(GridCoord + vec(1, 1));
}
public void PlaceUnit(ref bool placed, float unit_tpe, vec2 GridCoord, float PlayerValue, float TeamValue, float TerritoryRange = float.MaxValue)
{
placed = false;
Render.UnsetDevice();
if (CellAvailable_1x1(GridCoord, TerritoryRange))
{
try
{
Create.PlaceUnit(DataGroup, GridCoord, unit_tpe, PlayerValue, TeamValue, SetPrevious: MapEditorActive);
placed = true;
CanPlaceItem = false;
}
catch
{
}
}
}
public void CalculateMouseDownOverUi()
{
if (!GameInputEnabled)
{
SteamWrapper.SteamHtml.AllowMouseEvents = true;
MouseOverHud = true;
MouseDownOverUi = true;
return;
}
if (World != null && World.BoxSelecting)
{
SteamWrapper.SteamHtml.AllowMouseEvents = false;
}
else
{
SteamWrapper.SteamHtml.AllowMouseEvents = true;
}
if (!Input.LeftMouseDown || !MouseOverHud)
{
MouseDownOverUi = false;
}
else
{
try
{
Render.UnsetDevice();
MouseDownOverUi = SteamWrapper.SteamHtml.Texture.GetData(Input.CurMousePos).A > 20;
}
catch
{
MouseDownOverUi = false;
}
}
}
public void Startup()
{
Render.UnsetDevice();
int user_count = 0;
for (int p = 1; p <= 4; p++)
{
if (Program.SteamUsers[p - 1] != 0)
{
user_count++;
}
}
if (RemoveComputerDragonLords && user_count > 1)
{
for (int player = 1; player <= 4; player++)
{
if (Program.PlayersSteamUser[player] == 0)
{
RemoveDragonLordData.Apply(DataGroup.CurrentUnits, DataGroup.CurrentData, Player.Vals[player], Output: DataGroup.Temp1);
RemoveDragonLordUnit.Apply(DataGroup.CurrentUnits, DataGroup.CurrentData, Player.Vals[player], Output: DataGroup.Temp2);
CoreMath.Swap(ref DataGroup.Temp1, ref DataGroup.CurrentData);
CoreMath.Swap(ref DataGroup.Temp2, ref DataGroup.CurrentUnits);
RemoveDragonLordData.Apply(DataGroup.PreviousUnits, DataGroup.PreviousData, Player.Vals[player], Output: DataGroup.Temp1);
RemoveDragonLordUnit.Apply(DataGroup.PreviousUnits, DataGroup.PreviousData, Player.Vals[player], Output: DataGroup.Temp2);
CoreMath.Swap(ref DataGroup.Temp1, ref DataGroup.PreviousData);
CoreMath.Swap(ref DataGroup.Temp2, ref DataGroup.PreviousUnits);
}
}
}
// Set datagroup team data.
SetTeams.Apply(DataGroup.CurrentUnits, DataGroup.CurrentData, PlayerTeamVals, Output: DataGroup.Temp1);
CoreMath.Swap(ref DataGroup.Temp1, ref DataGroup.CurrentUnits);
SetTeams.Apply(DataGroup.PreviousUnits, DataGroup.PreviousData, PlayerTeamVals, Output: DataGroup.Temp1);
CoreMath.Swap(ref DataGroup.Temp1, ref DataGroup.PreviousUnits);
DataGroup.DistanceToOtherTeams.Clear();
for (int i = 0; i < 24; i++)
{
DataGroup.UpdateGradient_ToOtherTeams();
}
if (MyPlayerNumber > 0)
{
// Focus camera on a dragon lord.
vec2 pos = DataGroup.DragonLordPos(MyPlayerValue);
CameraPos = GridToWorldCood(pos);
CameraZoom = 80f;
}
else
{
// We're a spectator, so choose netural position.
CameraPos = vec2.Zero;
CameraZoom = 1.45f;
}
Render.UnsetDevice();
}
bool CheckBuildingAvailability(vec2 GridCoord, int PlayerNum, int TeamNum, float BuildingToPlace, bool[] CanPlace)
{
int _w = 3, _h = 3;
Render.UnsetDevice();
bool CanPlaceItem = false;
for (int i = 0; i < _w; i++)
{
for (int j = 0; j < _h; j++)
{
CanPlace[i + j * _w] = false;
}
}
if (BuildingToPlace == UnitType.Barracks && PlayerNum > 0)
{
var _data = DataGroup.CurrentData.GetData <building>(GridCoord, new vec2(_w, _h));
var _dist = DataGroup.DistanceToPlayers.GetData <PlayerTuple>(GridCoord, new vec2(_w, _h));
color clr = color.TransparentBlack;
if (_data != null)
{
CanPlaceItem = true;
for (int i = 0; i < _w; i++)
{
for (int j = 0; j < _h; j++)
{
var building_here = _data[i + j * _w];
var distance_to = _dist[i + j * _w];
var distance = GetPlayerVal(distance_to, PlayerNum);
bool occupied = building_here.direction > 0;
bool in_territory = distance < DrawTerritoryPlayer.TerritoryCutoff;
bool can_place = !occupied && (in_territory || MapEditorActive);
CanPlace[i + j * _w] = can_place;
if (!can_place)
{
CanPlaceItem = false;
}
}
}
}
}
if (BuildingToPlace == UnitType.GoldMine || BuildingToPlace == UnitType.JadeMine)
{
var _data = DataGroup.CurrentUnits.GetData <unit>(GridCoord, new vec2(_w, _h));
var _dist = DataGroup.DistanceToPlayers.GetData <PlayerTuple>(GridCoord, new vec2(_w, _h));
color clr = color.TransparentBlack;
if (_data != null)
{
CanPlaceItem = true;
for (int i = 0; i < _w; i++)
{
for (int j = 0; j < _h; j++)
{
var unit_here = _data[i + j * _w];
var distance_to = _dist[i + j * _w];
var distance = GetPlayerVal(distance_to, PlayerNum);
bool occupied = unit_here.type > 0;
bool is_valid_source = unit_here.team == Team.None && unit_here.type == BuildingToPlace;
bool in_territory = distance < DrawTerritoryPlayer.TerritoryCutoff;
bool can_place = (is_valid_source || MapEditorActive && !occupied) && (in_territory || MapEditorActive);
CanPlace[i + j * _w] = can_place;
if (!can_place)
{
CanPlaceItem = false;
}
}
}
}
}
return(CanPlaceItem);
}
void GameLogic(GameTime gameTime)
{
//Send("setMode", "in-game");
//Send("setScreen", "in-game-ui");
switch (State)
{
case GameState.ToEditor:
NewWorldEditor();
State = GameState.Game;
Send("setMode", "in-game");
Send("setScreen", "editor-ui");
break;
case GameState.ToMap:
Render.StandardRenderSetup();
DrawFullScreen(Assets.ScreenLoading);
if (Program.StartupMap == null)
{
Program.StartupMap = "Beset.m3n";
}
SetScenarioToLoad(Program.StartupMap);
break;
case GameState.TitleScreen:
StartMenuMusicIfNeeded();
AmbientSounds.EndAll();
// No mouse input to web browser.
SteamWrapper.SteamHtml.AllowMouseEvents = false;
Render.StandardRenderSetup();
DrawFullScreen(Assets.ScreenTitle);
if (gameTime.TotalGameTime.Seconds < .005f)
{
break;
}
if (MouseMovedSome)
{
World.DrawArrowCursor();
}
else
{
if (Input.DeltaMousPos.Length() > 40)
{
MouseMovedSome = true;
}
}
if (InputHelper.SomethingPressed())
{
State = GameState.MainMenu;
Send("setMode", "main-menu");
Send("setScreen", "game-menu");
}
break;
case GameState.MainMenu:
StartMenuMusicIfNeeded();
AmbientSounds.EndAll();
if (!InputHelper.SomethingDown())
{
SteamWrapper.SteamHtml.AllowMouseEvents = true;
}
if (_MapLoading != MapLoading)
{
_MapLoading = MapLoading;
SetMapLoading();
}
if (MapLoading && NewMap != null)
{
World = NewMap;
MapLoading = false;
SetMapLoading();
}
Render.StandardRenderSetup();
if (DrawMapPreview && World != null && World.DataGroup != null)
{
Render.UnsetDevice();
try
{
World.DataGroup.UpdateGradient_ToPlayers();
World.DataGroup.UpdateGradient_ToBuildings();
World.DataGroup.UpdateGradient_ToPlayers();
World.DataGroup.UpdateGradient_ToBuildings();
}
catch
{
}
World.UpdateMinimap();
GridHelper.GraphicsDevice.SetRenderTarget(null);
}
Render.StandardRenderSetup();
DrawFullScreen(Assets.ScreenDark);
DrawWebView();
if (DrawMapPreview && World != null && World.DataGroup != null)
{
MapPreviewPos = new vec2(0.76f, 0.32f);
MapPreviewSize = new vec2(.4f, .4f);
bool UseSolidColor = MapLoading || World == BlankWorld;
World.DrawMinimap(MapPreviewPos, MapPreviewSize, ShowCameraBox: false, SolidColor: UseSolidColor);
}
World.DrawArrowCursor();
break;
case GameState.Loading:
FadeOutMenuMusicIfNeeded();
PreGame();
Render.StandardRenderSetup();
DrawFullScreen(Assets.ScreenLoading);
if (ScenarioToLoad != null)
{
Send("setMode", "in-game");
Send("setScreen", "in-game-ui");
World = new World(
GameParams: Program.StartupGameParams,
RemoveComputerDragonLords: Program.RemoveComputerDragonLords);
TimeLoading = 0;
World.LoadPlayerInfo = false;
World.Load(Path.Combine(MapDirectory, ScenarioToLoad));
Program.WorldLoaded = true;
Networking.ToServer(new Message(MessageType.DoneLoading));
ScenarioToLoad = null;
TimeSinceLoad = 0;
DrawFullScreen(Assets.ScreenLoading);
GetNames();
//World.SaveCurrentStateInBuffer();
////var m = new MessageGameState(World.SimStep, World.WorldBytes);
//var m = new Message(MessageType.DoneLoading);
//var s = m.Encode();
//Networking.SendString(new SteamPlayer(SteamCore.PlayerId()), s);
//var t = Networking.ReceiveString();
//var _s = t.Item2;
//Console.WriteLine("!");
}
if (Program.GameStarted)
{
if (Program.Spectate)
{
State = GameState.Game;
}
}
else
{
TimeLoading += DeltaT;
if (TimeLoading > 25)
{
OnFailedToJoinGame();
}
TimeSinceLoad = 0;
break;
}
FadeOutLoading();
break;
case GameState.Game:
StartGameMusicIfNeeded();
CalculateMouseDownOverUi();
DrawGame(gameTime);
if (Program.Spectate && ShouldDrawFading())
{
Render.StandardRenderSetup();
DrawFullScreen(Assets.ScreenLoading);
FadeOutLoading();
}
else
{
DrawWebView();
World.DrawUi();
if (TimeSinceLoad < 1.5f)
{
BlackOverlay(1f - (float)(TimeSinceLoad - 1.3f) / .2f);
}
}
break;
}
}
