private void StartNewGameRoutine()
{
//begin mod
var m_MapName = this.Find <UITextField>("MapName");
var m_FileList = this.Find <UIListBox>("MapList");
//end mod
SimulationMetaData ngs = new SimulationMetaData()
{
m_CityName = m_MapName.text, m_gameInstanceIdentifier = Guid.NewGuid().ToString(), m_invertTraffic = !this.Find <UICheckBox>("InvertTraffic").isChecked ? SimulationMetaData.MetaBool.False : SimulationMetaData.MetaBool.True, m_disableAchievements = Singleton <PluginManager> .instance.enabledModCount <= 0 ? SimulationMetaData.MetaBool.False : SimulationMetaData.MetaBool.True, m_currentDateTime = DateTime.Now, m_newGameAppVersion = 159507472, m_updateMode = SimulationManager.UpdateMode.NewGameFromMap
};
//begin mod
ngs.m_environment = m_forceEnvironment;
//end mod
MapMetaData listingMetaData = this.GetListingMetaData(m_FileList.selectedIndex);
if (listingMetaData.mapThemeRef != null)
{
Package.Asset assetByName = PackageManager.FindAssetByName(listingMetaData.mapThemeRef);
if (assetByName != (Package.Asset)null)
{
ngs.m_MapThemeMetaData = assetByName.Instantiate <MapThemeMetaData>();
ngs.m_MapThemeMetaData.SetSelfRef(assetByName);
}
}
Singleton <LoadingManager> .instance.LoadLevel(this.GetListingData(m_FileList.selectedIndex), "Game", "InGame", ngs);
UIView.library.Hide(this.GetType().Name, 1);
}
public void LoadSavedGame2(Package.Asset savedGame)
{
LogCalled();
AssertNotNull(savedGame, "could not find save");
var metaData = savedGame?.Instantiate <SaveGameMetaData>();
AssertNotNull(metaData, "metadata");
AssertNotNull(metaData.assetRef, "assetRef");
var package = savedGame.package ?? metaData.assetRef.package;
AssertNotNull(package, "package");
PrintModsInfo(metaData.mods);
SimulationMetaData ngs = new SimulationMetaData {
m_CityName = metaData.cityName,
m_updateMode = SimulationManager.UpdateMode.LoadGame,
};
if (package.GetPublishedFileID() != PublishedFileId.invalid)
{
ngs.m_disableAchievements = MetaBool.True;
}
UpdateTheme(metaData.mapThemeRef, ngs);
Log.Info($"Loading new game from " +
$"map:{ngs.m_CityName} " +
$"assetName:{savedGame.name} " +
$"filePath:{package.packagePath}) " +
$"theme={(ngs.m_MapThemeMetaData?.name).ToSTR()} " +
$"LHT:{ngs.m_invertTraffic}", true);
LoadGame(metaData, ngs);
}
/// <summary>
/// Load the world byte array sent by the server
/// </summary>
public static void LoadLevel(byte[] world)
{
Log.Info($"Preparing to load world (of size {world.Length})...");
// Load the package
Package package = new Package(SYNC_NAME, world);
// Ensure that the LoadingManager is ready.
// Don't know if thats really necessary but doesn't hurt either. - root#0042
Singleton <LoadingManager> .Ensure();
// Get the meta data
Package.Asset asset = package.Find(package.packageMainAsset);
SaveGameMetaData metaData = asset.Instantiate <SaveGameMetaData>();
// Build the simulation
SimulationMetaData simulation = new SimulationMetaData()
{
m_CityName = metaData.cityName,
m_updateMode = SimulationManager.UpdateMode.LoadGame,
m_environment = UIView.GetAView().panelsLibrary.Get <LoadPanel>("LoadPanel").m_forceEnvironment
};
// Load the level
Log.Info("Telling the loading manager to load the level");
Singleton <LoadingManager> .instance.LoadLevel(metaData.assetRef, "Game", "InGame", simulation, false);
}
public void OnLoad()
{
if ((!SavePanel.isSaving && Singleton <LoadingManager> .exists) && !Singleton <LoadingManager> .instance.m_currentlyLoading)
{
ServerSettings.Name = m_serverNameTextbox.text;
ServerSettings.Port = int.Parse(m_serverPortTextbox.text);
ServerSettings.Private = m_serverPrivateCheckbox.isChecked;
ServerSettings.IsHosting = true;
base.CloseEverything();
m_LastSaveName = base.GetListingName(this.m_SaveList.selectedIndex);
SavePanel.lastLoadedName = m_LastSaveName;
SaveGameMetaData listingMetaData = base.GetListingMetaData(this.m_SaveList.selectedIndex);
base.PrintModsInfo(listingMetaData);
Package.Asset listingData = base.GetListingData(this.m_SaveList.selectedIndex);
SavePanel.lastCloudSetting = (listingData.package != null) && PackageManager.IsSteamCloudPath(listingData.package.packagePath);
SimulationMetaData ngs = new SimulationMetaData
{
m_CityName = listingMetaData.cityName,
m_updateMode = SimulationManager.UpdateMode.LoadGame,
m_environment = this.m_forceEnvironment
};
if ((Singleton <PluginManager> .instance.enabledModCount > 0) || ((listingData.package != null) && (listingData.package.GetPublishedFileID() != PublishedFileId.invalid)))
{
ngs.m_disableAchievements = SimulationMetaData.MetaBool.True;
}
Singleton <LoadingManager> .instance.LoadLevel(listingData, "Game", "InGame", ngs);
UIView.library.Hide(base.GetType().Name, 1);
Debug.Log("menuid " + listingData.package.GetPublishedFileID());
}
}
public void LoadAssetEditor(bool load = true, bool lht = false, bool lsm = true)
{
LogCalled();
//Patches.ForceLSMPatch.ForceLSM = lsm;
var mode = load ?
SimulationManager.UpdateMode.LoadAsset :
SimulationManager.UpdateMode.NewAsset;
Package.Asset theme = GetDefaultTheme();
AssertNotNull(theme, "theme not found");
var themeMetaData = theme.Instantiate <SystemMapMetaData>();
AssertNotNull(themeMetaData, "themeMetaData");
SimulationMetaData ngs = new SimulationMetaData {
m_gameInstanceIdentifier = Guid.NewGuid().ToString(),
m_WorkshopPublishedFileId = PublishedFileId.invalid,
m_updateMode = mode,
//m_MapThemeMetaData = themeMetaData,
m_invertTraffic = lht ? MetaBool.True : MetaBool.False,
};
Singleton <LoadingManager> .instance.LoadLevel(themeMetaData.assetRef, "AssetEditor", "InAssetEditor", ngs, false);
}
private void updateSimulationProperties(Simulation simulation, SimulationMetaData simMetaData)
{
simulation.UsedBuildingBlocks.Each(bb => simMetaData.AddBuildingBlock(mapFrom(bb)));
simMetaData.Properties.Data = _serializationManager.Serialize(simulation.Properties);
simulation.UsedObservedData.Each(x => simMetaData.AddObservedData(x.Id));
simulation.Analyses.Each(chart => simMetaData.AddChart(mapFrom(chart)));
}
public static SaveGameMetaData GetMetaDataForDateTime(DateTime needle)
{
SaveGameMetaData result = null;
foreach (Package.Asset current in PackageManager.FilterAssets(new Package.AssetType[]
{
UserAssetType.SaveGameMetaData
}))
{
if (current != null && current.isEnabled)
{
SaveGameMetaData saveGameMetaData = current.Instantiate <SaveGameMetaData>();
if (saveGameMetaData != null)
{
try
{
Stream s = saveGameMetaData.assetRef.GetStream();
SimulationMetaData mysimmeta = DataSerializer.Deserialize <SimulationMetaData>(s,
DataSerializer.Mode.File);
if (mysimmeta.m_currentDateTime.Equals(needle))
{
return(saveGameMetaData);
}
}
catch (Exception ex)
{
ex.ToString();
}
}
}
}
return(result);
}
private void deserializeResults(IMoBiSimulation moBiSimulation, SimulationMetaData simulationMetaData, SerializationContext serializationContext)
{
foreach (var historicalResult in simulationMetaData.HistoricalResults)
{
var dataRepository = deserializeContent <DataRepository>(historicalResult.Content, serializationContext);
dataRepository.SetPersistable(true);
moBiSimulation.HistoricResults.Add(dataRepository);
}
}
private SimulationMetaData createFor(Simulation simulation, SimulationMode simulationMode)
{
var simDeta = new SimulationMetaData {
SimulationMode = simulationMode
};
updateSimulationProperties(simulation, simDeta);
return(simDeta);
}
public Simulation MapFrom(SimulationMetaData simulationMetaData)
{
var simulation = simulationFrom(simulationMetaData.SimulationMode);
simulationMetaData.BuildingBlocks.Each(bb => simulation.AddUsedBuildingBlock(mapFrom(bb)));
//no lazy load need for the simulation properties
simulation.Properties = _serializationManager.Deserialize <SimulationProperties>(simulationMetaData.Properties.Data);
simulationMetaData.UsedObservedData.Each(o => simulation.AddUsedObservedData(mapFrom(o)));
return(simulation);
}
private void addSimulationToProject(SimulationMetaData simulationMetaData, SerializationContext serializationContext)
{
var simulation = deserializeContent <IMoBiSimulation>(simulationMetaData.Content, serializationContext);
_project.AddSimulation(simulation);
deserializeResults(simulation, simulationMetaData, serializationContext);
//Ensure that all references to simulations (Simulation itself, results etc) are available in the serialization context
serializationContext.AddRepository(simulation.Results);
simulation.HistoricResults.Each(serializationContext.AddRepository);
serializationContext.Register(simulation);
}
public override void GlobalContext()
{
base.GlobalContext();
_sim1 = new SimulationMetaData {
Id = "sim1", Name = "sim1"
};
_sim1.AddObservedData("ObsData1");
_sim2 = new SimulationMetaData {
Id = "sim2", Name = "sim2"
};
_sim2.AddObservedData("ObsData1");
}
public static void LoadWorld(byte[] worldBuffer, byte[] simulationBuffer)
{
using (MemoryStream ms = new MemoryStream(simulationBuffer))
{
SimulationMetaData simulationData = DataSerializer.Deserialize <SimulationMetaData>(ms, DataSerializer.Mode.Memory);
Package.Asset game = new Package.Asset("multiplayer-game", worldBuffer, Package.AssetType.Unknown, false);
// Load the level
Singleton <LoadingManager> .instance.LoadLevel(game, "Game", "InGame", simulationData, false);
}
}
static void UpdateTheme(string mapThemeRef, SimulationMetaData ngs)
{
if (!string.IsNullOrEmpty(mapThemeRef))
{
Package.Asset asset = PackageManager.FindAssetByName(mapThemeRef, UserAssetType.MapThemeMetaData);
if (asset != null)
{
ngs.m_MapThemeMetaData = asset.Instantiate <MapThemeMetaData>();
ngs.m_MapThemeMetaData.SetSelfRef(asset);
}
}
}
public override void GlobalContext()
{
base.GlobalContext();
sut = new ProjectMetaData {
Name = "Project", Id = 1
};
_simulation = new SimulationMetaData {
Id = "SimulationMetaDataId", Name = "tralala"
};
_simulation.SimulationResults = DomainHelperForSpecs.CreateSimulationResults();
sut.BuildingBlocks.Add(_simulation);
}
public override void GlobalContext()
{
base.GlobalContext();
sut = new SimulationMetaData {
Id = "SimulationMetaDataId", Name = "tralala"
};
sut.AddObservedData("ObsData1");
using (var session = _sessionFactory.OpenSession())
using (var transaction = session.BeginTransaction())
{
session.Save(sut);
transaction.Commit();
}
}
private SimulationMetaData mapFrom(IMoBiSimulation simulation)
{
var simulationMetaData = new SimulationMetaData {
Id = simulation.Id
};
if (!simulation.HasChanged)
{
return(simulationMetaData);
}
serialize(simulationMetaData, simulation);
simulation.HistoricResults.Where(x => x.IsPersistable()).Each(res => simulationMetaData.AddHistoricalResults(mapFrom(res)));
return(simulationMetaData);
}
protected override void Context()
{
base.Context();
_session = _sessionFactory.OpenSession();
A.CallTo(() => _sessionManager.OpenSession()).Returns(_session);
_simulation = new SimulationMetaData();
_simulation.Id = "ugygy";
_simulation.Name = " toto";
using (var session = _sessionFactory.OpenSession())
using (var transaction = session.BeginTransaction())
{
session.Save(_simulation);
transaction.Commit();
}
}
static void Prefix(Package.Asset asset, string playerScene, string uiScene, SimulationMetaData ngs, bool forceEnvironmentReload)
{
if (ngs == null)
{
return;
}
Log.Info("LoadLevelCoroutine called with arguments: " +
$"asset={asset.name} playerScene={playerScene} uiScene={uiScene} forceEnvironmentReload={forceEnvironmentReload}\n" +
$"ngs=[ " +
$"map:{ngs.m_CityName} " +
$"theme:{(ngs.m_MapThemeMetaData?.name).ToSTR()} " +
$"environment:{ngs.m_environment.ToSTR()} " +
$"LHT:{ngs.m_invertTraffic} " +
$"disableAchievements:{ngs.m_disableAchievements} " +
$"updateMode={ngs.m_updateMode}\n" +
$"filePath:{asset.package?.packagePath}) " +
"]\n" + Environment.StackTrace);
}
void StartGame(Package.Asset package)
{
m_connectionInfoLabel.text = "Game Starting";
SaveGameMetaData mmd = package.Instantiate <SaveGameMetaData>();
SavePanel.lastLoadedName = package.name;
Debug.Log(mmd.cityName);
SimulationMetaData ngs = new SimulationMetaData
{
m_CityName = mmd.cityName,
m_updateMode = SimulationManager.UpdateMode.LoadGame,
m_environment = "",
m_disableAchievements = SimulationMetaData.MetaBool.True
};
Singleton <LoadingManager> .instance.LoadLevel(mmd.assetRef, "Game", "InGame", ngs);
}
public override void GlobalContext()
{
base.GlobalContext();
A.CallTo(() => _sessionManager.OpenSession()).ReturnsLazily(() => _sessionFactory.OpenSession());
_simulation = new SimulationMetaData {
Id = "tralala", Name = " toto"
};
_simulation.SimulationAnalyses = new SimulationAnalysesMetaData {
Content = { Data = Encoding.UTF8.GetBytes("Content") }
};
using (var session = _sessionFactory.OpenSession())
using (var transaction = session.BeginTransaction())
{
session.Save(_simulation);
transaction.Commit();
}
}
private void StartGame(Package.Asset package)
{
ConnectSettings.Ip = m_serverList[m_selectedIndex]["ip"];
ConnectSettings.Port = int.Parse(m_serverList[m_selectedIndex]["port"]);
SaveGameMetaData mmd = package.Instantiate <SaveGameMetaData>();
SavePanel.lastLoadedName = package.name;
SimulationMetaData ngs = new SimulationMetaData
{
m_CityName = mmd.cityName,
m_updateMode = SimulationManager.UpdateMode.LoadGame,
m_environment = "",
m_disableAchievements = SimulationMetaData.MetaBool.True
};
Singleton <LoadingManager> .instance.LoadLevel(mmd.assetRef, "Game", "InGame", ngs);
}
public override void GlobalContext()
{
base.GlobalContext();
_projectMetaData = new ProjectMetaData {
Name = "Project"
};
_simulationMetaData = new SimulationMetaData {
Id = "PopSim", SimulationMode = SimulationMode.Population, Name = "Sim"
};
_simulationMetaData.SimulationResults = DomainHelperForSpecs.CreateSimulationResults(_numberOfIndividuals, numberOfPaths: 2);
_projectMetaData.AddBuildingBlock(_simulationMetaData);
using (var session = _sessionFactory.OpenSession())
using (var transaction = session.BeginTransaction())
{
session.Save(_projectMetaData);
transaction.Commit();
}
}
public void LaunchRowObject(UIComponent component)
{
UIPanel panel = component as UIPanel;
if (panel != null)
{
SaveGameRowStruct sgrs = panel.objectUserData as SaveGameRowStruct;
if (sgrs != null)
{
if (SavePanel.isSaving || !Singleton <LoadingManager> .exists || Singleton <LoadingManager> .instance.m_currentlyLoading)
{
return;
}
//this.CloseEverything();
WorldInfoPanel.HideAllWorldInfoPanels();
SaveGameMetaData listingMetaData = sgrs.saveMeta; // this.GetListingMetaData(this.m_SaveList.selectedIndex);
Package.Asset listingData = sgrs.saveMeta.assetRef; // this.GetListingData(this.m_SaveList.selectedIndex);
SimulationMetaData ngs = new SimulationMetaData()
{
m_CityName = listingMetaData.cityName,
m_updateMode = SimulationManager.UpdateMode.LoadGame //,
//m_environment = this.m_forceEnvironment
};
if (Singleton <PluginManager> .instance.enabledModCount > 0 || listingData.package.GetPublishedFileID() != PublishedFileId.invalid)
{
ngs.m_disableAchievements = SimulationMetaData.MetaBool.True;
}
Singleton <LoadingManager> .instance.LoadLevel(listingData, "Game", "InGame", ngs);
//UIView.library.Hide(this.GetType().Name, 1);
ParentBetterLoadPanelWrapper.Hide();
}
}
}
public override void GlobalContext()
{
base.GlobalContext();
_session = _sessionFactory.OpenSession();
A.CallTo(() => _sessionManager.OpenSession()).Returns(_session);
A.CallTo(() => _sessionManager.IsOpen).Returns(true);
_simulation = new SimulationMetaData {
Id = "tralala", Name = " toto"
};
_simResults = DomainHelperForSpecs.CreateSimulationResults();
_simulation.SimulationResults = _simResults;
using (var session = _sessionFactory.OpenSession())
using (var transaction = session.BeginTransaction())
{
session.Save(_simulation);
transaction.Commit();
}
_result = sut.ResultFor(_simulation.Id);
}
protected override void Context()
{
base.Context();
_session = _sessionFactory.OpenSession();
A.CallTo(() => _sessionManager.OpenSession()).Returns(_session);
_simulation = new SimulationMetaData {
Id = "tralala", Name = " toto"
};
_simulation.AddChart(new SimulationChartMetaData {
Id = "Chart1", Name = "Chart1", Content = { Data = Encoding.UTF8.GetBytes("chart1") }
});
_simulation.AddChart(new SimulationChartMetaData {
Id = "Chart2", Name = "Chart2", Content = { Data = Encoding.UTF8.GetBytes("chart2") }
});
using (var session = _sessionFactory.OpenSession())
using (var transaction = session.BeginTransaction())
{
session.Save(_simulation);
transaction.Commit();
}
}
public void should_be_able_to_save_the_simulation()
{
var newSimulation = new SimulationMetaData {
Id = "SimulationMetaDataId", Name = "tralala"
};
newSimulation.AddObservedData("ObsData1");
newSimulation.AddObservedData("ObsData2");
using (var session = _sessionFactory.OpenSession())
using (var transaction = session.BeginTransaction())
{
var simulationFromDb = session.Get <SimulationMetaData>(sut.Id);
simulationFromDb.UpdateFrom(newSimulation, session);
transaction.Commit();
}
using (var session = _sessionFactory.OpenSession())
{
var simulationFromDb = session.Get <SimulationMetaData>(sut.Id);
simulationFromDb.UsedObservedData.Count.ShouldBeEqualTo(2);
}
}
public override void GlobalContext()
{
base.GlobalContext();
_projectMetaData = new ProjectMetaData {
Name = "Project"
};
_simulationMetaData = new SimulationMetaData {
Id = "Id", SimulationMode = SimulationMode.Individual, Name = "Sim"
};
_simulationChartMetaData = new SimulationChartMetaData {
Id = "Chart", Name = "Chart"
};
_simulationMetaData.Charts.Add(_simulationChartMetaData);
_projectMetaData.AddBuildingBlock(_simulationMetaData);
//save project once
using (var session = _sessionFactory.OpenSession())
using (var transaction = session.BeginTransaction())
{
session.Save(_projectMetaData);
transaction.Commit();
}
//then delete chart to simulation lazy loading
_simulationMetaData.Charts.Clear();
_simulationMetaData.Content.Data = null;
_simulationMetaData.IsLoaded.ShouldBeFalse();
//update project again. The charts should not be clear
using (var session = _sessionFactory.OpenSession())
using (var transaction = session.BeginTransaction())
{
var projectMetaData = session.CreateCriteria <ProjectMetaData>().List <ProjectMetaData>().First();
projectMetaData.UpdateFrom(_projectMetaData, session);
transaction.Commit();
}
}
public void LoadMap2(Package.Asset map, bool lht = false)
{
LogCalled();
AssertNotNull(map, "map not found");
var metaData = map?.Instantiate <MapMetaData>();
AssertNotNull(metaData, "metadata");
AssertNotNull(metaData.assetRef, "assetRef");
var package = map.package ?? metaData.assetRef.package;
AssertNotNull(package, "package");
PrintModsInfo(metaData.mods);
SimulationMetaData ngs = new SimulationMetaData {
m_CityName = metaData.mapName,
m_gameInstanceIdentifier = Guid.NewGuid().ToString(),
m_invertTraffic = lht ? MetaBool.True : MetaBool.False,
m_disableAchievements = MetaBool.True,
m_startingDateTime = DateTime.Now,
m_currentDateTime = DateTime.Now,
m_newGameAppVersion = DataLocation.productVersion,
m_updateMode = SimulationManager.UpdateMode.NewGameFromMap,
};
UpdateTheme(metaData.mapThemeRef, ngs);
Log.Info($"Loading new game from " +
$"map:{ngs.m_CityName} " +
$"fileName:{map.name} " +
$"filePath:{package.packagePath}) " +
$"theme={(ngs.m_MapThemeMetaData?.name).ToSTR()}" +
$"LHT:{ngs.m_invertTraffic}", true);
LoadGame(metaData, ngs);
}
public static void StartSession(string mapName, string playerMap, SimulationManager.UpdateMode mode, SimulationMetaData ngs)
{
try
{
if (Mod.IsEnabled && Helper.HasTelemFlag(Mod.config.TelemetryLevel, Helper.TelemOption.DisableAll) ||
Helper.HasTelemFlag(Mod.config.TelemetryLevel, Helper.TelemOption.DisableStartSession))
{
if (Mod.DEBUG_LOG_ON) { Helper.dbgLog("Start Session telemetry disabled."); }
return;
}
TelemetryKH telemetry = new TelemetryKH();
telemetry.AddEvent("start_session", new Telemetry.Pair[]
{
new Telemetry.Pair("type", playerMap),
new Telemetry.Pair("start_flag", mode.ToString()),
new Telemetry.Pair("map_name", Path.GetFileName(mapName))
});
if (ngs != null)
{
telemetry.AddEvent("start_session", new Telemetry.Pair[]
{
new Telemetry.Pair("environment", ngs.m_environment),
new Telemetry.Pair("invert_traffic", ngs.m_invertTraffic),
new Telemetry.Pair("guid", ngs.m_gameInstanceIdentifier)
});
}
telemetry.Push();
}
catch (Exception ex)
{
CODebugBase<LogChannel>.Warn(LogChannel.HTTP, ex.GetType() + ": Telemetry event failed " + ex.Message);
}
}
void StartGame(Package.Asset package)
{
m_connectionInfoLabel.text = "Game Starting";
SaveGameMetaData mmd = package.Instantiate<SaveGameMetaData>();
SavePanel.lastLoadedName = package.name;
Debug.Log(mmd.cityName);
SimulationMetaData ngs = new SimulationMetaData
{
m_CityName = mmd.cityName,
m_updateMode = SimulationManager.UpdateMode.LoadGame,
m_environment = "",
m_disableAchievements = SimulationMetaData.MetaBool.True
};
Singleton<LoadingManager>.instance.LoadLevel(mmd.assetRef, "Game", "InGame", ngs);
}
static void LoadGame(MetaData metadata, SimulationMetaData ngs) => loadingMan_.LoadLevel(metadata.assetRef, "Game", "InGame", ngs);
void LoadSaveGameFromFile(String path)
{
Package p = new Package(null, path);
Package.Asset data = p.Find(p.packageMainAsset);
SaveGameMetaData mmd = data.Instantiate<SaveGameMetaData>();
Log.Debug(mmd.cityName);
Log.Debug(mmd.timeStamp.ToString());
SimulationMetaData simulationMetaData = new SimulationMetaData
{
m_CityName = mmd.cityName,
m_updateMode = SimulationManager.UpdateMode.LoadGame,
m_environment = ""
};
Singleton<LoadingManager>.instance.m_levelLoaded += LoadedGameCallback;
Singleton<LoadingManager>.instance.LoadLevel(mmd.assetRef, "Game", "InGame", simulationMetaData);
}
