// Use this for initialization
void Start()
{
ActiveTeam winningTeam = GameControl.instance.activeTeams[0].wonGame ? GameControl.instance.activeTeams[0] : null;
if (winningTeam == null)
{
winningTeam = GameControl.instance.activeTeams[1].wonGame ? GameControl.instance.activeTeams[1] : null;
}
if (winningTeam == null)
{
gameOverText.text = "They tied. That sucks. Hopefully it was funny anyway.";
player1Portrait.color = new Color(0, 0, 0, 0);
player1Name.text = "";
player2Portrait.color = new Color(0, 0, 0, 0);
player2Name.text = "";
player3Portrait.color = new Color(0, 0, 0, 0);
player3Name.text = "";
}
else
{
gameOverText.text = winningTeam.name + " won!";
SetBatterPhoto(winningTeam.players[0], player1Portrait);
player1Name.text = winningTeam.players[0].name;
SetBatterPhoto(winningTeam.players[1], player2Portrait);
player2Name.text = winningTeam.players[1].name;
SetBatterPhoto(winningTeam.players[2], player3Portrait);
player3Name.text = winningTeam.players[2].name;
}
}
public static ActiveMission Create(MissionDefinition definition)
{
var result = CreateInstance<ActiveMission>();
result.missionDefinition = definition;
result.teams = new ActiveTeam[definition.Teams.Count];
result.name = definition.name;
bool firstSlot = true;
for (int team = 0; team < result.teams.Length; ++team)
{
var newTeam = new ActiveTeam(definition.Teams[team]);
foreach (var slot in newTeam.Slots)
{
slot.Status = firstSlot ? SlotStatus.Human : SlotStatus.AI;
firstSlot = false;
}
result.teams[team] = newTeam;
}
return result;
}
public ActiveTeamsViewModel GetAllGamesUserCurrentlyPlaying(int userId, int?userTeamId, string footballClub, string searchString)
{
//var _activeGames = _games.GetAllGamesUserCurrentlyPlaying(userId);
var _activeUserTeams = _userTeams.GetAllUserTeamsCurrentlyActive(userId);
var _activeTeamsVM = new List <ActiveTeam>();
var _tempTeam = new ActiveTeam();
var _tempTeamOV = new TeamOverViewViewModel();
foreach (UserTeam uts in _activeUserTeams)
{
_tempTeam.GameName = uts.Game.Name;
_tempTeam.IsActive = (uts.OrderPosition == uts.Game.CurrentOrderPosition);
_tempTeam.UserTeamId = uts.Id;
_tempTeam.UserId = uts.UserId;
_tempTeam.GameId = uts.GameId;
_activeTeamsVM.Add(_tempTeam);
_tempTeam = new ActiveTeam(); // item stored in list is reference, not copy... need to new up item othrewise just end up with list of same items
}
if (userTeamId != null)
{
return(new ActiveTeamsViewModel()
{
ActiveTeams = _activeTeamsVM, TeamOverView = GetTeamOverViewViewModel((int)userTeamId, null, footballClub, searchString)
});
}
else
{
return(new ActiveTeamsViewModel()
{
ActiveTeams = _activeTeamsVM
});
}
}
public void SpawnAll(MissionDefinition.TeamDefinition teamDefinition, ActiveTeam activeTeam)
{
/* loop around slots, spawning players at each slot in turn until there are
* no more players
*/
var slotsCount = teamDefinition.Slots.Count;
var allSpawnPoints = new List<Transform>();
foreach (Transform spawnRoot in spawnPoints)
{
foreach (Transform spawnPoint in spawnRoot)
{
allSpawnPoints.Add(spawnPoint);
}
}
Ship firstSpawned = null;
var spawnsCount = allSpawnPoints.Count;
for (int slotIndex = 0; slotIndex < slotsCount; ++slotIndex)
{
var slotDefinition = teamDefinition.Slots[slotIndex];
var spawnPoint = allSpawnPoints[slotIndex % spawnsCount];
var activeSlot = activeTeam.Slots[slotIndex];
if (activeSlot.Status != SlotStatus.Closed || activeSlot.Status == SlotStatus.Open)
{
var ship = slotDefinition.SpawnShip(spawnPoint.position, spawnPoint.rotation, teamDefinition);
//first spawned ship becomnes the leader of the fleet
if (firstSpawned == null)
{
firstSpawned = ship;
}
else
{
SpaceTraderConfig.FleetManager.AddToFleet(firstSpawned, ship);
}
switch (activeSlot.Status)
{
case SlotStatus.AI:
SetupAIPlayer(ship);
break;
case SlotStatus.Human:
SetupHumanPlayer(ship, teamDefinition);
break;
}
activeSlot.SpawnedShip = ship;
}
}
}
public IEnumerator <YieldInstruction> BeginFloor()
{
DataManager.Instance.Save.Trail.Add(ZoneManager.Instance.CurrentMap.GetColoredName());
LogMsg(Text.FormatKey("MSG_ENTER_MAP", ActiveTeam.GetDisplayName(), ZoneManager.Instance.CurrentMap.GetColoredName()), true, false);
ZoneManager.Instance.CurrentMap.Begun = true;
//process player happenings
foreach (Character character in ZoneManager.Instance.CurrentMap.IterateCharacters())
{
character.Tactic.Initialize(character);
}
//map starts for map statuses
EventEnqueueFunction <SingleCharEvent> function = (StablePriorityQueue <GameEventPriority, EventQueueElement <SingleCharEvent> > queue, Priority maxPriority, ref Priority nextPriority) =>
{
//start with universal
DataManager.Instance.UniversalEvent.AddEventsToQueue(queue, maxPriority, ref nextPriority, DataManager.Instance.UniversalEvent.OnMapStarts, null);
ZoneManager.Instance.CurrentMap.MapEffect.AddEventsToQueue(queue, maxPriority, ref nextPriority, ZoneManager.Instance.CurrentMap.MapEffect.OnMapStarts, null);
foreach (MapStatus mapStatus in ZoneManager.Instance.CurrentMap.Status.Values)
{
MapStatusData entry = DataManager.Instance.GetMapStatus(mapStatus.ID);
mapStatus.AddEventsToQueue <SingleCharEvent>(queue, maxPriority, ref nextPriority, entry.OnMapStarts, null);
}
int portPriority = 0;
foreach (Character character in ZoneManager.Instance.CurrentMap.IterateCharacters())
{
if (!character.Dead)
{
foreach (PassiveContext effectContext in character.IteratePassives(new Priority(portPriority)))
{
effectContext.AddEventsToQueue(queue, maxPriority, ref nextPriority, effectContext.EventData.OnMapStarts, character);
}
}
portPriority++;
}
};
foreach (EventQueueElement <SingleCharEvent> effect in IterateEvents <SingleCharEvent>(function))
{
yield return(CoroutineManager.Instance.StartCoroutine(effect.Event.Apply(effect.Owner, effect.OwnerChar, effect.TargetChar)));
}
yield return(CoroutineManager.Instance.StartCoroutine(ZoneManager.Instance.CurrentMap.OnEnter()));
LogMsg(Text.DIVIDER_STR);
}
//Set selected teams as active
void SetupTeams()
{
foreach (var team in GameControl.instance.teams)
{
if (team.name == team1.options[team1.value].text)
{
ActiveTeam aTeam = new ActiveTeam();
aTeam.name = team.name;
aTeam.abbreviation = team.abbreviation;
aTeam.currentlyAtBat = t1Toggle.isOn;
aTeam.score = 0;
aTeam.wins = team.wins;
aTeam.ties = team.ties;
aTeam.loses = team.loses;
AddPlayers(aTeam, 1);
GameControl.instance.activeTeams.Add(aTeam);
Color teamColor = new Color(team.colorR, team.colorG, team.colorB);
GameControl.instance.homeTeamMat.color = teamColor;
aTeam.color = teamColor;
break;
}
}
foreach (var team in GameControl.instance.teams)
{
if (team.name == team2.options[team2.value].text)
{
ActiveTeam aTeam = new ActiveTeam();
aTeam.name = team.name;
aTeam.abbreviation = team.abbreviation;
aTeam.score = 0;
aTeam.currentlyAtBat = t2Toggle.isOn;
aTeam.wins = team.wins;
aTeam.ties = team.ties;
aTeam.loses = team.loses;
AddPlayers(aTeam, 2);
GameControl.instance.activeTeams.Add(aTeam);
Color teamColor = new Color(team.colorR, team.colorG, team.colorB);
GameControl.instance.awayTeamMat.color = teamColor;
aTeam.color = teamColor;
break;
}
}
}
public void HandleEvent(TeamRaceStarted teamRaceStarted)
{
var xxx = Stopwatch.StartNew();
var team = this._teamRepository.Get(teamRaceStarted.TeamId);
team.StartRace(teamRaceStarted.StartDate);
this._teamRepository.Update(team);
var activeTeam = new ActiveTeam
{
ChipId = team.ChipId,
TeamId = team.Id
};
this._activeTeamRepository.Add(activeTeam);
StatsPrinter.Print("TeamRaceStarted", xxx.ElapsedMilliseconds);
}
public IEnumerator <YieldInstruction> PrepareFloor()
{
DataManager.Instance.Save.Trail.Add(ZoneManager.Instance.CurrentMap.GetSingleLineName());
LogMsg(Text.FormatKey("MSG_ENTER_MAP", ActiveTeam.GetReferenceName(), ZoneManager.Instance.CurrentMap.GetSingleLineName()), true, false);
//start emitters for existing map status
foreach (MapStatus mapStatus in ZoneManager.Instance.CurrentMap.Status.Values)
{
mapStatus.StartEmitter(Anims);
}
//process events before the map fades in
foreach (SingleCharEvent effect in ZoneManager.Instance.CurrentMap.PrepareEvents)
{
yield return(CoroutineManager.Instance.StartCoroutine(effect.Apply(null, null, FocusedCharacter)));
}
//Notify script engine
LuaEngine.Instance.OnDungeonFloorPrepare();
}
static void UpdateTeamData(ActiveTeam aTeam, Team team)
{
//Set values of the team to account for updated values in active team
team.hits += aTeam.hits;
team.runs += aTeam.score;
team.atbatstrikeouts += aTeam.GetStrikeoutsAtBat();
team.pitchedstrikeouts += aTeam.GetPitchedStrikeouts();
if (aTeam.wonGame)
{
team.wins += 1;
}
else if (aTeam.lostGame)
{
team.loses += 1;
}
else if (aTeam.tiedGame)
{
team.ties += 1;
}
}
void NextBatter()
{
ActiveTeam battingTeam = GetTeamAtBat();
int curBatter = GetCurrentBatter();
curBatter = curBatter + 1 == battingTeam.players.Count ? 0 : curBatter + 1;
foreach (var player in battingTeam.players)
{
player.isAtBat = false;
}
foreach (var runner in Field.runners)
{
runner.atBat = false;
}
battingTeam.players[curBatter].isAtBat = true;
AddBatterToField();
changeCountEvent();
}
//Eventually use this to set up the pregame screen
void Start()
{
ActiveTeam homeTeam = GameControl.instance.activeTeams[0];
ActiveTeam awayTeam = GameControl.instance.activeTeams[1];
homeTeamName.text = homeTeam.name;
homePlayer1Img.sprite = GetPortaitForPlayer(homeTeam.players[0]);
homePlayer1Name.text = homeTeam.players[0].name;
homePlayer2Img.sprite = GetPortaitForPlayer(homeTeam.players[1]);
homePlayer2Name.text = homeTeam.players[1].name;
homePlayer3Img.sprite = GetPortaitForPlayer(homeTeam.players[2]);
homePlayer3Name.text = homeTeam.players[2].name;
homeTeamRecord.text = homeTeam.wins + "-" + homeTeam.loses + "-" + homeTeam.ties;
awayTeamName.text = awayTeam.name;
awayPlayer1Img.sprite = GetPortaitForPlayer(awayTeam.players[0]);
awayPlayer1Name.text = awayTeam.players[0].name;
awayPlayer2Img.sprite = GetPortaitForPlayer(awayTeam.players[1]);
awayPlayer2Name.text = awayTeam.players[1].name;
awayPlayer3Img.sprite = GetPortaitForPlayer(awayTeam.players[2]);
awayPlayer3Name.text = awayTeam.players[2].name;
awayTeamRecord.text = awayTeam.wins + "-" + awayTeam.loses + "-" + homeTeam.ties;
}
//Add selected players to active team
void AddPlayers(ActiveTeam team, int teamNumber)
{
switch (teamNumber)
{
case 1:
foreach (var player in GameControl.instance.players)
{
if (player.name == t1player1.options[t1player1.value].text || player.name == t1player2.options[t1player2.value].text || player.name == t1player3.options[t1player3.value].text)
{
ActivePlayer aPlayer = new ActivePlayer();
aPlayer.number = player.number;
aPlayer.name = player.name;
aPlayer.totalAtBats = player.atBats;
aPlayer.totalHits = player.hits;
aPlayer.portraitPath = player.portraitPath;
team.players.Add(aPlayer);
}
}
break;
case 2:
foreach (var player in GameControl.instance.players)
{
if (player.name == t2player1.options[t2player1.value].text || player.name == t2player2.options[t2player2.value].text || player.name == t2player3.options[t2player3.value].text)
{
ActivePlayer aPlayer = new ActivePlayer();
aPlayer.number = player.number;
aPlayer.name = player.name;
aPlayer.totalAtBats = player.atBats;
aPlayer.totalHits = player.hits;
aPlayer.portraitPath = player.portraitPath;
team.players.Add(aPlayer);
}
}
break;
}
}
private void SetUpScoreboardText()
{
ActiveTeam hTeam = GameControl.instance.activeTeams[0];
ActiveTeam aTeam = GameControl.instance.activeTeams[1];
hTeamInning1Score.text = hTeam.scoreByInning[0].ToString();
hTeamInning2Score.text = hTeam.scoreByInning[1].ToString();
hTeamInning3Score.text = hTeam.scoreByInning[2].ToString();
hTeamInning4Score.text = hTeam.scoreByInning[3].ToString();
hTeamInning5Score.text = hTeam.scoreByInning[4].ToString();
aTeamInning1Score.text = aTeam.scoreByInning[0].ToString();
aTeamInning2Score.text = aTeam.scoreByInning[1].ToString();
aTeamInning3Score.text = aTeam.scoreByInning[2].ToString();
aTeamInning4Score.text = aTeam.scoreByInning[3].ToString();
aTeamInning5Score.text = aTeam.scoreByInning[4].ToString();
hTeamHits.text = hTeam.GetHits().ToString();
aTeamHits.text = aTeam.GetHits().ToString();
hTeamRuns.text = hTeam.score.ToString();
aTeamRuns.text = aTeam.score.ToString();
aTeamPitches.text = aTeam.GetPitches().ToString();
hTeamPitches.text = hTeam.GetPitches().ToString();
aTeamAbr.text = aTeam.abbreviation;
hTeamAbr.text = hTeam.abbreviation;
}
//the intention, and its result to that frame
//"choose the action to partake in"
public IEnumerator <YieldInstruction> ProcessInput(GameAction action, Character character, ActionResult result)
{
//translates commands into actions
if (character.AttackOnly && character.CantWalk && action.Type == GameAction.ActionType.Wait)
{
action = new GameAction(GameAction.ActionType.Attack, action.Dir);
}
ProcessDir(action.Dir, character);
switch (action.Type)
{
case GameAction.ActionType.Dir:
{
//result.Success = ActionResult.ResultType.Success;
break;
}
case GameAction.ActionType.Wait:
{
result.Success = ActionResult.ResultType.TurnTaken;
//if it's a team character and it's team mode, wait a little while
if (DataManager.Instance.Save.TeamMode && character.MemberTeam == ActiveTeam)
{
DungeonScene.Instance.LogMsg(Text.FormatKey("MSG_SKIP_TURN", character.GetDisplayName(false)), false, true);
yield return(new WaitForFrames(GameManager.Instance.ModifyBattleSpeed(20)));
}
else if (character == FocusedCharacter) //add just one little wait to slow down the turn-passing when no enemies are in view
{
yield return(new WaitForFrames(1)); //this will cause 1-frame breaks when waiting with walking characters in view, but it's barely noticable
}
yield return(CoroutineManager.Instance.StartCoroutine(FinishTurn(character, true, false, false)));
break;
}
case GameAction.ActionType.Move:
{
yield return(CoroutineManager.Instance.StartCoroutine(ProcessWalk(character, (action[0] == 1), result)));
break;
}
case GameAction.ActionType.Pickup:
{
yield return(CoroutineManager.Instance.StartCoroutine(ProcessPickup(character, result)));
break;
}
case GameAction.ActionType.Drop:
{
//takes an index argument
//[0] = item slot to use (-1 for the held item)
yield return(CoroutineManager.Instance.StartCoroutine(ProcessPlaceItem(character, action[0], result)));
break;
}
case GameAction.ActionType.Give:
{
//[0] = item slot to use (-1 for the ground item)
//[1] = who to give it to (-1 for the user)
yield return(CoroutineManager.Instance.StartCoroutine(ProcessGiveItem(character, action[0], action[1], result)));
break;
}
case GameAction.ActionType.Take:
{
//[0] = team slot to take from
yield return(CoroutineManager.Instance.StartCoroutine(ProcessTakeItem(character, action[0], result)));
break;
}
case GameAction.ActionType.Tile:
{
yield return(CoroutineManager.Instance.StartCoroutine(ProcessTileInteract(character, result)));
break;
}
case GameAction.ActionType.Attack:
{
yield return(CoroutineManager.Instance.StartCoroutine(ProcessObjectInteract(character, result)));
break;
}
case GameAction.ActionType.UseSkill:
{
yield return(CoroutineManager.Instance.StartCoroutine(ProcessUseSkill(character, action[0], result)));
break;
}
case GameAction.ActionType.UseItem:
{
//[0] = item slot to use (-1 for held item, -2 for the ground item)
//[1] = who to use it on (-1 for the user)
//others: which slot to delete,
//which intrinsic to have, which team member/item to send in, etc.
yield return(CoroutineManager.Instance.StartCoroutine(ProcessUseItem(character, action[0], action[1], result)));
break;
}
case GameAction.ActionType.Throw:
{
//[0] = item slot to use (-1 for held item, -2 for the ground item)
yield return(CoroutineManager.Instance.StartCoroutine(ProcessThrowItem(character, action[0], result)));
break;
}
case GameAction.ActionType.TeamMode:
{
yield return(CoroutineManager.Instance.StartCoroutine(ToggleTeamMode(result)));
break;
}
case GameAction.ActionType.ShiftTeam:
{
result.Success = ActionResult.ResultType.Success;
SwitchTeam(action[0]);
break;
}
case GameAction.ActionType.SetLeader:
{
yield return(CoroutineManager.Instance.StartCoroutine(MakeLeader(action[0], result)));
break;
}
case GameAction.ActionType.SendHome:
{
result.Success = ActionResult.ResultType.Success;
yield return(CoroutineManager.Instance.StartCoroutine(SendHome(action[0])));
break;
}
case GameAction.ActionType.GiveUp:
{
result.Success = ActionResult.ResultType.Success;
yield return(CoroutineManager.Instance.StartCoroutine(GameManager.Instance.EndSegment((GameProgress.ResultType)action[0])));
break;
}
case GameAction.ActionType.Tactics:
{
result.Success = ActionResult.ResultType.Success;
//saves all the settings to the characters
for (int ii = 0; ii < ActiveTeam.Players.Count; ii++)
{
int choice = action[ii];
Character target = ActiveTeam.Players[ii];
AITactic tactic = DataManager.Instance.GetAITactic(choice);
if (tactic.ID != target.Tactic.ID)
{
target.Tactic = new AITactic(tactic);
}
target.Tactic.Initialize(target);
}
break;
}
case GameAction.ActionType.SetSkill:
{
result.Success = ActionResult.ResultType.Success;
Skill skill = ActiveTeam.Players[action[0]].Skills[action[1]].Element;
skill.Enabled = !skill.Enabled;
break;
}
case GameAction.ActionType.ShiftSkill:
{
result.Success = ActionResult.ResultType.Success;
ActiveTeam.Players[action[0]].SwitchSkills(action[1]);
break;
}
case GameAction.ActionType.SortItems:
{
result.Success = ActionResult.ResultType.Success;
ActiveTeam.SortItems();
break;
}
default:
{
throw new Exception("Undefined Command: " + action.Type);
}
}
}
private void Init()
{
startPosition = Field.fieldPositions[position].transform;
playPosition = Field.playPositions[position].transform;
team = GameControl.instance.GetTeamInField();
}
public IEnumerator <YieldInstruction> ProcessRescue(GameAction action, SOSMail mail)
{
//delete all enemies
for (int ii = ZoneManager.Instance.CurrentMap.MapTeams.Count - 1; ii >= 0; ii--)
{
for (int jj = ZoneManager.Instance.CurrentMap.MapTeams[ii].Players.Count - 1; jj >= 0; jj--)
{
yield return(CoroutineManager.Instance.StartCoroutine(ZoneManager.Instance.CurrentMap.MapTeams[ii].Players[jj].DieSilent()));
}
for (int jj = ZoneManager.Instance.CurrentMap.MapTeams[ii].Guests.Count - 1; jj >= 0; jj--)
{
yield return(CoroutineManager.Instance.StartCoroutine(ZoneManager.Instance.CurrentMap.MapTeams[ii].Guests[jj].DieSilent()));
}
}
//heal players
foreach (Character character in ActiveTeam.IterateMainByRank())
{
if (character.Dead)
{
Loc?endLoc = ZoneManager.Instance.CurrentMap.GetClosestTileForChar(character, ActiveTeam.Leader.CharLoc);
if (endLoc == null)
{
endLoc = ActiveTeam.Leader.CharLoc;
}
character.CharLoc = endLoc.Value;
character.HP = character.MaxHP;
character.Dead = false;
character.DefeatAt = "";
ZoneManager.Instance.CurrentMap.UpdateExploration(character);
}
}
ZoneManager.Instance.CurrentMap.CurrentTurnMap.CurrentOrder.TurnIndex = 0;
ZoneManager.Instance.CurrentMap.CurrentTurnMap.CurrentOrder.Faction = Faction.Player;
ZoneManager.Instance.CurrentMap.CurrentTurnMap.CurrentOrder.TurnTier = 0;
ZoneManager.Instance.CurrentMap.CurrentTurnMap.CurrentOrder.SkipAll = false;
RegenerateTurnMap();
RemoveDeadTeams();
DataManager.Instance.Save.RescuesLeft--;
//fade white back with music
//remove reward item
MapItem offeredItem = new MapItem((action[0] == 1), action[1]);
offeredItem.HiddenValue = action[2];
if (offeredItem.Value > -1)
{
if (offeredItem.IsMoney)
{
ActiveTeam.Bank -= offeredItem.Value;
}
else
{
ItemData entry = DataManager.Instance.GetItem(offeredItem.Value);
if (entry.MaxStack > 1)
{
List <int> itemsToTake = new List <int>();
for (int ii = 0; ii < offeredItem.HiddenValue; ii++)
{
itemsToTake.Add(offeredItem.Value);
}
ActiveTeam.TakeItems(itemsToTake);
}
else if (entry.UsageType == ItemData.UseType.Box)
{
int chosenIndex = 0;
for (int ii = 0; ii < ActiveTeam.BoxStorage.Count; ii++)
{
if (ActiveTeam.BoxStorage[ii].ID == offeredItem.Value &&
ActiveTeam.BoxStorage[ii].HiddenValue == offeredItem.HiddenValue)
{
chosenIndex = ii;
break;
}
}
List <int> itemsToTake = new List <int>();
itemsToTake.Add(DataManager.Instance.DataIndices[DataManager.DataType.Item].Count + chosenIndex);
}
else
{
List <int> itemsToTake = new List <int>();
itemsToTake.Add(offeredItem.Value);
ActiveTeam.TakeItems(itemsToTake);
}
}
}
if (DataManager.Instance.CurrentReplay == null)
{
yield return(CoroutineManager.Instance.StartCoroutine(ZoneManager.Instance.CurrentZone.OnRescued(mail)));
yield return(CoroutineManager.Instance.StartCoroutine(MenuManager.Instance.SetDialogue(Text.FormatKey("MSG_RESCUES_LEFT", DataManager.Instance.Save.RescuesLeft))));
yield return(new WaitForFrames(1));
}
else
{
GameManager.Instance.SE(GraphicsManager.ReviveSE);
GameManager.Instance.SetFade(true, true);
yield return(CoroutineManager.Instance.StartCoroutine(GameManager.Instance.FadeIn()));
int nameLength = action[3];
string name = "";
for (int ii = 0; ii < nameLength; ii++)
{
name += (char)action[4 + ii];
}
LogMsg(Text.FormatKey("MSG_RESCUED_BY", name));
}
ZoneManager.Instance.CurrentMap.NoRescue = true;
yield return(CoroutineManager.Instance.StartCoroutine(ProcessTurnStart(CurrentCharacter)));
}
public override IEnumerator <YieldInstruction> EndGame(ResultType result, ZoneLoc nextArea, bool display, bool fanfare)
{
bool recorded = DataManager.Instance.RecordingReplay;
//if lose, end the play, display plaque, and go to title
if (result != ResultType.Cleared)
{
if (GameManager.Instance.CurrentScene == GroundScene.Instance)
{
Location = ZoneManager.Instance.CurrentGround.GetSingleLineName();
}
else if (GameManager.Instance.CurrentScene == DungeonScene.Instance)
{
Location = ZoneManager.Instance.CurrentMap.GetSingleLineName();
}
Outcome = result;
DataManager.Instance.MsgLog.Clear();
//end the game with a recorded ending
string recordFile = DataManager.Instance.EndPlay(this, null);
MenuBase.Transparent = false;
//save to the main file
GameState state = DataManager.Instance.LoadMainGameState();
List <int> newRecruits = new List <int>();
if (state != null)
{
newRecruits = MergeDexTo(state.Save);
DataManager.Instance.SaveGameState(state);
}
if (recorded && display)
{
GameProgress ending = DataManager.Instance.GetRecord(Data.DataManager.REPLAY_PATH + recordFile);
if (fanfare)
{
if (result != ResultType.Cleared)
{
GameManager.Instance.Fanfare("Fanfare/MissionFail");
}
else
{
GameManager.Instance.Fanfare("Fanfare/MissionClear");
}
}
else
{
GameManager.Instance.SE("Menu/Skip");
}
FinalResultsMenu menu = new FinalResultsMenu(ending);
yield return(CoroutineManager.Instance.StartCoroutine(MenuManager.Instance.ProcessMenuCoroutine(menu)));
Dictionary <int, List <RecordHeaderData> > scores = RecordHeaderData.LoadHighScores();
yield return(CoroutineManager.Instance.StartCoroutine(MenuManager.Instance.ProcessMenuCoroutine(new ScoreMenu(scores, ZoneManager.Instance.CurrentZoneID, DataManager.REPLAY_PATH + recordFile))));
}
if (newRecruits.Count > 0)
{
yield return(new WaitForFrames(10));
GameManager.Instance.Fanfare("Fanfare/NewArea");
yield return(CoroutineManager.Instance.StartCoroutine(MenuManager.Instance.SetDialogue(Text.FormatKey("DLG_NEW_CHARS"))));
}
yield return(new WaitForFrames(20));
GameManager.Instance.SceneOutcome = GameManager.Instance.RestartToTitle();
}
else
{
int completedZone = ZoneManager.Instance.CurrentZoneID;
MidAdventure = true;
ClearDungeonItems();
// if there isn't a next area, end the play, display the plaque, return to title screen
//GameManager.Instance.Fanfare("Fanfare/MissionClear");
Location = ZoneManager.Instance.CurrentZone.Name.ToLocal();
Outcome = result;
DataManager.Instance.MsgLog.Clear();
//end the game with a recorded ending
string recordFile = DataManager.Instance.EndPlay(this, null);
MenuBase.Transparent = false;
//save to the main file
GameState state = DataManager.Instance.LoadMainGameState();
if (state != null)
{
MergeDexTo(state.Save);
state.Save.DungeonUnlocks[completedZone] = UnlockState.Completed;
DataManager.Instance.SaveGameState(state);
}
if (recorded)
{
GameProgress ending = DataManager.Instance.GetRecord(DataManager.REPLAY_PATH + recordFile);
if (fanfare)
{
if (result != ResultType.Cleared)
{
GameManager.Instance.Fanfare("Fanfare/MissionFail");
}
else
{
GameManager.Instance.Fanfare("Fanfare/MissionClear");
}
}
else
{
GameManager.Instance.SE("Menu/Skip");
}
FinalResultsMenu menu = new FinalResultsMenu(ending);
yield return(CoroutineManager.Instance.StartCoroutine(MenuManager.Instance.ProcessMenuCoroutine(menu)));
Dictionary <int, List <RecordHeaderData> > scores = RecordHeaderData.LoadHighScores();
yield return(CoroutineManager.Instance.StartCoroutine(MenuManager.Instance.ProcessMenuCoroutine(new ScoreMenu(scores, ZoneManager.Instance.CurrentZoneID, DataManager.REPLAY_PATH + recordFile))));
}
//ask to transfer if the dungeon records progress, and it is NOT a seeded run.
if (state != null && Stakes != DungeonStakes.None && !Seeded)
{
bool allowTransfer = false;
QuestionDialog question = MenuManager.Instance.CreateQuestion(Text.FormatKey("DLG_TRANSFER_ASK"),
() => { allowTransfer = true; }, () => { });
yield return(CoroutineManager.Instance.StartCoroutine(MenuManager.Instance.ProcessMenuCoroutine(question)));
if (allowTransfer)
{
MainProgress mainSave = state.Save as MainProgress;
//put the new recruits into assembly
foreach (Character character in ActiveTeam.Players)
{
if (!(character.Dead && DataManager.Instance.GetSkin(character.BaseForm.Skin).Challenge))
{
mainSave.CharsToStore.Add(new CharData(character));
}
}
foreach (Character character in ActiveTeam.Assembly)
{
if (!(character.Dead && DataManager.Instance.GetSkin(character.BaseForm.Skin).Challenge))
{
mainSave.CharsToStore.Add(new CharData(character));
}
}
//put the new items into the storage
foreach (InvItem item in ActiveTeam.EnumerateInv())
{
mainSave.ItemsToStore.Add(item);
}
foreach (InvItem item in ActiveTeam.BoxStorage)
{
mainSave.ItemsToStore.Add(item);
}
mainSave.StorageToStore = ActiveTeam.Storage;
mainSave.MoneyToStore = state.Save.ActiveTeam.Money + state.Save.ActiveTeam.Bank;
}
DataManager.Instance.SaveGameState(state);
if (allowTransfer)
{
yield return(CoroutineManager.Instance.StartCoroutine(MenuManager.Instance.SetDialogue(Text.FormatKey("DLG_TRANSFER_COMPLETE"))));
}
}
yield return(new WaitForFrames(20));
}
}
public override IEnumerator <YieldInstruction> EndGame(ResultType result, ZoneLoc nextArea, bool display, bool fanfare)
{
Outcome = result;
bool recorded = DataManager.Instance.RecordingReplay;
string recordFile = null;
if (result == ResultType.Rescue)
{
Location = ZoneManager.Instance.CurrentZone.GetDisplayName();
DataManager.Instance.MsgLog.Clear();
//end the game with a recorded ending
recordFile = DataManager.Instance.EndPlay(this, StartDate);
SOSMail sos = Rescue.SOS;
string dateRescued = String.Format("{0:yyyy-MM-dd}", DateTime.Now);
ReplayData replay = DataManager.Instance.LoadReplay(PathMod.ModSavePath(DataManager.REPLAY_PATH, recordFile), false);
AOKMail aok = new AOKMail(sos, DataManager.Instance.Save, dateRescued, replay);
GeneratedAOK = DataManager.SaveRescueMail(PathMod.NoMod(DataManager.RESCUE_OUT_PATH + DataManager.AOK_FOLDER), aok, false);
string deletePath = DataManager.FindRescueMail(PathMod.NoMod(DataManager.RESCUE_IN_PATH + DataManager.SOS_FOLDER), sos, sos.Extension);
if (deletePath != null)
{
File.Delete(deletePath);
}
if (nextArea.IsValid()) // if an exit is specified, go to the exit.
{
NextDest = nextArea;
}
else
{
NextDest = new ZoneLoc(1, new SegLoc(-1, 1));
}
}
else if (result != ResultType.Cleared)
{
if (GameManager.Instance.CurrentScene == GroundScene.Instance)
{
Location = ZoneManager.Instance.CurrentGround.GetColoredName();
}
else if (GameManager.Instance.CurrentScene == DungeonScene.Instance)
{
Location = ZoneManager.Instance.CurrentMap.GetColoredName();
}
DataManager.Instance.MsgLog.Clear();
//end the game with a recorded ending
recordFile = DataManager.Instance.EndPlay(this, StartDate);
if (Outcome != ResultType.Escaped && Stakes == DungeonStakes.Risk) //remove all items
{
LossPenalty(this);
}
if (nextArea.IsValid()) // if an exit is specified, go to the exit.
{
NextDest = nextArea;
}
else
{
NextDest = new ZoneLoc(1, new SegLoc(-1, 1));
}
}
else
{
int completedZone = ZoneManager.Instance.CurrentZoneID;
DungeonUnlocks[completedZone] = UnlockState.Completed;
Location = ZoneManager.Instance.CurrentZone.GetDisplayName();
DataManager.Instance.MsgLog.Clear();
//end the game with a recorded ending
recordFile = DataManager.Instance.EndPlay(this, StartDate);
if (nextArea.IsValid()) // if an exit is specified, go to the exit.
{
NextDest = nextArea;
}
else
{
NextDest = new ZoneLoc(1, new SegLoc(-1, 1));
}
}
TotalAdventures++;
foreach (Character character in ActiveTeam.EnumerateChars())
{
character.Dead = false;
character.FullRestore();
}
foreach (Character character in ActiveTeam.Assembly)
{
character.Dead = false;
character.FullRestore();
}
MidAdventure = false;
ClearDungeonItems();
//clear rescue status
Rescue = null;
//merge back the team if the dungeon was level-limited
yield return(CoroutineManager.Instance.StartCoroutine(RestoreLevel()));
GameState state = DataManager.Instance.LoadMainGameState();
MainProgress mainSave = state?.Save as MainProgress;
//save the result to the main file
if (Stakes != DungeonStakes.None)
{
if (mainSave != null)
{
mainSave.MergeDataTo(this);
}
DataManager.Instance.SaveMainGameState();
}
else
{
if (mainSave != null)
{
DataManager.Instance.SetProgress(mainSave);
}
DataManager.Instance.Save.NextDest = NextDest;
}
MenuBase.Transparent = false;
if (recorded && display)
{
GameProgress ending = DataManager.Instance.GetRecord(PathMod.ModSavePath(DataManager.REPLAY_PATH, recordFile));
if (fanfare)
{
if (result != ResultType.Cleared && result != ResultType.Escaped && result != ResultType.Rescue)
{
GameManager.Instance.Fanfare("Fanfare/MissionFail");
}
else
{
GameManager.Instance.Fanfare("Fanfare/MissionClear");
}
}
else
{
GameManager.Instance.SE("Menu/Skip");
}
FinalResultsMenu menu = new FinalResultsMenu(ending);
yield return(CoroutineManager.Instance.StartCoroutine(MenuManager.Instance.ProcessMenuCoroutine(menu)));
}
yield return(new WaitForFrames(20));
}
//Add team to list of participating teams
void AddActiveTeam(ActiveTeam team)
{
activeTeams.Add(team);
}
