37239732ac
- Globe Asset - Spatial Anchors - Photon Implementation - Scripts for Globe Control and Initial Country Colorizing - Script for Reading csv file
421 lines
15 KiB
C#
421 lines
15 KiB
C#
using UnityEngine;
|
|
using System;
|
|
using System.Text;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
|
|
namespace WPM {
|
|
public partial class WorldMapEditor : MonoBehaviour {
|
|
|
|
public int GUICityIndex;
|
|
public string GUICityName = "";
|
|
public string GUICityNewName = "";
|
|
public string GUICityPopulation = "";
|
|
public string GUICityProvince = "";
|
|
public Vector2 GUICityLatLon;
|
|
public CITY_CLASS GUICityClass = CITY_CLASS.CITY;
|
|
public int cityIndex = -1;
|
|
public bool cityChanges;
|
|
// if there's any pending change to be saved
|
|
public bool cityAttribChanges;
|
|
|
|
// private fields
|
|
int lastCityCount = -1;
|
|
string[] _cityNames;
|
|
|
|
public string[] cityNames {
|
|
get {
|
|
if (map.cities != null && lastCityCount != map.cities.Count) {
|
|
cityIndex = -1;
|
|
ReloadCityNames();
|
|
}
|
|
return _cityNames;
|
|
}
|
|
}
|
|
|
|
|
|
#region Editor functionality
|
|
|
|
|
|
public void ClearCitySelection() {
|
|
map.HideCityHighlights();
|
|
cityIndex = -1;
|
|
GUICityName = "";
|
|
GUICityIndex = -1;
|
|
GUICityNewName = "";
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Adds a new city to current country.
|
|
/// </summary>
|
|
public void CityCreate(Vector3 newPoint) {
|
|
if (countryIndex < 0)
|
|
return;
|
|
GUICityName = "New City " + (map.cities.Count + 1);
|
|
newPoint = newPoint.normalized * 0.5f;
|
|
City newCity = new City(GUICityName, GUIProvinceName, countryIndex, 100, newPoint, GUICityClass);
|
|
map.cities.Add(newCity);
|
|
map.DrawCities();
|
|
lastCityCount = -1;
|
|
ReloadCityNames();
|
|
cityChanges = true;
|
|
}
|
|
|
|
public bool CityUpdate() {
|
|
if (cityIndex < 0)
|
|
return false;
|
|
|
|
bool changes = false;
|
|
City city = map.cities[cityIndex];
|
|
if (city.cityClass != GUICityClass) {
|
|
city.cityClass = GUICityClass;
|
|
changes = true;
|
|
}
|
|
int newPopulation;
|
|
if (int.TryParse(GUICityPopulation, out newPopulation) && city.population != newPopulation) {
|
|
city.population = newPopulation;
|
|
changes = true;
|
|
}
|
|
if (city.latlon != GUICityLatLon) {
|
|
city.latlon = GUICityLatLon;
|
|
changes = true;
|
|
}
|
|
|
|
string prevName = city.name;
|
|
GUICityNewName = GUICityNewName.Trim();
|
|
if (!prevName.Equals(GUICityNewName)) {
|
|
city.name = GUICityNewName;
|
|
GUICityName = GUICityNewName;
|
|
lastCityCount = -1;
|
|
ReloadCityNames();
|
|
changes = true;
|
|
}
|
|
|
|
if (changes) {
|
|
map.DrawCities();
|
|
cityChanges = true;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
public void CityMove(Vector3 destination) {
|
|
if (cityIndex < 0)
|
|
return;
|
|
map.cities[cityIndex].localPosition = destination.normalized * 0.5f;
|
|
UpdateCityVisualPosition();
|
|
cityChanges = true;
|
|
}
|
|
|
|
void UpdateCityVisualPosition() {
|
|
GameObject cityObj = map.cities[cityIndex].gameObject;
|
|
if (cityObj != null) {
|
|
cityObj.transform.localPosition = map.cities[cityIndex].localPosition * 1.001f;
|
|
}
|
|
}
|
|
|
|
public void CitySelectByCombo(int selection) {
|
|
GUICityName = "";
|
|
GUICityIndex = selection;
|
|
if (GetCityIndexByGUISelection()) {
|
|
if (Application.isPlaying) {
|
|
map.BlinkCity(cityIndex, Color.black, Color.green, 1.2f, 0.2f);
|
|
}
|
|
}
|
|
CitySelect();
|
|
}
|
|
|
|
bool GetCityIndexByGUISelection() {
|
|
if (GUICityIndex < 0 || GUICityIndex >= cityNames.Length)
|
|
return false;
|
|
string[] s = cityNames[GUICityIndex].Split(new char[] {
|
|
'(',
|
|
')'
|
|
}, System.StringSplitOptions.RemoveEmptyEntries);
|
|
if (s.Length >= 2) {
|
|
GUICityName = s[0].Trim();
|
|
if (int.TryParse(s[1], out cityIndex)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void CitySelect() {
|
|
if (cityIndex < 0 || cityIndex > map.cities.Count)
|
|
return;
|
|
|
|
// If no country is selected (the city could be at sea) select it
|
|
City city = map.cities[cityIndex];
|
|
int cityCountryIndex = city.countryIndex;
|
|
if (cityCountryIndex < 0) {
|
|
SetInfoMsg("Country not found in this country file.");
|
|
}
|
|
|
|
if (countryIndex != cityCountryIndex && cityCountryIndex >= 0) {
|
|
ClearSelection();
|
|
countryIndex = cityCountryIndex;
|
|
countryRegionIndex = map.countries[countryIndex].mainRegionIndex;
|
|
CountryRegionSelect();
|
|
}
|
|
|
|
// Just in case makes GUICountryIndex selects appropiate value in the combobox
|
|
GUICityName = city.name;
|
|
GUICityPopulation = city.population.ToString();
|
|
GUICityClass = city.cityClass;
|
|
GUICityProvince = city.province;
|
|
GUICityLatLon = city.latlon;
|
|
SyncGUICitySelection();
|
|
if (cityIndex >= 0) {
|
|
GUICityNewName = city.name;
|
|
CityHighlightSelection();
|
|
}
|
|
}
|
|
|
|
public bool CitySelectByScreenClick(Ray ray, int countryIndex = -1) {
|
|
int targetCityIndex;
|
|
if (map.GetCityIndex(ray, out targetCityIndex, countryIndex)) {
|
|
cityIndex = targetCityIndex;
|
|
CitySelect();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void CityHighlightSelection() {
|
|
|
|
if (cityIndex < 0 || cityIndex >= map.cities.Count)
|
|
return;
|
|
|
|
// Colorize city
|
|
map.HideCityHighlights();
|
|
map.ToggleCityHighlight(cityIndex, Color.blue, true);
|
|
}
|
|
|
|
public void ReloadCityNames() {
|
|
if (map == null || map.cities == null) {
|
|
lastCityCount = -1;
|
|
return;
|
|
}
|
|
lastCityCount = map.cities.Count; // check this size, and not result from GetCityNames because it could return additional rows (separators and so)
|
|
_cityNames = map.GetCityNames(countryIndex, true);
|
|
SyncGUICitySelection();
|
|
CitySelect(); // refresh selection
|
|
}
|
|
|
|
void SyncGUICitySelection() {
|
|
// recover GUI city index selection
|
|
if (GUICityName.Length > 0) {
|
|
for (int k = 0; k < cityNames.Length; k++) {
|
|
if (_cityNames[k].TrimStart().StartsWith(GUICityName)) {
|
|
GUICityIndex = k;
|
|
if (provinceIndex >= 0) {
|
|
cityIndex = map.GetCityIndexInProvince(provinceIndex, GUICityName);
|
|
}
|
|
if (cityIndex < 0) {
|
|
cityIndex = map.GetCityIndexInCountry(countryIndex, GUICityName);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
if (map.GetCityIndex(GUICityName) < 0) {
|
|
SetInfoMsg("City " + GUICityName + " not found in database.");
|
|
}
|
|
}
|
|
GUICityIndex = -1;
|
|
GUICityName = "";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Deletes current city
|
|
/// </summary>
|
|
public void DeleteCity() {
|
|
if (cityIndex < 0 || cityIndex >= map.cities.Count)
|
|
return;
|
|
|
|
map.HideCityHighlights();
|
|
map.cities.RemoveAt(cityIndex);
|
|
cityIndex = -1;
|
|
GUICityName = "";
|
|
SyncGUICitySelection();
|
|
map.DrawCities();
|
|
cityChanges = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Deletes all cities of current selected country
|
|
/// </summary>
|
|
public void DeleteCountryCities() {
|
|
if (countryIndex < 0)
|
|
return;
|
|
|
|
map.HideCityHighlights();
|
|
int k = -1;
|
|
while (++k < map.cities.Count) {
|
|
if (map.cities[k].countryIndex == countryIndex) {
|
|
map.cities.RemoveAt(k);
|
|
k--;
|
|
}
|
|
}
|
|
cityIndex = -1;
|
|
GUICityName = "";
|
|
SyncGUICitySelection();
|
|
map.DrawCities();
|
|
cityChanges = true;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Deletes all cities of current selected country's continent
|
|
/// </summary>
|
|
public void DeleteCitiesSameContinent() {
|
|
if (countryIndex < 0)
|
|
return;
|
|
|
|
map.HideCityHighlights();
|
|
int k = -1;
|
|
string continent = map.countries[countryIndex].continent;
|
|
while (++k < map.cities.Count) {
|
|
int cindex = map.cities[k].countryIndex;
|
|
if (cindex >= 0) {
|
|
string cityContinent = map.countries[cindex].continent;
|
|
if (cityContinent.Equals(continent)) {
|
|
map.cities.RemoveAt(k);
|
|
k--;
|
|
}
|
|
}
|
|
}
|
|
cityIndex = -1;
|
|
GUICityName = "";
|
|
SyncGUICitySelection();
|
|
map.DrawCities();
|
|
cityChanges = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calculates correct province for cities
|
|
/// </summary>
|
|
public void FixOrphanCities() {
|
|
if (_map.provinces == null)
|
|
return;
|
|
|
|
int countryAssigned = 0;
|
|
int provinceAssigned = 0;
|
|
|
|
int cityCount = _map.cities.Count;
|
|
for (int c = 0; c < cityCount; c++) {
|
|
City city = _map.cities[c];
|
|
if (city.countryIndex == -1) {
|
|
for (int k = 0; k < _map.countries.Length; k++) {
|
|
Country co = _map.countries[k];
|
|
if (co.regions == null)
|
|
continue;
|
|
int regCount = co.regions.Count;
|
|
for (int kr = 0; kr < regCount; kr++) {
|
|
if (co.regions[kr].Contains(city.latlon)) {
|
|
city.countryIndex = k;
|
|
countryAssigned++;
|
|
cityChanges = true;
|
|
k = 100000;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (city.countryIndex == -1) {
|
|
float minDist = float.MaxValue;
|
|
for (int k = 0; k < _map.countries.Length; k++) {
|
|
Country co = _map.countries[k];
|
|
if (co.regions == null)
|
|
continue;
|
|
int regCount = co.regions.Count;
|
|
for (int kr = 0; kr < regCount; kr++) {
|
|
float dist = (co.regions[kr].latlonCenter - city.latlon).sqrMagnitude;
|
|
if (dist < minDist) {
|
|
minDist = dist;
|
|
city.countryIndex = k;
|
|
cityChanges = true;
|
|
countryAssigned++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (city.province.Length == 0) {
|
|
Country country = _map.countries[city.countryIndex];
|
|
if (country.provinces == null)
|
|
continue;
|
|
for (int p = 0; p < country.provinces.Length; p++) {
|
|
Province province = country.provinces[p];
|
|
if (province.regions == null)
|
|
_map.ReadProvincePackedString(province);
|
|
if (province.regions == null)
|
|
continue;
|
|
int regCount = province.regions.Count;
|
|
for (int pr = 0; pr < regCount; pr++) {
|
|
Region reg = province.regions[pr];
|
|
if (reg.Contains(city.latlon)) {
|
|
city.province = province.name;
|
|
cityChanges = true;
|
|
p = 100000;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int c = 0; c < cityCount; c++) {
|
|
City city = _map.cities[c];
|
|
if (city.province.Length == 0) {
|
|
float minDist = float.MaxValue;
|
|
int pg = -1;
|
|
for (int p = 0; p < _map.provinces.Length; p++) {
|
|
Province province = _map.provinces[p];
|
|
if (province.regions == null)
|
|
_map.ReadProvincePackedString(province);
|
|
if (province.regions == null)
|
|
continue;
|
|
int regCount = province.regions.Count;
|
|
for (int pr = 0; pr < regCount; pr++) {
|
|
Region pregion = province.regions[pr];
|
|
for (int prp = 0; prp < pregion.latlon.Length; prp++) {
|
|
float dist = (city.latlon - pregion.latlon[prp]).sqrMagnitude;
|
|
if (dist < minDist) {
|
|
minDist = dist;
|
|
pg = p;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (pg >= 0) {
|
|
city.province = _map.provinces[pg].name;
|
|
provinceAssigned++;
|
|
cityChanges = true;
|
|
}
|
|
} else { // check for differences in capitals
|
|
#if !UNITY_WSA
|
|
if (!city.name.Equals(city.province) && String.Compare(city.name, city.province, System.Globalization.CultureInfo.CurrentCulture, System.Globalization.CompareOptions.IgnoreNonSpace) == 0) {
|
|
city.name = city.province;
|
|
cityChanges = true;
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
Debug.Log(countryAssigned + " cities were assigned a new country.");
|
|
Debug.Log(provinceAssigned + " cities were assigned a new province.");
|
|
|
|
if (countryAssigned > 0 || provinceAssigned > 0) {
|
|
cityChanges = true;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
}
|
|
}
|