/// <summary>
/// Loads a player from <paramref name="storedPlayers"/> which matches the identifications given in <paramref name="playerInfo"/>
/// , overriding any player type info the player may have been stored with.
/// </summary>
/// <param name="level">The level the player is loading into.</param>
/// <param name="storedPlayers">Data of the all stored players.</param>
/// <param name="playerInfo">The new info to match or override the stored info with.</param>
/// <param name="insigniaGetter">Provider of graphical identifications for players.</param>
/// <returns>Loader that loads a player from <paramref name="storedPlayers"/> which matches the identifications given in <paramref name="playerInfo"/></returns>
public static IPlayerLoader GetLoaderFromInfo(LevelManager level,
IList <StPlayer> storedPlayers,
PlayerInfo playerInfo,
InsigniaGetter insigniaGetter)
{
return(new Loader(level, storedPlayers, insigniaGetter, playerInfo));
}
public Screen(LevelSettingsScreen proxy, out string errorMessage)
: base(proxy)
{
this.proxy = proxy;
Game.UI.LoadLayoutToElement(MenuUIManager.MenuRoot, Game.ResourceCache, "UI/LevelSettingsScreenLayout.xml");
window = (Window)MenuUIManager.MenuRoot.GetChild("LevelSettingsWindow");
customSettingsWindow = (Window)window.GetChild("CustomSettings", true);
UIElement descriptionTextElement = Game.UI.LoadLayout(Game.PackageManager.GetXmlFile("UI/DescriptionTextLayout.xml", true),
MenuUIManager.MenuRoot.GetDefaultStyle());
descriptionText = (Text)descriptionTextElement.GetChild("DescriptionText");
descriptionText.Value = Level.Description;
descriptionScrollView = (ScrollView)window.GetChild("DescriptionScrollView", true);
descriptionScrollView.ContentElement = descriptionTextElement;
mapImage = (BorderImage)window.GetChild("MapImage");
mapImage.Texture = Level.Thumbnail;
mapImage.ImageRect = new Urho.IntRect(0, 0, Level.Thumbnail.Width, Level.Thumbnail.Height);
playerList = (ListView)window.GetChild("PlayerListView");
((Button)window.GetChild("PlayButton", true)).Released += PlayButtonReleased;
((Button)window.GetChild("BackButton", true)).Released += BackButtonReleased;
InsigniaGetter insigniaGetter = new InsigniaGetter();
PlayerItem.CreateAndAddToList(playerList,
this,
insigniaGetter.MarkUsed(PlayerInsignia.NeutralPlayerInsignia),
0,
PlayerTypeCategory.Neutral);
PlayerItem.CreateAndAddToList(playerList,
this,
insigniaGetter.GetNextUnusedInsignia(),
1,
PlayerTypeCategory.Human);
for (int i = 0; i < Level.MaxNumberOfPlayers - 1; i++)
{
PlayerItem.CreateAndAddToList(playerList, this, insigniaGetter.GetNextUnusedInsignia(), i + 2, PlayerTypeCategory.AI);
}
try {
pluginCustomSettings = Level.LevelLogicType.GetCustomSettings(customSettingsWindow, Game);
errorMessage = null;
}
catch (Exception e) {
string message =
$"Level plugin threw an exception when getting the Custom settings window contents: {e.Message}";
Urho.IO.Log.Write(Urho.LogLevel.Error, message);
pluginCustomSettings = null;
errorMessage = message;
}
}
/// <summary>
/// Loads players and initializes them with the <see cref="players"/> data.
/// </summary>
protected override void LoadPlayers()
{
Progress.SendTextUpdate("Loading players");
//If players == null, we are loading a saved level already in play with set AIs
InsigniaGetter insigniaGetter = new InsigniaGetter();
if (players == PlayerSpecification.LoadFromSavedGame)
{
foreach (var storedPlayer in StoredLevel.Players.Players)
{
LoadPlayer(Player.GetLoader(Level, storedPlayer, insigniaGetter));
}
Level.HumanPlayer = Level.GetPlayer(StoredLevel.Players.HumanPlayerID);
Level.NeutralPlayer = Level.GetPlayer(StoredLevel.Players.NeutralPlayerID);
}
//We are loading new level from a prototype or a level in play with new AIs
else
{
foreach (var playerInfo in players)
{
IPlayerLoader newPlayer =
Player.GetLoaderFromInfo(Level, StoredLevel.Players.Players, playerInfo, insigniaGetter);
LoadPlayer(newPlayer);
if (playerInfo.IsHuman && playerInfo.IsNeutral)
{
throw new
ArgumentException("Corrupted save file, neutral player cannot have the input");
}
else if (playerInfo.IsNeutral)
{
Level.NeutralPlayer = newPlayer.Player;
}
else if (playerInfo.IsHuman)
{
Level.HumanPlayer = newPlayer.Player;
}
}
}
if (Level.HumanPlayer == null)
{
throw new
ArgumentException("Corrupted save file, no human has input");
}
Level.Input = Game.ControllerFactory.CreateGameController(Level.Camera, Level, Level.octree, Level.HumanPlayer);
RegisterPlayersToUI();
//Player selection is disabled by default in play mode, but it can be enabled again
Level.UIManager.DisablePlayerSelection();
Progress.SendUpdate(playersLPartSize, "Loaded players");
}
/// <summary>
/// Loads players, replacing them with placeholder players for editing.
/// </summary>
protected override void LoadPlayers()
{
Progress.SendTextUpdate("Loading players");
int numberOfPlayers = 0;
InsigniaGetter insigniaGetter = new InsigniaGetter();
foreach (var existingPlayer in StoredLevel.Players.Players)
{
numberOfPlayers++;
IPlayerLoader newPlayer = Player.GetLoaderToPlaceholder(Level, existingPlayer, insigniaGetter);
LoadPlayer(newPlayer);
//While editing, even the neutral player can have input
//When starting play, user will set who has input manually anyway
if (newPlayer.Player.ID == StoredLevel.Players.NeutralPlayerID)
{
Level.NeutralPlayer = newPlayer.Player;
}
else if (newPlayer.Player.ID == StoredLevel.Players.HumanPlayerID)
{
Level.HumanPlayer = newPlayer.Player;
Level.Input = Game.ControllerFactory.CreateGameController(Level.Camera, Level, Level.octree, newPlayer.Player);
}
}
//There will always be the neutral player and the player with input (representing the human behind the keyboard)
if (numberOfPlayers < 2)
{
throw new
ArgumentException("Corrupted save file, there was less than 2 players (neutral or human missing)");
}
//Some player always has to have the input
if (Level.Input == null)
{
throw new ArgumentException("Corrupted save file, no player had input");
}
for (; numberOfPlayers < LevelRep.MaxNumberOfPlayers; numberOfPlayers++)
{
CreatePlaceholderPlayer(insigniaGetter.GetNextUnusedInsignia());
}
RegisterPlayersToUI();
Progress.SendUpdate(playersLPartSize, "Loaded players");
}
/// <summary>
/// Creates a loader that loads one of the <paramref name="storedPlayers"/> that corresponds to the data in
/// <paramref name="newInfo"/>.
/// </summary>
/// <param name="level">The level to load the player into.</param>
/// <param name="storedPlayers">The stored data of all players.</param>
/// <param name="insigniaGetter">The source of graphical representations of the players.</param>
/// <param name="newInfo">Info of the player to load.</param>
public Loader(LevelManager level, IList <StPlayer> storedPlayers, InsigniaGetter insigniaGetter, PlayerInfo newInfo)
{
this.level = level;
this.storedPlayer = (from stPlayer in storedPlayers
where stPlayer.InsigniaID == newInfo.Insignia.Index
select stPlayer).FirstOrDefault();
if (storedPlayer == null)
{
throw new
ArgumentException("StoredPlayers did not contain player entry for player with provided playerInfo", nameof(storedPlayers));
}
this.type = newInfo.PlayerType;
this.teamID = newInfo.TeamID;
this.insignia = insigniaGetter.MarkUsed(newInfo.Insignia);
//Clear the stored player plugin data
storedPlayer.UserPlugin = new PluginData();
}
/// <summary>
/// Creates placeholder players in the generated level.
/// </summary>
void CreatePlayers()
{
InsigniaGetter insignias = new InsigniaGetter();
Level.HumanPlayer = CreatePlaceholderPlayer(insignias.GetNextUnusedInsignia());
//human player gets the input and is the first one selected
Level.Input =
Game.ControllerFactory.CreateGameController(Level.Camera, Level, Level.Scene.GetComponent <Octree>(), Level.HumanPlayer);
//Neutral player placeholder
Level.NeutralPlayer = CreatePlaceholderPlayer(insignias.GetUnusedInsignia(insignias.NeutralPlayerIndex));
//AI player placeholders
for (int i = 1; i < LevelRep.MaxNumberOfPlayers; i++)
{
CreatePlaceholderPlayer(insignias.GetNextUnusedInsignia());
}
RegisterPlayersToUI();
}
/// <summary>
/// Creates a loader that loads the given <paramref name="storedPlayer"/> into the <paramref name="level"/>.
/// </summary>
/// <param name="level">The level to load the player into.</param>
/// <param name="storedPlayer">Stored data of the player.</param>
/// <param name="insigniaGetter">The source of graphical representations of the players.</param>
/// <param name="loadPlaceholder">If the player should be loaded as a placeholder player, or if it should be loaded with it's
/// actual type and plugin.</param>
public Loader(LevelManager level, StPlayer storedPlayer, InsigniaGetter insigniaGetter, bool loadPlaceholder)
{
this.level = level;
this.storedPlayer = storedPlayer;
this.insignia = insigniaGetter.GetUnusedInsignia(storedPlayer.InsigniaID);
if (loadPlaceholder)
{
this.type = PlayerType.Placeholder;
teamID = 0;
}
else
{
if (storedPlayer.TypeID == 0)
{
throw new ArgumentException("StoredPlayer had no type", nameof(storedPlayer));
}
type = level.Package.GetPlayerType(storedPlayer.TypeID);
teamID = storedPlayer.TeamID;
}
}
public void SimulatePlayButton(LevelSettingsScreenAction screenAction)
{
InsigniaGetter insigniaGetter = new InsigniaGetter();
insigniaGetter.MarkUsed(PlayerInsignia.NeutralPlayerInsignia);
PlayerType neutralPlayerType = Level.GamePack.GetPlayerType(screenAction.NeutralPlayerTypeName);
Tuple <PlayerType, int, PlayerInsignia> humanPlayer =
Tuple.Create(Level.GamePack.GetPlayerType(screenAction.HumanPlayer.Item1),
screenAction.HumanPlayer.Item2,
insigniaGetter.GetNextUnusedInsignia());
//Has to be last statement in the method, this instance will be released during the execution
proxy.Play(neutralPlayerType,
humanPlayer,
from aiPlayer in screenAction.AIPlayers
select Tuple.Create(Level.GamePack.GetPlayerType(aiPlayer.Item1),
aiPlayer.Item2,
insigniaGetter.GetNextUnusedInsignia()),
pluginCustomSettings);
}
/// <summary>
/// Loads placeholder player with ownership of units and buildings.
/// </summary>
/// <param name="level">The level the placeholder player is loading into.</param>
/// <param name="storedPlayer">The stored data for this placeholder player.</param>
/// <param name="insigniaGetter">Provider of graphical identifications for players.</param>
/// <returns>Loader that loads the placeholder player from the data in the <paramref name="storedPlayer"/>.</returns>
public static IPlayerLoader GetLoaderToPlaceholder(LevelManager level, StPlayer storedPlayer, InsigniaGetter insigniaGetter)
{
return(new Loader(level, storedPlayer, insigniaGetter, true));
}
