public void SaveMapFile(BinaryWriter writer, MapGlobal MapGlobal)
{
writer.Write(MapGlobal.height);
writer.Write(MapGlobal.width);
for (int i = 0; i < MapGlobal.cells.Length; i++)
{
writer.Write(MapGlobal.cells[i]);
}
writer.Write(MapGlobal.unitCount);
for (int i = 0; i < MapGlobal.unitCount; i++)
{
writer.Write(MapGlobal.Fleets[i].CoordinatesX);
writer.Write(MapGlobal.Fleets[i].CoordinatesZ);
writer.Write(MapGlobal.Fleets[i].moved);
writer.Write(MapGlobal.Fleets[i].camp);
writer.Write(MapGlobal.Fleets[i].fleetTypeIndex);
writer.Write(MapGlobal.Fleets[i].mapIndex);
writer.Write(MapGlobal.Fleets[i].shipCount);
for (int j = 0; j < MapGlobal.Fleets[i].MapShip.Length; j++)
{
writer.Write(MapGlobal.Fleets[i].MapShip[j].maxDefence);
writer.Write(MapGlobal.Fleets[i].MapShip[j].defence);
writer.Write(MapGlobal.Fleets[i].MapShip[j].attack);
writer.Write(MapGlobal.Fleets[i].MapShip[j].speed);
writer.Write(MapGlobal.Fleets[i].MapShip[j].shipTypeIndex);
}
}
}
public void Load(MapGlobal MapGlobal)
{
ClearPath();
ClearUnits();
int x, z;
x = MapGlobal.height;
z = MapGlobal.width;
width = z;
height = x;
CreateMap(z, x);
for (int i = 0; i < cells.Length; i++)
{
cells[i].Load(MapGlobal, i);
}
Refresh();
int unitCount = MapGlobal.unitCount;
for (int i = 0; i < unitCount; i++)
{
Fleet.FleetShipsLoad(MapGlobal, this, i);
}
gamePlayUI.activeCampUnits();
if (FastUnitSelection)
{
FastUnitSelection.LoadSheet();
}
this.Save(MapGlobal.getInstance());
}
public void Save(MapGlobal MapGlobal)
{
MapGlobal.height = height;
MapGlobal.width = width;
MapGlobal.cells = new int[height * width];
for (int i = 0; i < cells.Length; i++)
{
MapGlobal.cells[i] = cells[i].terrainTypeIndex;
}
MapGlobal.unitCount = fleetUnits.Count;
MapGlobal.Fleets = new MapGlobal.Fleet[fleetUnits.Count];
for (int i = 0; i < fleetUnits.Count; i++)
{
fleetUnits[i].location.coordinates.Save(MapGlobal, i);
MapGlobal.Fleets[i].moved = fleetUnits[i].location.FleetUnit.moved;
MapGlobal.Fleets[i].camp = fleetUnits[i].location.FleetUnit.camp;
MapGlobal.Fleets[i].fleetTypeIndex = fleetUnits[i].location.FleetUnit.fleetTypeIndex;
MapGlobal.Fleets[i].mapIndex = fleetUnits[i].location.FleetUnit.mapIndex;
MapGlobal.Fleets[i].shipCount = fleetUnits[i].mapShipList.Count;
MapGlobal.Fleets[i].MapShip = new MapGlobal.MapShip[fleetUnits[i].mapShipList.Count];
for (int j = 0; j < fleetUnits[i].mapShipList.Count; j++)
{
MapGlobal.Fleets[i].MapShip[j].maxDefence = fleetUnits[i].mapShipList[j].MaxDefence;
MapGlobal.Fleets[i].MapShip[j].defence = fleetUnits[i].mapShipList[j].defence;
MapGlobal.Fleets[i].MapShip[j].attack = fleetUnits[i].mapShipList[j].attack;
MapGlobal.Fleets[i].MapShip[j].speed = fleetUnits[i].mapShipList[j].speed;
MapGlobal.Fleets[i].MapShip[j].shipTypeIndex = fleetUnits[i].mapShipList[j].shipTypeIndex;
}
}
}
public static HexCoordinates Load(MapGlobal MapGlobal, int i)
{
HexCoordinates c;
c.x = MapGlobal.Fleets[i].CoordinatesX;
c.z = MapGlobal.Fleets[i].CoordinatesZ;
return(c);
}
public void Clear(MapGlobal MapGlobal)
{
MapGlobal.path = null;
MapGlobal.width = 0;
MapGlobal.height = 0;
FightClear();
MapGlobal.cells = new int[0];
MapGlobal.unitCount = 0;
MapGlobal.Fleets = new Fleet[0];
}
public static MapGlobal getInstance()
{
if (MapDate == null)
{
obj = new GameObject("MapDate");//创建一个带名字的对象
MapDate = obj.AddComponent(typeof(MapGlobal)) as MapGlobal;
//LoadFight(attackingFleet, attackedFleet);
DontDestroyOnLoad(obj);
}
return(MapDate);
}
void fight(Fleet attackerFleet, Fleet defenderFleet)
{
//Global.getInstance().LoadFight(attackerFleet, defenderFleet);
SendFightFleet(attackerFleet, defenderFleet);
grid.Save(MapGlobal.getInstance());
loadingFightScence();
grid.gameObject.SetActive(false);
camera.gameObject.SetActive(false);
canvas.gameObject.SetActive(false);
}
public void Retreat()
{
UpDateFleets(MapGlobal.getInstance(), attackerIndex, weFleet);
UpDateFleets(MapGlobal.getInstance(), attackerIndex, enemyFleet);
UpDateFleets(MapGlobal.getInstance(), defenderIndex, weFleet);
UpDateFleets(MapGlobal.getInstance(), defenderIndex, enemyFleet);
SceneManager.LoadScene("Start 1");
}
void Save(string path)
{
// string path = Path.Combine(Application.streamingAssetsPath + "\\Save", "test.map");
using (
BinaryWriter writer =
new BinaryWriter(File.Open(path, FileMode.Create))
)
{
writer.Write(7);
MapGlobal.getInstance().Clear(MapGlobal.getInstance());
hexGrid.Save(MapGlobal.getInstance());
hexGrid.SaveMapFile(writer, MapGlobal.getInstance());
}
}
/*
* public void FleetSave(BinaryWriter writer)
* {
* location.coordinates.Save(writer);
* writer.Write(location.FleetUnit.moved);
* writer.Write(location.FleetUnit.camp);
* writer.Write(location.FleetUnit.fleetTypeIndex);
* writer.Write(location.FleetUnit.mapIndex);
*
*
* for (int i = 0; i < mapShipList.Count; i++)
* {
* writer.Write(mapShipList[i].MaxDefence);
* writer.Write(mapShipList[i].defence);
* writer.Write(mapShipList[i].attack);
* writer.Write(mapShipList[i].speed);
*
* }
* }
*/
public static void FleetShipsLoad(MapGlobal MapGlobal, HexGrid grid, int i)
{
if (MapGlobal.Fleets[i].MapShip.Length != 0)
{
HexCoordinates coordinates = HexCoordinates.Load(MapGlobal, i);
int camp = MapGlobal.Fleets[i].camp;
int fleetTypeIndex = MapGlobal.Fleets[i].fleetTypeIndex;
Fleet newFleet = Instantiate(grid.unitPrefabs[fleetTypeIndex]);
newFleet.mapIndex = i;
newFleet.moved = MapGlobal.Fleets[i].moved;
newFleet.shipCount = MapGlobal.Fleets[i].shipCount;
newFleet.CampLoad(MapGlobal, grid, newFleet, coordinates, camp, i);
}
}
void Start()
{
if (MapGlobal.getInstance().mapHeader == 0 && MapGlobal.getInstance().path != null)
{
ReadMapFile(MapGlobal.getInstance().path);
Load(MapGlobal.getInstance());
}
else if (MapGlobal.getInstance().mapHeader != 0)
{
Load(MapGlobal.getInstance());
}
hexMesh.Triangulate(cells);
}
public void CampLoad(MapGlobal MapGlobal, HexGrid grid, Fleet newFleet, HexCoordinates coordinates, int camp, int i)
{
grid.AddFleetUnit(newFleet, grid.GetCell(coordinates), camp);
for (int j = 0; j < MapGlobal.Fleets[i].MapShip.Length; j++)
{
MapShip newShip = Instantiate(grid.shipPrefabs[MapGlobal.Fleets[i].MapShip[j].shipTypeIndex]);
newFleet.mapShipList.Add(newShip);
newShip.transform.SetParent(newFleet.transform);
newShip.MaxDefence = MapGlobal.Fleets[i].MapShip[j].maxDefence;
newShip.defence = MapGlobal.Fleets[i].MapShip[j].defence;
newShip.attack = MapGlobal.Fleets[i].MapShip[j].attack;
newShip.speed = MapGlobal.Fleets[i].MapShip[j].speed;
newShip.shipTypeIndex = MapGlobal.Fleets[i].MapShip[j].shipTypeIndex;
}
}
void UpDateFleets(MapGlobal MapGlobal, int Index, List <FightShip> fleet)
{
bool b = false;
b = (ClearDead(fleet) != null);
if (b)
{
List <FightShip> clearFleet = ClearDead(fleet);
MapGlobal.MapShip[] tempFleet = new MapGlobal.MapShip[clearFleet.Count];
for (int i = 0; i < clearFleet.Count; i++)
{
tempFleet[i].attack = clearFleet[i].attack;
tempFleet[i].defence = clearFleet[i].defence;
tempFleet[i].maxDefence = clearFleet[i].MaxDefence;
tempFleet[i].speed = clearFleet[i].speed;
tempFleet[i].shipTypeIndex = clearFleet[i].shipTypeIndex;
}
for (int i = 0; i < MapGlobal.Fleets.Length; i++)
{
if (MapGlobal.Fleets[i].mapIndex == Index && MapGlobal.Fleets[i].camp == fleet[0].camp)
{
MapGlobal.Fleets[i].MapShip = tempFleet;
}
}
}
else
{
MapGlobal.Fleet[] tempFleets = new MapGlobal.Fleet[MapGlobal.Fleets.Length - 1];
for (int i = 0, j = 0; i < MapGlobal.Fleets.Length; i++)
{
if (MapGlobal.Fleets[i].mapIndex != Index)
{
tempFleets[j] = MapGlobal.Fleets[i];
j++;
}
}
MapGlobal.Fleets = tempFleets;
MapGlobal.unitCount = MapGlobal.Fleets.Length;
}
}
public void ReadMapFile(string path)
{
BinaryReader reader = new BinaryReader(File.OpenRead(path));
MapGlobal.getInstance().mapHeader = reader.ReadInt32();
MapGlobal.getInstance().height = reader.ReadInt32();
MapGlobal.getInstance().width = reader.ReadInt32();
MapGlobal.getInstance().cells = new int[MapGlobal.getInstance().width *MapGlobal.getInstance().height];
for (int i = 0; i < MapGlobal.getInstance().width *MapGlobal.getInstance().height; i++)
{
MapGlobal.getInstance().cells[i] = reader.ReadInt32();;
}
MapGlobal.getInstance().unitCount = reader.ReadInt32();
MapGlobal.getInstance().Fleets = new MapGlobal.Fleet[MapGlobal.getInstance().unitCount];
for (int i = 0; i < MapGlobal.getInstance().unitCount; i++)
{
MapGlobal.getInstance().Fleets[i].CoordinatesX = reader.ReadInt32();
MapGlobal.getInstance().Fleets[i].CoordinatesZ = reader.ReadInt32();
MapGlobal.getInstance().Fleets[i].moved = reader.ReadBoolean();
MapGlobal.getInstance().Fleets[i].camp = reader.ReadInt32();
MapGlobal.getInstance().Fleets[i].fleetTypeIndex = reader.ReadInt32();
MapGlobal.getInstance().Fleets[i].mapIndex = reader.ReadInt32();
MapGlobal.getInstance().Fleets[i].shipCount = reader.ReadInt32();
MapGlobal.getInstance().Fleets[i].MapShip = new MapGlobal.MapShip[MapGlobal.getInstance().Fleets[i].shipCount];
for (int j = 0; j < MapGlobal.getInstance().Fleets[i].MapShip.Length; j++)
{
MapGlobal.getInstance().Fleets[i].MapShip[j].maxDefence = reader.ReadInt32();
MapGlobal.getInstance().Fleets[i].MapShip[j].defence = reader.ReadInt32();
MapGlobal.getInstance().Fleets[i].MapShip[j].attack = reader.ReadInt32();
MapGlobal.getInstance().Fleets[i].MapShip[j].speed = reader.ReadInt32();
MapGlobal.getInstance().Fleets[i].MapShip[j].shipTypeIndex = reader.ReadInt32();
}
}
}
void NewFleet(int index, int camp, MapGlobal MapGlobal)
{
for (int i = 0; i < MapGlobal.Fleets.Length; i++)
{
if (MapGlobal.Fleets[i].mapIndex == index)
{
if (MapGlobal.Fleets[i].camp == 0)
{
MapGlobal.MapShip[] tempMapShip = new MapGlobal.MapShip[weFleet.Count];
for (int j = 0; j < tempMapShip.Length; j++)
{
tempMapShip[j].attack = weFleet[j].attack;
tempMapShip[j].defence = weFleet[j].defence;
tempMapShip[j].maxDefence = weFleet[j].MaxDefence;
tempMapShip[j].speed = weFleet[j].speed;
tempMapShip[j].shipTypeIndex = weFleet[j].shipTypeIndex;
}
MapGlobal.Fleets[i].MapShip = tempMapShip;
}
}
}
}
void Load(string path)
{
if (!File.Exists(path))
{
Debug.LogError("File does not exist " + path);
return;
}
// string path = Path.Combine(Application.streamingAssetsPath + "\\Save", "test.map");
using (BinaryReader reader = new BinaryReader(File.OpenRead(path)))
{
int header = reader.ReadInt32();
if (header <= 7)
{
MapGlobal.getInstance().path = path;
SceneManager.LoadScene("Start 1");
}
else
{
Debug.LogWarning("Unknown map format " + header);
}
}
}
public void Save(MapGlobal MapGlobal, int i)
{
MapGlobal.Fleets[i].CoordinatesX = x;
MapGlobal.Fleets[i].CoordinatesZ = z;
}
void LoadFleet(int attackerIndex, int defenderIndex, MapGlobal MapGlobal)
{
this.attackerIndex = attackerIndex;
this.defenderIndex = defenderIndex;
for (int i = 0; i < MapGlobal.Fleets.Length; i++)
{
if (MapGlobal.Fleets[i].mapIndex == attackerIndex)
{
MapGlobal.Fleet attacker = MapGlobal.Fleets[i];
for (int j = 0; j < attacker.MapShip.Length; j++)
{
FightShip ship = Instantiate(shipPrefabs[attacker.MapShip[j].shipTypeIndex]);
ship.attack = attacker.MapShip[j].attack;
ship.defence = attacker.MapShip[j].defence;
ship.MaxDefence = attacker.MapShip[j].maxDefence;
ship.speed = attacker.MapShip[j].speed;
ship.camp = attacker.camp;
ship.shipTypeIndex = attacker.MapShip[j].shipTypeIndex;
//text.text = ship.hullNumber;
//image = ship.headPortrait;
if (ship.camp == 0 || ship.camp == 2)
{
weFleet.Add(ship);
}
else if (ship.camp == 1)
{
enemyFleet.Add(ship);
}
fightFleet.Add(ship);
ship.transform.SetParent(weContent, false);
}
}
else if (MapGlobal.Fleets[i].mapIndex == defenderIndex)
{
MapGlobal.Fleet defender = MapGlobal.Fleets[i];
for (int j = 0; j < defender.MapShip.Length; j++)
{
FightShip ship = Instantiate(shipPrefabs[defender.MapShip[j].shipTypeIndex]);
ship.attack = defender.MapShip[j].attack;
ship.defence = defender.MapShip[j].defence;
ship.MaxDefence = defender.MapShip[j].maxDefence;
ship.speed = defender.MapShip[j].speed;
ship.camp = defender.camp;
ship.shipTypeIndex = defender.MapShip[j].shipTypeIndex;
//text.text = ship.hullNumber;
//image = ship.headPortrait;
if (ship.camp == 0 && ship.camp == 2)
{
weFleet.Add(ship);
}
else if (ship.camp == 1)
{
enemyFleet.Add(ship);
}
fightFleet.Add(ship);
ship.transform.SetParent(enemyContent, false);
}
}
}
fightFleet.Sort((x, y) => x.CompareTo(y));
}
private void Awake()
{
LoadFleet(MapGlobal.getInstance().attacker, MapGlobal.getInstance().defender, MapGlobal.getInstance());
}
public void SendFightFleet(Fleet attacker, Fleet defender)
{
MapGlobal.getInstance().attacker = attacker.mapIndex;
MapGlobal.getInstance().defender = defender.mapIndex;
}
public void Load(MapGlobal MapGlobal, int i)
{
terrainTypeIndex = MapGlobal.cells[i];
}
