/// <summary>
/// Reset all persistet game data.
/// </summary>
public void ResetGame()
{
PlayerPrefs.DeleteAll();
gameData = new GameDataContainer();
SaveGameData();
SceneManager.instance.LoadScene(0);
}
public static GameDataContainer LoadGameSave()
{
GameDataContainer data = new GameDataContainer ();
// Ensure that the file exists, else returns
if (!File.Exists ("Data/SaveGame.dat"))
return data;
using (BinaryReader br = new BinaryReader(File.OpenRead("Data/SaveGame.dat")))
{
br.ReadBytes(10); // Header
int moneyBytes = br.ReadInt32(); // sizeof (money)
data.Money = new BigInteger(Encoding.ASCII.GetString(br.ReadBytes(moneyBytes))); // money
// Loop for product data
for (int i = 0; i < (int)Products.Max; i++)
{
int level;
level = br.ReadInt32();
data.ProdList[i] = level;
}
int upgradeCount = br.ReadInt32();
for (int i = 0; i < upgradeCount; i++) {
int upId = br.ReadInt32();
data.AcquiredUpgrades.Add(upId);
}
}
return data;
}
public static bool SaveGame()
{
GameDataContainer data = new GameDataContainer ();
data.Money = GameController.Instance.Money;
for(int i = 0; i < (int)Products.Max; i++) {
data.ProdList[i] = GameController.Instance.ProdList[(Products)i].Level;
}
using (BinaryWriter bw = new BinaryWriter(File.OpenWrite("Data/SaveGame.dat")))
{
bw.Write(new char[10]);
byte[] money = Encoding.ASCII.GetBytes(data.Money.ToString());
bw.Write(money.Length);
bw.Write(money);
for (int i = 0; i < (int)Products.Max; i++) {
bw.Write(data.ProdList[i]);
}
int upCount = UpgradeController.Instance.AcquiredUps.Count;
bw.Write(upCount);
for(int i = 0; i < upCount; i++) {
bw.Write(UpgradeController.Instance.AcquiredUps[i]);
}
}
return true;
}
public void Initialize(IFactory <GameObject, Transform, Vector2, Node> _nodeFactory, DijkstraNode _dijkstraNodePrefab, AStarNode _astarNodePrefab, SignalBus _signalBus, GameDataContainer _gameDataContainer)
{
dijkstraNodePrefab = _dijkstraNodePrefab;
gameDataContainer = _gameDataContainer;
astarNodePrefab = _astarNodePrefab;
nodeFactory = _nodeFactory;
signalBus = _signalBus;
}
public void Save()
{
BinaryFormatter bf = new BinaryFormatter();
FileStream file = File.Create(Application.persistentDataPath + "/GameData.dat");
GameDataContainer container = new GameDataContainer();
container.dDamageMod = DDamageMod;
container.currentScore = CurrentScore;
container.lastSavedScore = LastSavedScore;
container.lives = Lives;
container.currentLevel = CurrentLevel;
bf.Serialize(file, container);
file.Close();
}
public void Save()
{
var bf = new BinaryFormatter();
FileStream file = File.Create(Application.persistentDataPath + "/GameData.dat");
var container = new GameDataContainer();
container.difficulty = Difficulty;
container.currentScore = CurrentScore;
container.lastSavedScore = LastSavedScore;
container.lives = Lives;
container.currentLevel = CurrentLevel;
bf.Serialize(file, container);
file.Close();
}
/// <summary>
/// Loads an instance.
/// </summary>
/// <returns></returns>
public bool Load()
{
// Load the game
// Get game state data
// Deserialize data
GameDataContainer tileDataContainer = XMLSerializer.Deserialize <GameDataContainer>(Path);
Money = tileDataContainer.GameStateData.Money;
// Load the world
_map.Load(Path);
return(true);
}
public void Load()
{
if (File.Exists(Application.persistentDataPath + "/GameData.dat"))
{
BinaryFormatter bf = new BinaryFormatter();
FileStream file = File.Open(Application.persistentDataPath + "/GameData.dat", FileMode.Open);
GameDataContainer container = (GameDataContainer)bf.Deserialize(file);
file.Close();
DDamageMod = container.dDamageMod;
CurrentScore = container.currentScore;
LastSavedScore = container.lastSavedScore;
Lives = container.lives;
CurrentLevel = container.currentLevel;
}
}
public static Dictionary<Products, Product> LoadProducts(ref GameDataContainer cont)
{
Dictionary<Products, Product> prodList = new Dictionary<Products, Product> ();
prodList.Add (Products.Prod1, new Prod1(cont.ProdList[(int)Products.Prod1]));
prodList.Add (Products.Prod2, new Prod2(cont.ProdList[(int)Products.Prod2]));
prodList.Add (Products.Prod3, new Prod3(cont.ProdList[(int)Products.Prod3]));
prodList.Add (Products.Prod4, new Prod4(cont.ProdList[(int)Products.Prod4]));
prodList.Add (Products.Prod5, new Prod5(cont.ProdList[(int)Products.Prod5]));
prodList.Add (Products.Prod6, new Prod6(cont.ProdList[(int)Products.Prod6]));
prodList.Add (Products.Prod7, new Prod7(cont.ProdList[(int)Products.Prod7]));
prodList.Add (Products.Prod8, new Prod8(cont.ProdList[(int)Products.Prod8]));
prodList.Add (Products.Prod9, new Prod9(cont.ProdList[(int)Products.Prod9]));
prodList.Add (Products.Prod10, new Prod10(cont.ProdList[(int)Products.Prod10]));
return prodList;
}
/// <summary>
/// Load the persistet game data and reinitialize the gameData attribute.
/// </summary>
public void LoadPersistedGameData()
{
GameDataContainer persistedGameData = (GameDataContainer)PersistenceService.Load("gameData");
if (persistedGameData != null)
{
gameData = persistedGameData;
}
else
{
gameData = new GameDataContainer();
}
Debug.Log("Credits: " + gameData.credits);
Debug.Log("Semester: " + gameData.semester);
Debug.Log("Attempts: " + gameData.attempts);
Debug.Log("Amount retried modules: " + gameData.amountRetriedModules);
}
/// <summary>
/// Saves this instance.
/// </summary>
public void Save()
{
// Save the game
// Save the world map
GameDataContainer gameDataContainer = new GameDataContainer();
// Ground tiles
foreach (Tile tile in _map.GroundTiles)
{
tile.StoreData();
gameDataContainer.GroundDataList.Add(tile.Data);
}
// Buildings
foreach (Building building in _map.Buildings)
{
building.StoreData();
gameDataContainer.BuildingDataList.Add(building.Data);
}
// Roads
foreach (Tile tile in _map.Roads)
{
tile.StoreData();
gameDataContainer.RoadDataList.Add(tile.Data);
}
// Decorations
foreach (Tile tile in _map.Decorations)
{
tile.StoreData();
gameDataContainer.DecorationDataList.Add(tile.Data);
}
// Save game state data
// Money
gameDataContainer.GameStateData.Money = Money;
// Serialize data
XMLSerializer.Serialize(gameDataContainer, Path);
}
// Use this for initialization
void Start()
{
gdc = GameDataContainer.FindObjectOfType<GameDataContainer>();
if(gdc.loosing == true )
{
titelGameOver.SetActive(true);
titelWinner.SetActive(false);
}
else if(gdc.loosing == false && gdc.winning2ndLevel == false)
{
titelGameOver.SetActive(false);
titelWinner.SetActive(true);
}
else if( gdc.loosing == false && gdc.winning2ndLevel == true )
{
titelGameOver.SetActive(false);
titelWinner.SetActive(true);
}
}
void Start()
{
gdc = GameObject.FindObjectOfType<GameDataContainer>();
}
private void Awake()
{
Instance = this;
}
// Use this for initialization
void Start()
{
np = GameObject.FindWithTag("NamesPoints");
gdc = GameDataContainer.FindObjectOfType<GameDataContainer>();
name1 = GameObject.FindWithTag("Name1");
name2 = GameObject.FindWithTag("Name2");
name3 = GameObject.FindWithTag("Name3");
name4 = GameObject.FindWithTag("Name4");
name5 = GameObject.FindWithTag("Name5");
points1 = GameObject.FindWithTag("Points1");
points2 = GameObject.FindWithTag("Points2");
points3 = GameObject.FindWithTag("Points3");
points4 = GameObject.FindWithTag("Points4");
points5 = GameObject.FindWithTag("Points5");
Debug.Log(name1);
highscores = new Dictionary<string, int>();
highscores.Add("S", 999);
highscores.Add("Alice", 300);
highscores.Add("Bob", 645);
highscores.Add("Nobody", 5);
newName = inputF.text;
time = (int)gdc.timerUntilWin;
points = calcPoints(time);
fillTextFields(time, points);
fillHighscoreTable();
}
// Use this for initialization
void Start()
{
/********************************************
* TEMP code for testing
********************************************/
// Unit Types
// Container for all application data
GameDataContainer = new GameDataContainer();
GameDataContainer.LoadUnitTypes();
UnitType heavyInf = GameDataContainer.UnitTypes[0];
UnitType dragon = GameDataContainer.UnitTypes[2];
// temp initilization
CurrentGameData = new CurrentGameData(GameDataContainer);
// instantiate terrain, main function
InstantiateTerrain(CurrentGameData.TerrainTiles);
// temp set owner
Stack playerStack = GameObject.Find("PlayerStack").GetComponent <Stack>();
playerStack.StackData.Owner = CurrentGameData.Players[0];
var playerUnit = new Unit(heavyInf);
var playerUnit2 = new Unit(heavyInf);
var playerUnit3 = new Unit(dragon);
playerStack.AddUnit(playerUnit);
playerStack.AddUnit(playerUnit2);
playerStack.AddUnit(playerUnit3);
playerStack.NextTurn();
AddStackToAllStacks(playerStack);
Stack enemyStack = GameObject.Find("EnemyStack").GetComponent <Stack>();
enemyStack.StackData.Owner = CurrentGameData.Players[1];
var enemyUnit = new Unit(heavyInf);
enemyStack.AddUnit(enemyUnit);
enemyStack.NextTurn();
AddStackToAllStacks(enemyStack);
Stack enemyStack2 = GameObject.Find("EnemyStack2").GetComponent <Stack>();
enemyStack2.StackData.Owner = CurrentGameData.Players[1];
var enemyUnit2 = new Unit(heavyInf);
enemyStack2.AddUnit(enemyUnit2);
enemyStack2.NextTurn();
AddStackToAllStacks(enemyStack2);
#region CameraInitialized
// camera init vals
// limit the camera based on the map size
float vertExtent = MainCamera.orthographicSize;
float horzExtent = vertExtent * Screen.width / Screen.height;
// Size taken from bottom panel
float uiPaddingBot = 2 * MainCamera.orthographicSize * (BottomUI.GetComponent <RectTransform>().rect.height / Screen.height);
float uiPaddingTop = 2 * MainCamera.orthographicSize * (TopPanel.GetComponent <RectTransform>().rect.height / Screen.height);
// off set is calculated based on the size of the map
float offset = CurrentGameData.MapSize / 2f - 0.5f;
CameraMinX = horzExtent - ((float)CurrentGameData.MapSize) / 2.0f + offset;
CameraMaxX = ((float)CurrentGameData.MapSize) / 2.0f - horzExtent + offset;
CameraMinY = vertExtent - ((float)CurrentGameData.MapSize) / 2.0f + offset - uiPaddingBot;
CameraMaxY = ((float)CurrentGameData.MapSize) / 2.0f - vertExtent + offset + uiPaddingTop;
if (CameraMaxX - CameraMinX < 0)
{
float diffX = CameraMinX - CameraMaxX;
CameraMaxX += diffX / 2;
CameraMinX -= diffX / 2;
}
if (CameraMaxY - CameraMinY < 0)
{
float diffY = CameraMinY - CameraMaxY;
CameraMaxY += diffY / 2;
CameraMinY -= diffY / 2;
}
#endregion
}
private void Initialize(GameDataContainer _gameDataContainer, DijkstraPathfinding _dijkstraPathfinding, AStarPathfinding _astarPathfinding)
{
gameDataContainer = _gameDataContainer;
dijkstraPathfinding = _dijkstraPathfinding;
aStarPathfinding = _astarPathfinding;
}
/// <summary>
/// Loads an existing map.
/// </summary>
/// <param name="path">The XML file path which contains the world data.</param>
/// <returns></returns>
public void Load(string path)
{
// Clear existing GroundTiles
GroundTiles = new Tile[XSize, YSize];
// Check if the file exists
if (!File.Exists(path))
{
return;
}
// Deserialize data
GameDataContainer tileDataContainer = XMLSerializer.Deserialize <GameDataContainer>(path);
// Clear parent GameObject
GameObject groundParentObj = GameObject.Find("Tiles/Ground");
foreach (Transform child in groundParentObj.transform)
{
Destroy(child.gameObject);
}
// Create tile
List <TileData> groundDataList = tileDataContainer.GroundDataList;
int arrayCounter = 0;
// Process ground tiles
for (int y = 0; y < YSize; y++)
{
for (int x = 0; x < XSize; x++)
{
// Create tile
TileData tileData = groundDataList[arrayCounter];
Tile tile = CreateTile(tileData);
// Load data
tile.Data = tileData;
tile.LoadData();
// Set parent
tile.gameObject.transform.parent = GameObject.Find("Tiles/Ground").transform;
// Add tile to array
GroundTiles[x, y] = tile;
// Update array counter
arrayCounter++;
}
}
// Process buildings
List <BuildingData> buildingDataList = tileDataContainer.BuildingDataList;
foreach (BuildingData buildingData in buildingDataList)
{
SpawnBuilding(buildingData);
}
// Process roads
List <TileData> roadDataList = tileDataContainer.RoadDataList;
foreach (TileData data in roadDataList)
{
Tile tile = CreateTile(data);
tile.Data = data;
tile.LoadData();
// Set parent
tile.gameObject.transform.parent = GameObject.Find("Tiles/Roads").transform;
// Add to list
Roads.Add(tile);
}
// Process nodes
ProcessNodes();
// Process decorations
List <TileData> decorationDataList = tileDataContainer.DecorationDataList;
foreach (TileData data in decorationDataList)
{
Tile tile = CreateTile(data);
tile.Data = data;
tile.LoadData();
// Set parent
tile.gameObject.transform.parent = GameObject.Find("Tiles/Decoration").transform;
// Add to list
Decorations.Add(tile);
}
}
private void Initialize(SignalBus _signalBus, GameDataContainer _gameDataContainer)
{
signalBus = _signalBus;
gameDataContainer = _gameDataContainer;
}
///////////////
public void Init()
{
GameDataContainer gameDatas = Resources.Load <GameDataContainer>("GameDataContainer");
foreach (TextAsset text in gameDatas.m_GameDataFiles)
{
JsonArray dataArray = Helper.ParseJsonArray(text.ToString());
switch (text.name)
{
case "enemies":
Enemies = new List <EnemyData>();
foreach (JsonObject obj in dataArray)
{
Enemies.Add(new EnemyData(obj));
}
break;
case "equipments":
Equipments = new List <EquipmentItem>();
foreach (JsonObject obj in dataArray)
{
Equipments.Add(new EquipmentItem(obj));
}
break;
case "materials":
Materials = new List <MaterialData>();
foreach (JsonObject obj in dataArray)
{
Materials.Add(new MaterialData(obj));
}
break;
case "missions":
Missions = new List <MissionData>();
foreach (JsonObject obj in dataArray)
{
Missions.Add(new MissionData(obj));
}
break;
case "base_config":
NewProfileData = dataArray;
break;
case "abilities":
Abilities = new List <AbilityData>();
foreach (JsonObject obj in dataArray)
{
Abilities.Add(new AbilityData(obj));
}
break;
case "crafting":
CraftReceipies = new List <CraftingData>();
foreach (JsonObject obj in dataArray)
{
CraftReceipies.Add(new CraftingData(obj));
}
break;
case "drops":
Drops = new List <DropData>();
foreach (JsonObject obj in dataArray)
{
Drops.Add(new DropData(obj));
}
break;
default:
Debug.LogError("Wrong storage name");
break;
}
}
// end init
IsInited = true;
}
public void Load()
{
_container = JsonUtility.FromJson <GameDataContainer>(GetJson());
}
