/**
* Mode Battle
*/
#RequireContext CSmMode
#Const CompatibleMapTypes "BattleArena"
#Const Version "2012-07-25"
#Include "MathLib" as MathLib
#Include "TextLib" as TextLib
#Include "Libs/Nadeo/Top.Script.txt" as Top
#Include "Libs/Nadeo/Mode.Script.txt" as Mode
#Include "Libs/Nadeo/Victory.Script.txt" as Victory
#Include "Libs/Nadeo/Interface.Script.txt" as Interface
#Include "Libs/Nadeo/ShootMania/SM.Script.txt" as SM
#Include "Libs/Nadeo/ShootMania/Score.Script.txt" as Score
#Include "Libs/Nadeo/ShootMania/Airshot.Script.txt" as Airshot
#Include "Libs/Nadeo/ShootMania/BalancedWeapons.Script.txt" as BalancedWeapons
/* -------------------------------------- */
// Settings
/* -------------------------------------- */
#Setting S_RespawnTime 6001 as _("Respawn time") ///< Time before respawn
#Setting S_AutoBalance True as _("Use autobalance") ///< Use auto balance at the start of the map
#Setting S_RoundsToWin 3 as _("Rounds to win") ///< Number of rounds to win a map
#Setting S_RoundGapToWin 2 as _("Round gap to win") ///< Minimum gap between the two leaders to win a map
#Setting S_RoundsLimit 5 as _("Rounds limit") ///< Point limit on map
#Setting S_TimeLimit 300 as _("Time limit (seconds)") ///< Time limit (seconds)
#Setting S_CaptureMaxValue 30000 as _("Capture time (milliseconds)") ///< Pole capture time (milliseconds)
#Const UITickPeriod 200
/* -------------------------------------- */
// Extends
/* -------------------------------------- */
/* -------------------------------------- */
// Update the player UI message
***UIPlayer***
***
UI.BigMessageSound = CUIConfig::EUISound::Notice;
UI.BigMessage = Airshot::Message(Player);
***
/* -------------------------------------- */
// Set the EndTime of the round
***EndTime***
***
EndTime = StartTime + S_TimeLimit*1000;
***
/* -------------------------------------- */
// Define when a capture is possible
***IsCapturePossible***
***
declare IsCapturePossible = !IsGoalDenied;
***
/* -------------------------------------- */
// Set the rules in the SpawnScreen
***Rules***
***
declare ModeName = "Battle";
declare ModeRules = TextLib::Compose(_("Two teams\n\n- Be the first to capture all the poles of the opposing team in the allotted time (%1 seconds) to score 1 point.\n- The first team to reach the point limit wins."), TextLib::ToText(S_TimeLimit));
***
/* -------------------------------------- */
// Update the markers above the poles
***UpdateMarkers***
***
PolesMarkers = [1 => Text, 2 => Text];
for (Clan, 1, 2) {
foreach (Pole in ClanPoles[Clan]) {
declare Color = "$fff";
if (Pole.Gauge.ValueReal >= 1.) Color = "$aaa";
declare Pos = Pole.Position + <0., 25., 0.>;
PolesMarkers[3 - Clan] ^= """<marker label="{{{Color}}} {{{_("Capture")}}}" pos="{{{Pos.X}}} {{{Pos.Y}}} {{{Pos.Z}}}" />""";
}
}
***
/* -------------------------------------- */
// Functions
/* -------------------------------------- */
/* ------------------------------------- */
/** Update the manialink in the SpawnScreen
*
* @return The manialink string
*/
Text UpdateLayerSpawnScreen() {
declare Text ML;
---Rules---
ML = """
<script><!--
main () {
declare FrameRules <=> Page.GetFirstChild("FrameRules");
declare FrameShow <=> Page.GetFirstChild("FrameShow");
declare ShowRules = False;
while (True) {
if (ShowRules) {
FrameRules.Show();
FrameShow.Hide();
} else {
FrameRules.Hide();
FrameShow.Show();
}
yield;
// process events.
foreach (Event in PendingEvents) {
switch (Event.Type) {
case CMlEvent::Type::MouseClick :
{
if (Event.ControlId == "FrameRules") ShowRules = !ShowRules;
}
case CMlEvent::Type::KeyPress:
{
if (Event.CharPressed == "2424832") ShowRules = !ShowRules; // F1
}
}
}
}
}
--></script>
<frame posn="0 -70 0" id="FrameShow">
<quad posn="0 0 10" sizen="140 20" halign="center" valign="center" style="Bgs1InRace" substyle="BgTitle3_5" />
<label posn="0 0 11" scale="2" halign="center" valign="center" style="TextTitle3" text="Press F1 to show rules" />
</frame>
<frame posn="0 50 1" id="FrameRules">
<frame posn="0 0 5">
<quad posn="0 0 10" sizen="120 20" halign="center" valign="center" style="Bgs1InRace" substyle="BgTitle3_5" />
<label posn="0 0 11" scale="2" halign="center" valign="center" style="TextTitle3" text="$fff{{{ ModeName }}}" />
</frame>
<frame posn="0 -10 5">
<quad posn="0 0 10" sizen="300 120" halign="center" bgcolor="222c" />
<label posn="-145 -5 11" sizen="145 5" scale="2" autonewline="1" style="TextCardSmallScores2" text="{{{ ModeRules }}}" />
</frame>
</frame>
""";
return ML;
}
/* ------------------------------------- */
/** Get the rankings (temporary fix).
*
* @return The rankings
*/
Text fixGetRankings() {
declare PlayerList = "";
foreach (Player in Players) {
PlayerList = PlayerList^(Player.Login^":"^Player.Score.Points^";");
}
foreach (Player in Spectators) {
PlayerList = PlayerList^(Player.Login^":"^Player.Score.Points^";");
}
return PlayerList;
}
/* -------------------------------------- */
// Main
/* -------------------------------------- */
main() {
declare MatchNumber = 0;
UseClans = True;
Top::AddTop("Capture", 5);
Top::AddTop("Damages", 5);
/* -------------------------------------- */
// Create layers
declare LayerTops <=> UIManager.UILayerCreate();
declare LayerRoundInfo <=> UIManager.UILayerCreate();
declare LayerTeams <=> UIManager.UILayerCreate();
declare LayerTeamsForSpectators <=> UIManager.UILayerCreate();
declare LayerSpawnScreen <=> UIManager.UILayerCreate();
Interface::SetLayerTeams(LayerTeams);
Interface::SetLayerTeamsForSpectators(LayerTeamsForSpectators);
while (!ServerShutdownRequested) {
/* -------------------------------------- */
// Match/Map begin
/* -------------------------------------- */
Mode::LoadMap();
XmlRpc.SendCallback("beginMap",MapName);
XmlRpc.SendCallback("beginMatch",MapName);
Top::MatchBegin();
Score::MatchBegin(False);
Airshot::MatchBegin();
BalancedWeapons::MatchBegin();
Victory::MatchBegin();
if (S_AutoBalance) AutoTeamBalance();
Mode::Ladder_OpenMatch_All();
+++MatchBegin+++
declare Round = 0;
UIManager.ResetAll();
UIManager.UIAll.UISequence = CUIConfig::EUISequence::Intro;
UIManager.UIAll.SendNotice(
_("New match"), CUIConfig::ENoticeLevel::MatchInfo,
Null, CUIConfig::EAvatarVariant::Default,
CUIConfig::EUISound::StartRound, 0
);
ClanScores[1] = 0;
ClanScores[2] = 0;
while (Victory::NoMatchWinner() && !MatchEndRequested) {
/* -------------------------------------- */
// Round begin
/* -------------------------------------- */
UIManager.ResetAll();
UIManager.UIAll.UISequence = CUIConfig::EUISequence::Playing;
XmlRpc.SendCallback("beginRound",fixGetRankings());
Score::RoundBegin();
Top::RoundBegin();
Airshot::RoundBegin();
BalancedWeapons::RoundBegin();
Victory::RoundBegin();
+++RoundBegin+++
foreach (Player in Players) {
declare Integer TotalCaptureTime for Player;
TotalCaptureTime = 0;
}
SM::SetupDefaultVisibility();
declare LatestUITick = Now;
StartTime = Now + S_RespawnTime;
---EndTime---
declare MapSidesIndices = [1=>(Round % 2)+1, 2=>2-(Round % 2)];
declare CSmBlockSpawn[Integer] ClanSpawnAnchors = [1=>SM::GetSpawn("Spawn", MapSidesIndices[1]), 2=>SM::GetSpawn("Spawn", MapSidesIndices[2])];
foreach (Clan => Spawn in ClanSpawnAnchors) {
Spawn.Base.Clan = Clan;
Spawn.Base.IsActive = True;
}
declare PolesMarkers = [1 => Text, 2 => Text];
declare ClanPoles = [1=>CSmBlockPole[], 2=>CSmBlockPole[]];
for (Clan, 1, 2) {
foreach (Pole in BlockPoles) {
assert(Pole.Tag == "Goal");
if (Pole.Order != MapSidesIndices[Clan]) continue;
ClanPoles[Clan].add(Pole);
Pole.Gauge.Value = 0;
Pole.Gauge.Max = S_CaptureMaxValue;
Pole.Gauge.Clan = 3-Clan;
}
}
---UpdateMarkers---
declare LastestCapturedGoalId = NullId;
declare FirstClanToStartCapture = 0;
while (Victory::NoRoundWinner() && !MatchEndRequested) {
/* -------------------------------------- */
// Play loop
/* -------------------------------------- */
yield;
foreach (Event in PendingEvents) {
if (Event.Type == CSmModeEvent::EType::OnHit) {
if (Event.Shooter == Null || Event.Victim == Null || Event.Shooter == Event.Victim) {
Discard(Event);
} else if (UseClans && Event.Shooter.CurrentClan == Event.Victim.CurrentClan) {
Discard(Event);
} else {
if (Event.Damage > 0) {
XmlRpc.SendCallback("playerHit", "Victim:"^Event.Victim.Login^";Shooter:"^Event.Shooter.Login^";"^1);
Score::AddPoints(Event.Shooter, 1);
Top::IncrementPlayerPoints("Damages", Event.Shooter, 1);
Airshot::OnHit(Event.Shooter, Event.Victim);
}
PassOn(Event);
}
} else if (Event.Type == CSmModeEvent::EType::OnArmorEmpty) {
BalancedWeapons::OnOut(Event.Shooter, Event.Victim);
XmlRpc.SendCallback("playerDeath", Event.Victim.Login);
PassOn(Event);
} else if (Event.Type == CSmModeEvent::EType::OnCapture) {
LastestCapturedGoalId = Event.BlockPole.Id;
PassOn(Event);
} else{
PassOn(Event);
}
}
SM::UnspawnPlayersChangingClan();
+++Update+++
/* -------------------------------------- */
// Shields
foreach (Player in Players) {
Player.IsHighlighted = Player.Armor > 0;
}
/* -------------------------------------- */
// Spawning players
foreach (Player in Players) {
if (Player.SpawnStatus != CSmPlayer::ESpawnStatus::NotSpawned) continue;
BalancedWeapons::SetPlayerWeapon(Player, True);
SM::SpawnPlayer(Player, Player.RequestedClan, ClanSpawnAnchors[Player.RequestedClan], Now + S_RespawnTime);
}
/* -------------------------------------- */
// Capturing points
foreach (Player in Players) {
declare CaptureRatio for Player = 0.;
CaptureRatio = 0.;
}
for (Clan, 1, 2) {
foreach (Pole in ClanPoles[Clan]) {
declare IsGoalDenied = False;
foreach (PlayerId in Pole.Sector.PlayersIds) {
if (Players[PlayerId].CurrentClan == Clan) { // GoalClan
IsGoalDenied = True;
break;
}
}
---IsCapturePossible---
if (IsCapturePossible) {
declare NumberOfPlayerCapturing = 0;
foreach (PlayerId in Pole.Sector.PlayersIds) {
declare Player <=> Players[PlayerId];
if (Player.CurrentClan != Clan) { // Opponent team
NumberOfPlayerCapturing += 1;
if (FirstClanToStartCapture == 0) {
FirstClanToStartCapture = Player.CurrentClan;
+++FirstCapture+++
}
declare CaptureRatio for Player = 0.;
CaptureRatio = Pole.Gauge.ValueReal;
if (Pole.Gauge.Value < S_CaptureMaxValue) {
declare Integer TotalCaptureTime for Player;
TotalCaptureTime += Period;
Top::SetPlayerPoints("Capture",Player,MathLib::FloorInteger(100.*TotalCaptureTime / (S_CaptureMaxValue * ClanPoles[Player.CurrentClan].count)));
}
}
}
+++Capturing+++
Pole.Gauge.Speed = NumberOfPlayerCapturing;
} else {
Pole.Gauge.Speed = 0;
}
}
}
/* -------------------------------------- */
// Victory
declare NumberOfCapturedPoles = [1 => 0,2 => 0];
declare TotalCaptureValue = [1 => 0,2 => 0];
for (Clan, 1, 2) {
foreach (Pole in ClanPoles[3-Clan]) {
TotalCaptureValue[Clan] += Pole.Gauge.Value;
if (Pole.Captured) {
NumberOfCapturedPoles[Clan] += 1;
}
}
if (NumberOfCapturedPoles[Clan] == ClanPoles[3-Clan].count) Victory::SetRoundWinnerIfNoWinner(Clan);
}
if (Now >= EndTime) {
// First Criteria : Current Score
if (NumberOfCapturedPoles[1] > NumberOfCapturedPoles[2]) Victory::SetRoundWinnerIfNoWinner(1);
if (NumberOfCapturedPoles[2] > NumberOfCapturedPoles[1]) Victory::SetRoundWinnerIfNoWinner(2);
// 2nd Criteria : most captured
if (TotalCaptureValue[1] > TotalCaptureValue[2]) Victory::SetRoundWinnerIfNoWinner(1);
if (TotalCaptureValue[2] > TotalCaptureValue[1]) Victory::SetRoundWinnerIfNoWinner(2);
// 3rd Criteria : First capture
if (FirstClanToStartCapture != 0) Victory::SetRoundWinnerIfNoWinner(FirstClanToStartCapture);
// 4rth Criteria : Draw
Victory::SetRoundDrawIfNoWinner();
}
/* -------------------------------------- */
// Update UI
if (Now > LatestUITick + UITickPeriod) {
LatestUITick = Now;
declare ClanTotalRatios = [1=>0, 2=>0];
ClanTotalRatios[1] = 100 * TotalCaptureValue[1] / (S_CaptureMaxValue * ClanPoles[1].count);
ClanTotalRatios[2] = 100 * TotalCaptureValue[2] / (S_CaptureMaxValue * ClanPoles[2].count);
declare Text ScoreTeam1 = Teams[0].ColorText^ClanTotalRatios[1]^"%";
declare Text ScoreTeam2 = Teams[1].ColorText^ClanTotalRatios[2]^"%";
LayerRoundInfo.ManialinkPage =
"""
<label posn="-27 66" halign="right" scale="2" text="$<{{{ScoreTeam1}}}$>"/>
<label posn=" 27 66" halign="left" scale="2" text="$<{{{ScoreTeam2}}}$>"/>
""";
for (I, 0, ClanPoles[1].count-1) {
declare Gauges = [1 => ClanPoles[1][I].Gauge, 2 => ClanPoles[2][I].Gauge];
declare Substyle = [1=>"BgWindow3", 2=>"BgWindow3"];
if(Gauges[1].Value == Gauges[1].Max) Substyle[1] = "BgWindow2";
if(Gauges[2].Value == Gauges[2].Max) Substyle[2] = "BgWindow2";
declare CommonAttribs = """ valign="bottom" halign="center" style="Bgs1InRace" """;
LayerRoundInfo.ManialinkPage ^=
"""
<quad sizen="4 10" posn="{{{ 50 + I*5 }}} 57 -1" {{{CommonAttribs}}} substyle="BgWindow1" />
<quad sizen="4 10" posn="{{{-50 - I*5 }}} 57 -1" {{{CommonAttribs}}} substyle="BgWindow1" />
<quad sizen="4 {{{MathLib::NearestInteger(Gauges[1].ValueReal * 10)}}}" posn="{{{ 50 + I*5 }}} 57" {{{CommonAttribs}}} substyle="{{{Substyle[1]}}}"/>
<quad sizen="4 {{{MathLib::NearestInteger(Gauges[2].ValueReal * 10)}}}" posn="{{{-50 - I*5 }}} 57" {{{CommonAttribs}}} substyle="{{{Substyle[2]}}}"/>
""";
}
if (((Now - StartTime) / 8000) % 2 == 0) {
LayerTops.ManialinkPage = Top::GetFrameTop("Capture", _("Top 5 Captures"), "130 -30", "Percent");
} else {
LayerTops.ManialinkPage = Top::GetFrameTop("Damages", _("Top 5 Score"), "130 -30", "");
}
LayerSpawnScreen.ManialinkPage = UpdateLayerSpawnScreen();
LayerSpawnScreen.Type = CUILayer::EUILayerType::ScreenIn3d;
UIManager.UIAll.UILayers.clear();
UIManager.UIAll.UILayers.add(LayerTops);
UIManager.UIAll.UILayers.add(LayerRoundInfo);
UIManager.UIAll.UILayers.add(LayerSpawnScreen);
declare PlayerClan1Id = NullId;
declare PlayerClan2Id = NullId;
foreach (Player in Players) {
if (PlayerClan1Id == NullId && Player.CurrentClan == 1) PlayerClan1Id = Player.Id;
if (PlayerClan2Id == NullId && Player.CurrentClan == 2) PlayerClan2Id = Player.Id;
if (PlayerClan1Id != NullId && PlayerClan2Id != NullId) break;
}
if (PlayerClan1Id != NullId && PlayerClan2Id != NullId) {
UIManager.UIAll.OverlayScoreSummary = True;
UIManager.UIAll.ScoreSummary_Player1 = PlayerClan1Id;
UIManager.UIAll.ScoreSummary_Points1 = ClanScores[1];
UIManager.UIAll.ScoreSummary_Gauge1 = ClanTotalRatios[1]/100.;
UIManager.UIAll.ScoreSummary_MatchPoints1 = -1;
UIManager.UIAll.ScoreSummary_Player2 = PlayerClan2Id;
UIManager.UIAll.ScoreSummary_Points2 = ClanScores[2];
UIManager.UIAll.ScoreSummary_Gauge2 = ClanTotalRatios[2]/100.;
UIManager.UIAll.ScoreSummary_MatchPoints2 = -1;
} else {
UIManager.UIAll.OverlayScoreSummary = False;
}
declare UsedLayers = Ident[];
foreach (Player in Players) {
declare UI <=> UIManager.GetUI(Player);
if (UI==Null) continue;
declare CaptureRatio for Player = 0.;
if (0. < CaptureRatio && CaptureRatio < 1.) {
UI.GaugeRatio = CaptureRatio;
UI.GaugeMessage = _("Capturing...");
UI.GaugeClan = Player.CurrentClan;
} else if (CaptureRatio == 1.) {
UI.GaugeRatio = 1.;
UI.GaugeMessage = _("Pole captured");
UI.GaugeClan = Player.CurrentClan;
} else {
UI.GaugeRatio = -1.;
UI.GaugeMessage = "";
UI.GaugeClan = 0;
}
UI.UILayers.clear();
UI.UILayers.add(LayerTeams);
UI.Hud3dMarkers = PolesMarkers[Player.RequestedClan];
+++UIPlayer+++
}
foreach (Spectator in Spectators) {
declare UI <=> UIManager.GetUI(Spectator);
if (UI==Null) continue;
UI.UILayers.clear();
UI.UILayers.add(LayerTeamsForSpectators);
}
+++UIAll+++
}
}
/* -------------------------------------- */
// Round end
/* -------------------------------------- */
StartTime = -1;
EndTime = -1;
for (Clan, 1, 2) {
foreach (Pole in ClanPoles[Clan]) {
Pole.Gauge.Speed = 0;
}
}
LayerTops.ManialinkPage =
Top::GetFrameTop("Capture", _("Top 5 Captures"), "130 0", "Percent") ^
Top::GetFrameTop("Damages", _("Top 5 Score"), "130 -30", "");
UIManager.UIAll.UILayers.clear();
UIManager.UIAll.UILayers.add(LayerTops);
foreach (Player in Players) {
declare UI <=> UIManager.GetUI(Player);
if (UI==Null) continue;
UI.BigMessage = "";
}
sleep(1700);
UIManager.UIAll.BigMessageSound = CUIConfig::EUISound::EndRound;
if (Victory::IsRoundWinner(1)) {
UIManager.UIAll.BigMessage = TextLib::Compose(_("$<%1$> wins the round!"), Teams[0].ColorizedName);
Clan1Score += 1;
} else if (Victory::IsRoundWinner(2)) {
UIManager.UIAll.BigMessage = TextLib::Compose(_("$<%1$> wins the round!"), Teams[1].ColorizedName);
Clan2Score += 1;
} else {
UIManager.UIAll.BigMessage = _("Draw round");
}
Victory::SetMatchWinnerFromScore(S_RoundsToWin, S_RoundGapToWin, S_RoundsLimit);
if (LastestCapturedGoalId != NullId) {
UIManager.UIAll.ForceSpectator = True;
UIManager.UIAll.SpectatorForceCameraType = 0;
UIManager.UIAll.SpectatorForcedTarget = LastestCapturedGoalId;
sleep(5*1000);
LastestCapturedGoalId = NullId;
}
UIManager.UIAll.UISequence = CUIConfig::EUISequence::EndRound;
foreach (Player in Players) {
UnspawnPlayer(Player);
}
sleep(3*1000);
LayerTops.ManialinkPage =
Top::GetFrameTop("Capture", _("Top 5 Captures"), "130 40", "Percent") ^
Top::GetFrameTop("Damages", _("Top 5 Score"), "130 -10", "");
UIManager.UIAll.UILayers.clear();
UIManager.UIAll.UILayers.add(LayerTops);
sleep(4*1000);
+++RoundEnd+++
XmlRpc.SendCallback("endRound",fixGetRankings());
Score::RoundEnd();
Top::RoundEnd();
Airshot::RoundEnd();
BalancedWeapons::RoundEnd();
Victory::RoundEnd();
Round += 1;
}
/* -------------------------------------- */
// Match/Map end
/* -------------------------------------- */
UIManager.ResetAll();
UIManager.UIAll.UISequence = CUIConfig::EUISequence::Outro;
UIManager.UIAll.BigMessageSound = CUIConfig::EUISound::EndRound;
declare WinnerClan = -1;
if (Victory::IsMatchWinner(1)) {
UIManager.UIAll.BigMessage = TextLib::Compose(_("$<%1$> wins the match!"), Teams[0].ColorizedName);
WinnerClan = 1;
} else if (Victory::IsMatchWinner(2)) {
UIManager.UIAll.BigMessage = TextLib::Compose(_("$<%1$> wins the match!"), Teams[1].ColorizedName);
WinnerClan = 2;
}
MatchNumber += 1;
sleep(6*1000);
if (WinnerClan != -1) {
// Reset score clans
foreach (Score in Scores) { declare Integer Clan for Score; Clan = 0; }
foreach (Player in Players) {
if (Player.Score == Null) continue;
declare Integer Clan for Player.Score;
Clan = Player.CurrentClan;
}
// Sort scores by clan
declare ClanScoresSorted = [1 => CSmScore[], 2 => CSmScore[]];
foreach (Score in Scores) {
Score.LadderRankSortValue = 1000;
declare Integer Clan for Score;
if (Clan != 1 && Clan != 2) continue;
ClanScoresSorted[Clan].add(Score);
}
declare Shift = [1 => 1, 2 => 1];
Shift[3 - WinnerClan] = 2;
foreach(Index => Score in ClanScoresSorted[1]) { Score.LadderRankSortValue = Index * 2 + Shift[1]; }
foreach(Index => Score in ClanScoresSorted[2]) { Score.LadderRankSortValue = Index * 2 + Shift[2]; }
Mode::Ladder_CloseMatch();
}
else {
Mode::Ladder_CancelMatch();
}
+++MatchEnd+++
XmlRpc.SendCallback("endMap",fixGetRankings());
Score::MatchEnd();
Top::MatchEnd();
Airshot::MatchEnd();
BalancedWeapons::MatchEnd();
Victory::MatchEnd();
UIManager.UIAll.BigMessage = "";
UIManager.UIAll.UISequence = CUIConfig::EUISequence::Podium;
sleep(10*1000);
UIManager.UIAll.ScoreTableVisibility = CUIConfig::EVisibility::Normal;
UIManager.UIAll.UILayers.clear();
sleep(1*1000);
MatchEndRequested = False;
Mode::UnloadMap();
}
/* -------------------------------------- */
// Destroy layers
UIManager.UILayerDestroy(LayerTops);
UIManager.UILayerDestroy(LayerRoundInfo);
UIManager.UILayerDestroy(LayerTeams);
UIManager.UILayerDestroy(LayerTeamsForSpectators);
UIManager.UILayerDestroy(LayerSpawnScreen);
}