public void HardReset()
{
reset();
GuildManager.resetAllUpgrades();
StatisticsTracker.HardReset();
FieldInfo[] fields = typeof(Industries).GetFields();
foreach (FieldInfo field in fields)
{
Industry ind = (Industry)field.GetValue(null);
ind.startingVendors = 0;
ind.apprentices = 0;
ind.SetRawVendors(0);
}
maxVendors = 3;
renown = totalRenown = 0;
money = 20;
maxApprentices = 0;
currentApprentices = 0;
journeymen = 0;
totalQuestsCompletedRenown = 0;
questsCompletedRenown = 0;
skillPoints = 0;
totalSkillPoints = 0;
researchTime = 0;
StatisticsTracker.lifetimeMoney.setValue(money);
builtItems = new List <Industry>();
resetLevel = 1;
upgrades.Clear();
SetDefaultUpgrades();
currentGuildmaster = new Master();
miscInventory.Clear();
unidentifiedRelics.Clear();
AchievementsManager.setupUI();
}
void Awake()
{
tracker = GetComponent <StatisticsTracker>();
achiever = new DataPercentage(1, 1, 1, 1);
explorer = new DataPercentage(0, 1, 0, 0.5f);
killer = new DataPercentage(0, 0, 1, 0.5f);
socializer = new DataPercentage(1, 0.5f, 0, 0);
}
private Task <KafkaDataPayload> EnqueueWriteTask(KafkaDataPayload payload, CancellationToken cancellationToken)
{
var sendTask = new SocketPayloadSendTask(payload, cancellationToken);
_sendTaskQueue.Add(sendTask);
StatisticsTracker.QueueNetworkWrite(_endpoint, payload);
return(sendTask.Tcp.Task);
}
private KafkaDataPayload EncodeProduceRequest(ProduceRequest request)
{
int totalCompressedBytes = 0;
if (request.Payload == null)
{
request.Payload = new List <Payload>();
}
var groupedPayloads = (from p in request.Payload
group p by new
{
p.Topic,
p.Partition,
p.Codec
} into tpc
select tpc).ToList();
using (var message = EncodeHeader(request)
.Pack(request.Acks)
.Pack(request.TimeoutMS)
.Pack(groupedPayloads.Count))
{
foreach (var groupedPayload in groupedPayloads)
{
var payloads = groupedPayload.ToList();
message.Pack(groupedPayload.Key.Topic, StringPrefixEncoding.Int16)
.Pack(payloads.Count)
.Pack(groupedPayload.Key.Partition);
switch (groupedPayload.Key.Codec)
{
case MessageCodec.CodecNone:
message.Pack(Message.EncodeMessageSet(payloads.SelectMany(x => x.Messages)));
break;
case MessageCodec.CodecGzip:
var compressedBytes = CreateGzipCompressedMessage(payloads.SelectMany(x => x.Messages));
Interlocked.Add(ref totalCompressedBytes, compressedBytes.CompressedAmount);
message.Pack(Message.EncodeMessageSet(new[] { compressedBytes.CompressedMessage }));
break;
default:
throw new NotSupportedException(string.Format("Codec type of {0} is not supported.", groupedPayload.Key.Codec));
}
}
var result = new KafkaDataPayload
{
Buffer = message.Payload(),
CorrelationId = request.CorrelationId,
MessageCount = request.Payload.Sum(x => x.Messages.Count)
};
StatisticsTracker.RecordProduceRequest(result.MessageCount, result.Buffer.Length, totalCompressedBytes);
return(result);
}
}
void OnGameEnded(object sender, EventArgs e)
{
timerIntervalSeconds.Stop();
if (field.GameWon)
{
StatisticsTracker.GamesWon++;
StatisticsTracker.TrySetPlayerNameOnNewHighscore(field.CurrentConfiguration, mineLabelTime.Value, this);
}
toolStripLabelDebugHelper.Text = field.GameWon ? "You win!" : "You lose!";
}
private async Task ProcessSentTasksAsync(NetworkStream netStream, SocketPayloadSendTask sendTask)
{
if (sendTask == null)
{
return;
}
using (sendTask)
{
var failed = false;
var sw = Stopwatch.StartNew();
try
{
sw.Restart();
if (UseStatisticsTracker())
{
StatisticsTracker.IncrementGauge(StatisticGauge.ActiveWriteOperation);
}
if (OnWriteToSocketAttempt != null)
{
OnWriteToSocketAttempt(sendTask.Payload);
}
_log.DebugFormat("Sending data for CorrelationId:{0} Connection:{1}", sendTask.Payload.CorrelationId, Endpoint);
await netStream.WriteAsync(sendTask.Payload.Buffer, 0, sendTask.Payload.Buffer.Length).ConfigureAwait(false);
_log.DebugFormat("Data sent to CorrelationId:{0} Connection:{1}", sendTask.Payload.CorrelationId, Endpoint);
sendTask.Tcp.TrySetResult(sendTask.Payload);
}
catch (Exception ex)
{
failed = true;
if (_disposeToken.IsCancellationRequested)
{
var exception = new ObjectDisposedException("Object is disposing.");
sendTask.Tcp.TrySetException(exception);
throw exception;
}
sendTask.Tcp.TrySetException(ex);
throw;
}
finally
{
if (UseStatisticsTracker())
{
StatisticsTracker.DecrementGauge(StatisticGauge.ActiveWriteOperation);
StatisticsTracker.CompleteNetworkWrite(sendTask.Payload, sw.ElapsedMilliseconds, failed);
}
}
}
}
public FSettings(Form parent, AdvancementTracker advancementTracker, AchievementTracker achievementTracker, StatisticsTracker statisticsTracker)
{
InitializeComponent();
LoadSettings();
this.advancementTracker = advancementTracker;
this.achievementTracker = achievementTracker;
this.statisticsTracker = statisticsTracker;
trackerGameVersion.Items.Clear();
foreach (var version in TrackerSettings.SupportedVersions.Reverse())
{
trackerGameVersion.Items.Add(version);
}
trackerGameVersion.Text = tracker.GameVersion;
}
protected override void Update(GameTime gameTime)
{
time.Update(gameTime);
display.Update(time);
//check minecraft version
GameVersionDetector.Update();
AdvancementTracker.Update(time);
StatisticsTracker.Update(time);
AchievementTracker.Update(time);
//update each screen
mainScreen.UpdateRecursive(time);
foreach (var screen in altScreens.Values)
{
screen.UpdateRecursive(time);
}
//update notes screen
if (NotesSettings.Instance.Enabled)
{
if (notesWindow == null || notesWindow.IsDisposed)
{
notesWindow = new FNotes();
notesWindow.Show();
}
else if (TrackerSettings.IsPostExplorationUpdate)
{
notesWindow.UpdateCurrentSave(AdvancementTracker.CurrentSaveName);
}
else
{
notesWindow.UpdateCurrentSave(AchievementTracker.CurrentSaveName);
}
}
else if (notesWindow != null && !notesWindow.IsDisposed)
{
notesWindow.Close();
}
TrackerSettings.Instance.Update();
MainSettings.Instance.Update();
OverlaySettings.Instance.Update();
SpriteSheet.Update(time);
base.Update(gameTime);
}
void Awake()
{
if (instance != null && instance != this)
{
Destroy(this.gameObject);
}
else
{
instance = this;
}
statTable = new Dictionary <int, Statistics>();
// Wait for QuestTracker to initialize first
StartCoroutine(Initialize());
}
public Screen(Main main, GameWindow window, int width, int height)
{
Main = main;
Window = window;
GraphicsDevice = main.GraphicsDevice;
AdvancementTracker = main.AdvancementTracker;
AchievementTracker = main.AchievementTracker;
StatisticsTracker = main.StatisticsTracker;
Form = Control.FromHandle(window.Handle) as Form;
Form.Resize += OnResize;
Form.Icon = new System.Drawing.Icon("assets/graphics/system/icon.ico");
Form.ShowIcon = true;
DrawMode = DrawMode.All;
//only create swap chain if this is a secondary window
if (window != main.Window)
{
SetWindowSize(width, height);
}
ResizeThis(new Rectangle(0, 0, width, height));
}
protected override void Initialize()
{
//instantiate important objects
time = new Time();
display = new Display(GraphicsManager);
AdvancementTracker = new AdvancementTracker();
StatisticsTracker = new StatisticsTracker();
AchievementTracker = new AchievementTracker();
//load assets
SpriteSheet.Initialize(GraphicsDevice);
FontSet.Initialize(GraphicsDevice);
//instantiate screens
altScreens = new Dictionary <Type, Screen>();
mainScreen = new MainScreen(this);
AddScreen(new OverlayScreen(this));
mainScreen.Form.BringToFront();
base.Initialize();
UpdateHelper.TryCheckForUpdatesAsync();
}
public static void ReportDrawTimeWhileSwitching(GuiWidget container, string firstWidgetName, string secondWidgetName, double switchTimeSeconds)
{
StatisticsTracker testTracker = new StatisticsTracker("SwitchBetweenTabs");
bool clickFirstItem = true;
bool done = false;
bool firstDraw = true;
AutomationRunner clickPreview;
Stopwatch timeSinceLastClick = Stopwatch.StartNew();
Stopwatch totalDrawTime = Stopwatch.StartNew();
int drawCount = 0;
DrawEventHandler beforeDraw = (sender, e) =>
{
if (firstDraw)
{
clickPreview = new AutomationRunner();
Task.Run(() =>
{
while (!done)
{
if (clickPreview != null && timeSinceLastClick.Elapsed.TotalSeconds > switchTimeSeconds)
{
if (clickFirstItem)
{
clickPreview.ClickByName(firstWidgetName);
}
else
{
clickPreview.ClickByName(secondWidgetName);
}
clickFirstItem = !clickFirstItem;
timeSinceLastClick.Restart();
}
}
});
firstDraw = false;
}
totalDrawTime.Restart();
};
container.DrawBefore += beforeDraw;
DrawEventHandler afterDraw = null;
afterDraw = (sender, e) =>
{
totalDrawTime.Stop();
if (drawCount++ > 30 && testTracker.Count < 100)
{
testTracker.AddValue(totalDrawTime.ElapsedMilliseconds);
if (testTracker.Count == 100)
{
Trace.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(testTracker));
container.DrawBefore -= beforeDraw;
container.DrawBefore -= afterDraw;
done = true;
}
}
};
container.DrawAfter += afterDraw;
}
private void OnStatisticsMenuItemClick(object sender, EventArgs e)
{
StatisticsTracker.ShowStatistics(this);
}
private void OnLeaderboardMenuItemClick(object sender, EventArgs e)
{
StatisticsTracker.ShowLeaderboard(this);
}
public FPickFavorites(AdvancementTracker advancementTracker, AchievementTracker achievementTracker, StatisticsTracker statisticsTracker)
{
InitializeComponent();
LoadImageDictionaries();
Populate(advancementTracker, achievementTracker, statisticsTracker);
Text += " (" + TrackerSettings.Instance.GameVersion + ")";
}
private async Task ProcessReadTaskAsync(NetworkStream netStream, SocketPayloadReadTask readTask)
{
using (readTask)
{
try
{
if (UseStatisticsTracker())
{
StatisticsTracker.IncrementGauge(StatisticGauge.ActiveReadOperation);
}
var readSize = readTask.ReadSize;
var result = new List <byte>(readSize);
var bytesReceived = 0;
while (bytesReceived < readSize)
{
readSize = readSize - bytesReceived;
var buffer = new byte[readSize];
if (OnReadFromSocketAttempt != null)
{
OnReadFromSocketAttempt(readSize);
}
bytesReceived = await netStream.ReadAsync(buffer, 0, readSize, readTask.CancellationToken).ConfigureAwait(false);
if (OnBytesReceived != null)
{
OnBytesReceived(bytesReceived);
}
if (bytesReceived <= 0)
{
using (_client)
{
_client = null;
if (_disposeToken.IsCancellationRequested)
{
return;
}
throw new BrokerConnectionException(string.Format("Lost connection to server: {0}", _endpoint), _endpoint);
}
}
result.AddRange(buffer.Take(bytesReceived));
}
readTask.Tcp.TrySetResult(result.ToArray());
}
catch (Exception ex)
{
if (_disposeToken.IsCancellationRequested)
{
var exception = new ObjectDisposedException(string.Format("Object is disposing (KafkaTcpSocket for endpoint: {0})", Endpoint));
readTask.Tcp.TrySetException(exception);
throw exception;
}
if (ex is BrokerConnectionException)
{
readTask.Tcp.TrySetException(ex);
if (_disposeToken.IsCancellationRequested)
{
return;
}
throw;
}
//if an exception made us lose a connection throw disconnected exception
if (_client == null || _client.Connected == false)
{
var exception = new BrokerConnectionException(string.Format("Lost connection to server: {0}", _endpoint), _endpoint);
readTask.Tcp.TrySetException(exception);
throw exception;
}
readTask.Tcp.TrySetException(ex);
if (_disposeToken.IsCancellationRequested)
{
return;
}
throw;
}
finally
{
if (UseStatisticsTracker())
{
StatisticsTracker.DecrementGauge(StatisticGauge.ActiveReadOperation);
}
}
}
}
private void Populate(AdvancementTracker advancementTracker, AchievementTracker achievementTracker, StatisticsTracker statisticsTracker)
{
advancementBoxes = new Dictionary <string, CheckBox>();
criterionBoxes = new Dictionary <string, CheckBox>();
statisticBoxes = new Dictionary <string, CheckBox>();
if (TrackerSettings.IsPostExplorationUpdate)
{
foreach (var advancement in advancementTracker.FullAdvancementList)
{
AddAdvancement(advancement.Key, advancement.Value);
foreach (var criterion in advancement.Value.Criteria)
{
AddCriterion(criterion);
}
}
}
else
{
foreach (var achievement in achievementTracker.FullAchievementList)
{
AddAdvancement(achievement.Key, achievement.Value);
foreach (var criterion in achievement.Value.Criteria)
{
AddCriterion(criterion);
}
}
}
foreach (var statistic in statisticsTracker.ItemCountList)
{
AddStatistic(statistic);
}
CheckBoxes();
}
public void reset()
{
foreach (Industry ind in builtItems)
{
ind.quantityStored = 0;
ind.SetRawVendors(0);
ind.setTimeRemaining(0);
ind.level = 0;
ind.consumeAmount = 0;
foreach (IndustryInput input in ind.inputs)
{
Main.Destroy(input.arrow);
}
Main.Destroy(ind.craftingGridGO);
ind.craftingGridGO = null;
ind.apprentices = 0;
ind.resetCache();
}
currentApprentices = 0;
currentVendors = 0;
builtItems = new List <Industry>();
//Debug.Log("digits: " + digits);
//double digitsCur = BigInteger.Log10(money / moneyFloor);
//Debug.Log(renown + "," + totalRenown);
BigInteger spentRenown = totalRenown - renown;
//Debug.Log("before: " + lifetimeMoney);
//TODO: Lifetime money -> renown calc is WRONG
//Immediate reset after reseting will generate renown for doing NOTHING
BigInteger newRenown = BigInteger.CubeRoot(StatisticsTracker.lifetimeMoney.value);
BigInteger totRen = newRenown;
newRenown -= StatisticsTracker.lastResetRenownGain.value;
StatisticsTracker.lastResetRenownGain.setValue(totRen);
//Debug.Log("totalRenown1: " + totalRenown);
newRenown /= 10000;
//Debug.Log("totalRenown2: " + totalRenown);
//Debug.Log("end: " + totalRenown + " - " + spentRenown + " + " + questsCompleted + " + " + newRenown + " = " + (totalRenown - spentRenown + questsCompleted));
totalRenown += questsCompletedRenown + newRenown;
renown = totalRenown - spentRenown;
StatisticsTracker.lifetimeRenown.addValue(questsCompletedRenown + newRenown);
//skillPoints += (int)digitsCur;
//moneyFloor *= 2;
money = GetStartingCash();
totalQuestsCompletedRenown = 0;
questsCompletedRenown = 0;
/*StatisticsTracker.questsCompleted.resetValue();
* StatisticsTracker.minQuestDifficulty.resetValue();
* StatisticsTracker.maxQuestDifficulty.resetValue();*/
StatisticsTracker.newLevelReset();
_questTypeCompletion.Clear();
if (StatisticsTracker.firstEnchantment.isAchieved())
{
StatisticsTracker.maxQuestDifficulty.addValue(2);
StatisticsTracker.minQuestDifficulty.addValue(1);
}
if (StatisticsTracker.firstGuildmaster.isAchieved())
{
StatisticsTracker.maxQuestDifficulty.addValue(2);
StatisticsTracker.minQuestDifficulty.addValue(1);
}
if (StatisticsTracker.relicsMade.value >= 1)
{
StatisticsTracker.maxQuestDifficulty.addValue(1);
}
if (StatisticsTracker.twentiethQuestCompleted.isAchieved())
{
StatisticsTracker.maxQuestDifficulty.addValue(2);
}
GuildManager.resetAllUpgrades();
}
public static void setupUI()
{
bool redraw = false;
Dictionary <StatAchievement, GameObject> .Enumerator achlist = achLookup.GetEnumerator();
while (achlist.MoveNext())
{
KeyValuePair <StatAchievement, GameObject> item = achlist.Current;
item.Value.transform.Find("Image").GetComponent <Image>().sprite = SpriteLoader.getSpriteForResource(item.Key.achieveImage + (item.Key.isAchieved() ? "" : "_off"));
if (item.Key is AchievementMulti)
{
AchievementMulti mult = (AchievementMulti)item.Key;
int numChecked = mult.getNumAchieved();
for (int j = 1; j <= mult.getNumValues(); j++)
{
Image img = item.Value.transform.Find("Check(" + j + ")").GetComponent <Image>();
if (j <= numChecked)
{
img.sprite = GuiManager.instance.checkOn;
img.color = ColorHelper.DGREEN;
}
else
{
img.sprite = GuiManager.instance.checkOff;
img.color = ColorHelper.DRED;
}
}
item.Value.transform.Find("Description").GetComponent <Text>().text = string.Format(Localization.translateToLocal(item.Key.description), Main.AsCurrency(mult.getNextValue(), 6));
}
else
{
item.Value.transform.Find("Progress").GetComponent <Text>().text = item.Key.isAchieved() ? "Completed" : "In progress";
}
if (!item.Key.isHidden && !item.Value.activeSelf)
{
redraw = true;
}
}
Dictionary <IStat, GameObject> .Enumerator statlist = statLookup.GetEnumerator();
while (statlist.MoveNext())
{
KeyValuePair <IStat, GameObject> item = statlist.Current;
item.Value.transform.Find("Progress").GetComponent <Text>().text = item.Key.getDisplay();
item.Value.transform.Find("Description").GetComponent <Text>().text = item.Key.description;
if (!item.Key.isHidden && !item.Value.activeSelf)
{
redraw = true;
}
}
if (redraw)
{
IEnumerator <StatAchievement> list = StatisticsTracker.getAchievementsList();
int h = 0;
while (list.MoveNext())
{
StatAchievement item = list.Current;
if (!achLookup.ContainsKey(item))
{
continue;
}
GameObject obj = achLookup[item];
obj.transform.localPosition = new Vector3(11, -50 * h - 11, 0);
if (item.isHidden)
{
obj.SetActive(false);
continue;
}
obj.SetActive(true);
h++;
}
((RectTransform)achievList.transform).SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, 50 * h + 18);
IEnumerator <IStat> list2 = StatisticsTracker.getStatsList();
h = 0;
while (list2.MoveNext())
{
IStat item = list2.Current;
if (!statLookup.ContainsKey(item))
{
continue;
}
GameObject obj = statLookup[item];
obj.transform.localPosition = new Vector3(11, -50 * h - 11, 0);
if (item.isHidden)
{
obj.SetActive(false);
continue;
}
obj.SetActive(true);
h++;
}
((RectTransform)statsList.transform).SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, 50 * h + 18);
}
}
public static void OneTimeSetup()
{
achievList = GuiManager.instance.achievementsArea.transform.Find("Achievements").GetChild(1).GetChild(0);
statsList = GuiManager.instance.achievementsArea.transform.Find("Statistics").GetChild(1).GetChild(0);
IEnumerator <StatAchievement> list = StatisticsTracker.getAchievementsList();
int h = 0;
while (list.MoveNext())
{
GameObject obj;
StatAchievement item = list.Current;
if (item.isHidden && !item.isSecret)
{
continue;
}
if (item is AchievementMulti)
{
obj = GameObject.Instantiate(PrefabManager.instance.ACHIEVEMENT_MULTI_LISTITEM, achievList) as GameObject;
}
else
{
obj = GameObject.Instantiate(PrefabManager.instance.ACHIEVEMENT_LISTITEM, achievList) as GameObject;
obj.transform.Find("Progress").GetComponent <Text>().text = item.isAchieved() ? "Completed" : "In progress";
}
obj.transform.localPosition = new Vector3(11, -50 * h - 11, 0);
obj.transform.Find("Name").GetComponent <Text>().text = Localization.translateToLocal(item.achieveName);
obj.transform.Find("Description").GetComponent <Text>().text = Localization.translateToLocal(item.description);
obj.transform.Find("Image").GetComponent <Image>().sprite = SpriteLoader.getSpriteForResource(item.achieveImage + (item.isAchieved() ? "":"_off"));
achLookup.Add(item, obj);
if (item.isSecret)
{
obj.SetActive(false);
continue;
}
h++;
}
((RectTransform)achievList.transform).SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, 50 * h + 18);
IEnumerator <IStat> list2 = StatisticsTracker.getStatsList();
h = 0;
while (list2.MoveNext())
{
IStat item = list2.Current;
if (item.isHidden)
{
continue;
}
GameObject obj = GameObject.Instantiate(PrefabManager.instance.ACHIEVEMENT_LISTITEM, statsList) as GameObject;
obj.transform.localPosition = new Vector3(11, -50 * h - 11, 0);
Transform trans;
trans = obj.transform.Find("Name");
trans.GetComponent <Text>().text = Localization.translateToLocal(item.statName);
trans.localPosition -= new Vector3(35, 0, 0);
trans = obj.transform.Find("Description");
trans.GetComponent <Text>().text = item.description;
trans.localPosition -= new Vector3(35, 0, 0);
string txt = item.getDisplay();
obj.transform.Find("Progress").GetComponent <Text>().text = txt;
obj.transform.Find("Image").gameObject.SetActive(false);
obj.transform.Find("BG").gameObject.SetActive(false);
statLookup.Add(item, obj);
h++;
}
((RectTransform)statsList.transform).SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, 50 * h + 18);
}
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
info.AddValue("SaveVersion", 24);
info.AddValue("money", money.ToString());
info.AddValue("moneyFloor", moneyFloor.ToString());
//info.AddValue("lifetimeMoney", StatisticsTracker.lifetimeMoney.ToString());
info.AddValue("renown", renown.ToString());
info.AddValue("totalRenown", totalRenown.ToString());
info.AddValue("maxVendors", maxVendors);
info.AddValue("currentVendors", currentVendors);
info.AddValue("maxApprentices", maxApprentices);
info.AddValue("journeymen", journeymen);
info.AddValue("currentApprentices", currentApprentices);
info.AddValue("totalQuestsCompleted", totalQuestsCompletedRenown);
info.AddValue("questsCompleted", questsCompletedRenown);
info.AddValue("skillPoints", skillPoints.ToString());
info.AddValue("totalSkillPoints", totalSkillPoints.ToString());
info.AddValue("resetLevel", resetLevel);
info.AddValue("researchTime", researchTime);
info.AddValue("miscInventorySize", miscInventory.Count);
for (int i = 0; i < miscInventory.Count; i++)
{
info.AddValue("miscInventory_" + i, miscInventory[i], typeof(ItemStack));
}
info.AddValue("unidentifiedRelicsSize", unidentifiedRelics.Count);
for (int i = 0; i < unidentifiedRelics.Count; i++)
{
info.AddValue("unidentifiedRelics_" + i, unidentifiedRelics[i], typeof(ItemStack));
}
info.AddValue("builtItemsSize", builtItems.Count);
for (int i = 0; i < builtItems.Count; i++)
{
info.AddValue("buildItemID_" + i, builtItems[i].saveName);
info.AddValue("builtItems_" + i, builtItems[i], typeof(Industry));
}
FieldInfo[] fields = typeof(Industries).GetFields();
info.AddValue("allIndustries", fields.Length);
for (int i = 0; i < fields.Length; i++)
{
FieldInfo field = fields[i];
Industry item = (Industry)field.GetValue(null);
info.AddValue("allIndustriesID_" + i, item.saveName);
info.AddValue("allIndustriesX_" + i, item.getGridPos().x);
info.AddValue("allIndustriesY_" + i, item.getGridPos().y);
info.AddValue("allIndustriesAB_" + i, item.doAutobuild);
info.AddValue("allIndustriesABLvl_" + i, item.autoBuildLevel);
info.AddValue("allIndustriesABMag_" + i, item.autoBuildMagnitude);
info.AddValue("allIndustriesABVend_" + i, item.startingVendors);
}
//Debug.Log("Saving " + QuestManager.activeQuests.Count + " active quests");
info.AddValue("activeQuestsSize", QuestManager.activeQuests.Count);
for (int i = 0; i < QuestManager.activeQuests.Count; i++)
{
info.AddValue("activeQuests_" + i, QuestManager.activeQuests[i], typeof(Quest));
}
//Debug.Log("Saving " + QuestManager.availableQuests.Count + " available quests");
info.AddValue("availableQuestsSize", QuestManager.availableQuests.Count);
for (int i = 0; i < QuestManager.availableQuests.Count; i++)
{
info.AddValue("availableQuests_" + i, QuestManager.availableQuests[i], typeof(Quest));
}
info.AddValue("availableRelicsSize", QuestManager.availableRelics.Count);
for (int i = 0; i < QuestManager.availableRelics.Count; i++)
{
info.AddValue("availableRelics_" + i, QuestManager.availableRelics[i], typeof(ItemStack));
}
info.AddValue("questTypeCompletion", questTypeCompletion, typeof(Dictionary <string, long>));
info.AddValue("newQuestTimer", QuestManager.getNewQuestTimer());
info.AddValue("questEquipTimer", QuestManager.getEquipTimer());
GuildManager.writeSaveData(ref info, ref context);
StatisticsTracker.serializeAllStats(ref info, ref context);
info.AddValue("currentGuildmaster", currentGuildmaster, typeof(Master));
DeepGoalsTypes.serialize(ref info, ref context);
info.AddValue("ResearchManager.lastViewDate", ResearchManager.lastViewDate.ToLongTimeString());
TutorialManager.serialize(ref info, ref context);
}
public void Start()
{
StatisticsTracker.Initialise(display);
}
public PlayerInfo(SerializationInfo info, StreamingContext context)
{
//Main.instance.player.SetDefaultUpgrades();
#pragma warning disable 0168
try {
Main.saveVersionFromDisk = info.GetInt32("SaveVersion");
}
catch (Exception ex) {
Main.saveVersionFromDisk = 0;
}
#pragma warning restore 0168
// To future self: this turned into a dirty hack
// Because how how upgrades were handled
// :(
Main.instance.player.builtItems = new List <Industry>();
Main.instance.player.money = BigInteger.Parse(info.GetString("money"));
Main.instance.player.moneyFloor = BigInteger.Parse(info.GetString("moneyFloor"));
//StatisticsTracker.lifetimeMoney.setValue(BigInteger.Parse(info.GetString("lifetimeMoney")));
Main.instance.player.renown = BigInteger.Parse(info.GetString("renown"));
Main.instance.player.totalRenown = BigInteger.Parse(info.GetString("totalRenown"));
Main.instance.player.maxVendors = info.GetInt32("maxVendors");
Main.instance.player.currentVendors = info.GetInt32("currentVendors");
Main.instance.player.maxApprentices = info.GetInt32("maxApprentices");
if (Main.saveVersionFromDisk >= 6)
{
Main.instance.player.journeymen = info.GetInt32("journeymen");
}
Main.instance.player.currentApprentices = info.GetInt32("currentApprentices");
Main.instance.player.totalQuestsCompletedRenown = info.GetInt64("totalQuestsCompleted");
Main.instance.player.questsCompletedRenown = info.GetInt64("questsCompleted");
if (Main.saveVersionFromDisk < 8)
{
Main.instance.player.skillPoints = info.GetInt32("skillPoints");
}
else
{
Main.instance.player.skillPoints = BigInteger.Parse(info.GetString("skillPoints"));
Main.instance.player.totalSkillPoints = BigInteger.Parse(info.GetString("totalSkillPoints"));
}
Main.instance.player.resetLevel = info.GetInt32("resetLevel");
Main.instance.player.researchTime = (float)info.GetDouble("researchTime");
int num;
num = info.GetInt32("miscInventorySize");
//miscInventory = new List<ItemStack>();
for (int o = 0; o < num; o++)
{
Main.instance.player.miscInventory.Add((ItemStack)info.GetValue("miscInventory_" + o, typeof(ItemStack)));
}
num = info.GetInt32("unidentifiedRelicsSize");
//unidentifiedRelics = new List<ItemStack>();
for (int o = 0; o < num; o++)
{
Main.instance.player.unidentifiedRelics.Add((ItemStack)info.GetValue("unidentifiedRelics_" + o, typeof(ItemStack)));
}
num = info.GetInt32("builtItemsSize");
for (int o = 0; o < num; o++)
{
Industry temp;
if (Main.saveVersionFromDisk >= 14)
{
string id = info.GetString("buildItemID_" + o);
temp = (Industry)info.GetValue("builtItems_" + o, typeof(Industry));
Main.instance.player.industriesFromDisk.Add(new IndustryLoadWrapper(temp, id));
}
else
{
int id = info.GetInt32("buildItemID_" + o);
temp = (Industry)info.GetValue("builtItems_" + o, typeof(Industry));
Main.instance.player.industriesFromDisk.Add(new IndustryLoadWrapper(temp, id));
}
}
if (Main.saveVersionFromDisk >= 13)
{
FieldInfo[] fields = typeof(Industries).GetFields();
num = info.GetInt32("allIndustries");
for (int o = 0; o < num; o++)
{
if (Main.saveVersionFromDisk >= 14)
{
Industry item = GameRegistry.GetIndustryByID(info.GetString("allIndustriesID_" + o));
item.setGridPos(new Vector3((float)info.GetDouble("allIndustriesX_" + o), (float)info.GetDouble("allIndustriesY_" + o), 0));
if (Main.saveVersionFromDisk >= 17)
{
item.doAutobuild = info.GetBoolean("allIndustriesAB_" + o);
item.autoBuildLevel = info.GetInt32("allIndustriesABLvl_" + o);
item.autoBuildMagnitude = info.GetInt32("allIndustriesABMag_" + o);
if (Main.saveVersionFromDisk >= 19)
{
item.startingVendors = info.GetInt32("allIndustriesABVend_" + o);
}
}
}
else
{
FieldInfo field = fields[o];
Industry item = (Industry)field.GetValue(null);
item.setGridPos(new Vector3((float)info.GetDouble("allIndustriesX_" + o), (float)info.GetDouble("allIndustriesY_" + o), 0));
}
}
}
num = info.GetInt32("activeQuestsSize");
//Debug.Log("Reading " + num + " active quests");
for (int o = 0; o < num; o++)
{
Quest temp = (Quest)info.GetValue("activeQuests_" + o, typeof(Quest));
//quest obstacle type data from disk isn't actually available yet
Main.instance.player.activeQuestsFromDisk.Add(new QuestLoadWrapper(temp));
}
num = info.GetInt32("availableQuestsSize");
//Debug.Log("Reading " + num + " available quests");
for (int o = 0; o < num; o++)
{
Quest temp = (Quest)info.GetValue("availableQuests_" + o, typeof(Quest));
//quest obstacle type data from disk isn't actually available yet
Main.instance.player.questsFromDisk.Add(new QuestLoadWrapper(temp));
}
num = info.GetInt32("availableRelicsSize");
for (int o = 0; o < num; o++)
{
QuestManager.availableRelics.Add((ItemStack)info.GetValue("availableRelics_" + o, typeof(ItemStack)));
}
if (Main.saveVersionFromDisk >= 10)
{
Main.instance.player._questTypeCompletion = (Dictionary <string, long>)info.GetValue("questTypeCompletion", typeof(Dictionary <string, long>));
}
float f = (float)info.GetDouble("newQuestTimer");
QuestManager.LoadTimerFromSave(f);
if (Main.saveVersionFromDisk >= 11)
{
QuestManager.setEquipTimer((float)info.GetDouble("questEquipTimer"));
}
if (Main.saveVersionFromDisk >= 2)
{
GuildManager.readSaveData(ref info, ref context);
}
if (Main.saveVersionFromDisk >= 7)
{
StatisticsTracker.deserializeAllStats(ref info, ref context);
}
if (Main.saveVersionFromDisk >= 8)
{
Main.instance.player.currentGuildmaster = (Master)info.GetValue("currentGuildmaster", typeof(Master));
}
else
{
Main.instance.player.currentGuildmaster = new Master();
}
if (Main.saveVersionFromDisk >= 12)
{
DeepGoalsTypes.deserialize(ref info, ref context);
}
if (Main.saveVersionFromDisk >= 22)
{
ResearchManager.lastViewDate = DateTime.Parse(info.GetString("ResearchManager.lastViewDate"));
}
TutorialManager.deserialize(ref info, ref context);
}
