public IEnumerator <YieldInstruction> MoveToEditor(bool newGround, string name)
{
BaseScene destScene = GroundEditScene.Instance;// newGround ? (BaseScene)GroundScene.Instance : DungeonScene.Instance;
ZoneLoc destLoc = ZoneLoc.Invalid;
if (ZoneManager.Instance.CurrentZoneID > -1)
{
destLoc = new ZoneLoc(ZoneManager.Instance.CurrentZoneID, ZoneManager.Instance.CurrentMapID);
}
exitMap(destScene);
ZoneManager.Instance.MoveToDevZone(newGround, name);
//Transparency mode
MenuBase.Transparent = true;
//switch in new scene
MoveToScene(destScene);
if (newGround)
{
GroundEditScene.Instance.EnterGroundEdit(0);
}
else
{
}
if (DataManager.Instance.Save != null)
{
DataManager.Instance.Save.NextDest = destLoc;
}
yield break;
}
public ClearZone(int t0, Actor who, ZoneLoc dest) : base(t0, who)
{
m_Zone = dest;
threats = who.Threats // these two should agree on whether they're null or not
#if DEBUG
?? throw new ArgumentNullException("who.Threats")
#endif
;
tourism = who.InterestingLocs
#if DEBUG
?? throw new ArgumentNullException("who.InterestingLocs")
#endif
;
Func <Point, bool> ok = pt => m_Zone.Rect.Contains(pt);
m_Unverified.UnionWith(threats.ThreatWhere(dest.m).Where(ok));
m_Unverified.UnionWith(tourism.In(dest.m).Where(ok));
#if OBSOLETE
// the civilian case
if (null == threats && null == sights_to_see)
{
m_Unverified.UnionWith(m_Zone.Rect.Where(pt => who.CanEnter(new Location(m_Zone.m, pt)))); // \todo? eliminate GC thrashing
}
#endif
// nonserialized fields
oai = (m_Actor.Controller as ObjectiveAI)
#if DEBUG
?? throw new ArgumentNullException("who.Controller is ObjectiveAI")
#endif
;
}
public IEnumerator <YieldInstruction> BeginSegment(ZoneLoc nextZone)
{
DataManager.Instance.Save.NextDest = nextZone;
if (DataManager.Instance.RecordingReplay)
{
DataManager.Instance.LogState();
}
SceneOutcome = MoveToZone(nextZone);
yield break;
}
public Point Reanchor(Location loc)
{
if (m_Domain.m != loc.Map)
{
var origin = m_Domain.Rect.Location;
var tl = new Location(m_Domain.m, origin);
var denorm = loc.Map.Denormalize(tl);
if (null == denorm)
{
throw new InvalidOperationException("cannot re-anchor");
}
// \todo re-positioned Rectangle ideally would contain loc.Position
m_Domain = new ZoneLoc(loc.Map, new Rectangle(denorm.Value.Position, m_Domain.Rect.Size));
return(origin - denorm.Value.Position);
}
return(new Point(0, 0));
}
public IEnumerator <YieldInstruction> DebugWarp(ZoneLoc dest, ulong seed)
{
DataManager.Instance.MsgLog.Clear();
DataManager.Instance.EndPlay(null, null);
if (DataManager.Instance.Save == null)
{
newGamePlus(seed);
}
else
{
DataManager.Instance.Save.Rand = new ReRandom(seed);
}
DataManager.Instance.Save.NextDest = dest;
DataManager.Instance.Save.RestartLogs(MathUtils.Rand.NextUInt64());
DataManager.Instance.Save.MidAdventure = true;
yield return(CoroutineManager.Instance.StartCoroutine(MoveToZone(DataManager.Instance.Save.NextDest, true)));
}
public GameProgress()
{
ActiveTeam = new ExplorerTeam();
Dex = new UnlockState[DataManager.Instance.DataIndices[DataManager.DataType.Monster].Count];
DungeonUnlocks = new UnlockState[DataManager.Instance.DataIndices[DataManager.DataType.Zone].Count];
NextDest = ZoneLoc.Invalid;
StartLevel = -1;
StartDate = "";
UUID = "";
ProfilePics = new ProfilePic[0];
EndDate = "";
Location = "";
Trail = new List <string>();
Outcome = ResultType.Unknown;
}
public MapKripke(ZoneLoc z, Actor?viewpoint = null)
{
m_Domain = z;
_viewpoint = viewpoint;
if (null != viewpoint)
{
update(viewpoint.Controller.FOVloc); // AI
}
else // Socrates' Daimon
{
m_Domain.DoForEach(loc => {
var obj = loc.MapObject;
if (null != obj)
{
(_knownMapObjects ??= new Dictionary <Location, MapObject>()).Add(loc, obj);
}
});
}
}
public SOSMail(GameProgress progress, ZoneLoc goal, LocalText goalText, string dateTime, Version version)
{
TeamName = progress.ActiveTeam.Name;
TeamID = progress.UUID;
DateDefeated = dateTime;
DefeatedVersion = version;
List <MonsterID> teamProfile = new List <MonsterID>();
foreach (Character chara in progress.ActiveTeam.Players)
{
teamProfile.Add(chara.BaseForm);
}
TeamProfile = teamProfile.ToArray();
Seed = progress.Rand.FirstSeed;
TurnsTaken = progress.TotalTurns;
Goal = goal;
GoalText = goalText;
OfferedItem = new MapItem();
}
public IEnumerator <YieldInstruction> BeginGameInSegment(ZoneLoc nextZone, GameProgress.DungeonStakes stakes, bool recorded, bool silentRestrict)
{
yield return(CoroutineManager.Instance.StartCoroutine(BeginGame(nextZone.ID, MathUtils.Rand.NextUInt64(), stakes, recorded, silentRestrict)));
yield return(CoroutineManager.Instance.StartCoroutine(BeginSegment(nextZone)));
}
public IEnumerator <YieldInstruction> MoveToZone(ZoneLoc destId, bool forceNewZone = false, bool preserveMusic = false)
{
bool newGround = (destId.StructID.Segment <= -1);
BaseScene destScene = newGround ? (BaseScene)GroundScene.Instance : DungeonScene.Instance;
exitMap(destScene);
//switch location
if (destId.ID == ZoneManager.Instance.CurrentZoneID && !forceNewZone)
{
ZoneManager.Instance.CurrentZone.SetCurrentMap(destId.StructID);
}
else
{
ZoneManager.Instance.MoveToZone(destId.ID, destId.StructID, unchecked (DataManager.Instance.Save.Rand.FirstSeed + (ulong)destId.ID));//NOTE: there are better ways to seed a multi-dungeon adventure
yield return(CoroutineManager.Instance.StartCoroutine(ZoneManager.Instance.CurrentZone.OnInit()));
}
//Transparency mode
MenuBase.Transparent = !newGround;
//switch in new scene
MoveToScene(destScene);
if (newGround && CurrentScene != GroundScene.Instance)
{
LuaEngine.Instance.OnGroundModeBegin();
}
else if (!newGround && CurrentScene != DungeonScene.Instance)
{
LuaEngine.Instance.OnDungeonModeBegin();
}
if (newGround)
{
if (!preserveMusic)
{
BGM(ZoneManager.Instance.CurrentGround.Music, true);
}
GroundScene.Instance.EnterGround(destId.EntryPoint);
yield return(CoroutineManager.Instance.StartCoroutine(GroundScene.Instance.InitGround()));
//no fade; the script handles that itself
yield return(CoroutineManager.Instance.StartCoroutine(GroundScene.Instance.BeginGround()));
}
else
{
if (!preserveMusic)
{
BGM(ZoneManager.Instance.CurrentMap.Music, true);
}
DungeonScene.Instance.EnterFloor(destId.EntryPoint);
yield return(CoroutineManager.Instance.StartCoroutine(DungeonScene.Instance.PrepareFloor()));
if (IsFaded())
{
if (ZoneManager.Instance.CurrentMap.DropTitle)
{
yield return(CoroutineManager.Instance.StartCoroutine(FadeTitle(true, ZoneManager.Instance.CurrentMap.Name.ToLocal())));
yield return(new WaitForFrames(30));
yield return(CoroutineManager.Instance.StartCoroutine(FadeTitle(false, "")));
}
yield return(CoroutineManager.Instance.StartCoroutine(FadeIn()));
}
yield return(CoroutineManager.Instance.StartCoroutine(DungeonScene.Instance.BeginFloor()));
}
DataManager.Instance.Save.NextDest = ZoneLoc.Invalid;
}
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.Name.ToLocal();
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(DataManager.REPLAY_PATH + recordFile, false);
AOKMail aok = new AOKMail(sos, DataManager.Instance.Save, dateRescued, replay);
GeneratedAOK = DataManager.SaveRescueMail(DataManager.RESCUE_OUT_PATH + DataManager.AOK_PATH, aok, false);
string deletePath = DataManager.FindRescueMail(DataManager.RESCUE_IN_PATH + DataManager.SOS_PATH, 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.GetSingleLineName();
}
else if (GameManager.Instance.CurrentScene == DungeonScene.Instance)
{
Location = ZoneManager.Instance.CurrentMap.GetSingleLineName();
}
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.Name.ToLocal();
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.Players)
{
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()));
//save the result to the main file
if (Stakes != DungeonStakes.None)
{
GameState state = DataManager.Instance.LoadMainGameState();
MainProgress mainSave = state.Save as MainProgress;
mainSave.MergeDataTo(this);
DataManager.Instance.SaveMainGameState();
}
else
{
GameState state = DataManager.Instance.LoadMainGameState();
MainProgress mainSave = state.Save as MainProgress;
mainSave.MergeDataTo(mainSave);
DataManager.Instance.SetProgress(state.Save);
DataManager.Instance.Save.NextDest = NextDest;
}
MenuBase.Transparent = false;
if (recorded && display)
{
GameProgress ending = DataManager.Instance.GetRecord(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));
}
public abstract IEnumerator <YieldInstruction> EndGame(ResultType result, ZoneLoc nextArea, bool display, bool fanfare);
public IEnumerator <YieldInstruction> travelMenuFlow(LuaTable dungeons, LuaTable grounds)
{
ZoneLoc chosenDest = ZoneLoc.Invalid;
List <int> availableDungeons = new List <int>();
List <Tuple <int, int[]> > goodsList = new List <Tuple <int, int[]> >();
foreach (object key in dungeons.Keys)
{
int entry = (int)(Int64)dungeons[key];
availableDungeons.Add(entry);
}
List <ZoneLoc> availableGrounds = new List <ZoneLoc>();
foreach (object key in grounds.Keys)
{
LuaTable entry = grounds[key] as LuaTable;
int zone = (int)(Int64)entry["Zone"];
int id = (int)(Int64)entry["ID"];
int entryPoint = (int)(Int64)entry["Entry"];
availableGrounds.Add(new ZoneLoc(zone, new SegLoc(-1, id), entryPoint));
}
if (availableDungeons.Count + availableGrounds.Count == 1)
{
if (availableDungeons.Count == 1)
{
//ask directly if the player wants to enter the one dungeon possible
yield return(CoroutineManager.Instance.StartCoroutine(askDungeonQuestion(availableDungeons[0], () => { chosenDest = new ZoneLoc(availableDungeons[0], new SegLoc(0, 0)); }, () => { })));
}
if (availableGrounds.Count == 1)
{
ZoneData zone = DataManager.Instance.GetZone(availableGrounds[0].ID);
QuestionDialog question = MenuManager.Instance.CreateQuestion(Text.FormatKey("DLG_ASK_ENTER_GROUND", DataManager.Instance.GetGround(zone.GroundMaps[availableGrounds[0].StructID.ID]).GetSingleLineName()),
() => { chosenDest = availableGrounds[0]; }, () => { });
yield return(CoroutineManager.Instance.StartCoroutine(MenuManager.Instance.ProcessMenuCoroutine(question)));
}
}
else if (availableDungeons.Count + availableGrounds.Count > 1)
{
//give the player the choice between all the possible dungeons
yield return(CoroutineManager.Instance.StartCoroutine(MenuManager.Instance.ProcessMenuCoroutine(new DungeonsMenu(availableDungeons, availableGrounds,
(int choice) => { chosenDest = new ZoneLoc(availableDungeons[choice], new SegLoc(0, 0)); },
(int choice) => { chosenDest = new ZoneLoc(availableGrounds[choice].ID, new SegLoc(-1, availableGrounds[choice].StructID.ID), availableGrounds[choice].EntryPoint); }))));
}
if (chosenDest.IsValid())
{
GameManager.Instance.BGM("", true);
yield return(CoroutineManager.Instance.StartCoroutine(GameManager.Instance.FadeOut(false)));
if (chosenDest.StructID.Segment > -1)
{
yield return(CoroutineManager.Instance.StartCoroutine(GameManager.Instance.BeginGameInSegment(chosenDest, GameProgress.DungeonStakes.Risk, true, false)));
}
else
{
GameManager.Instance.SceneOutcome = GameManager.Instance.MoveToZone(chosenDest);
}
}
}
