public async Task GetTerritories_TerritoriesExists_ReturnTerritories(
[Frozen] List <Territory> dto,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TerritoryController sut
)
{
//Arrange
mockMediator.Setup(x => x.Send(
It.IsAny <GetTerritoriesQuery>(),
It.IsAny <CancellationToken>()
))
.ReturnsAsync(dto);
//Act
var actionResult = await sut.GetTerritories();
//Assert
var okObjectResult = actionResult as OkObjectResult;
okObjectResult.Should().NotBeNull();
var territories = okObjectResult.Value as List <Territory>;
territories.Count.Should().Be(dto.Count);
}
public override void Conquest(GameController got, TerritoryController source, TerritoryController target)
{
bool enemy = false;
foreach (var n in target.neighborhood)
{
if (n.player != this.numTurn)
{
enemy = true;
}
}
if (enemy)
{
if (got.MoveConquest(Math.Min(3, source.getTropas() - 1)))
{
got.AttackSubstate();
}
}
else
{
if (got.MoveConquest(1))
{
got.AttackSubstate();
}
}
}
public void RegisterTerritory(TerritoryController territory)
{
if (!AllTerritories.Contains(territory))
{
AllTerritories.Add(territory);
}
}
public virtual void ShowAttack(GameController got, TerritoryController source, TerritoryController target, List <int> attackDice, List <int> defenseDice, bool goToConquest)
{
clickAttack = false;
showNext = false;
timer += Time.deltaTime;
if (showingAttack)
{
if (timer > DELAY)
{
if (goToConquest)
{
got.ConquestSubstate();
}
else
{
got.AttackSubstate();
}
showingAttack = false;
}
}
else
{
timer = 0.0f;
showingAttack = true;
}
}
public new void SetDesinationTerritory(TerritoryController territory)
{
this.destinationTerritory = territory;
this.selectedDefenderController = territory != null?territory.GetOwnerController() : null;
UpdateAttackMoveInfo();
}
public new void SetTerritoryOwner(TerritoryController tc, PlayerController pc, bool sendEvent)
{
tc.SetOwner(pc);
pc.AddTerritory(tc.Territory);
if (sendEvent)
{
RaiseEvent(pc.GetPlayer().GetPlayerName(), EventNetwork.TERRITORY_SET_OWNER, tc.Territory.GetTerritoryName(), null, false);
}
}
void addNeighbour(TerritoryController n)
{
List <TerritoryController> old = new List <TerritoryController>();
old.AddRange(tc.Neighbours);
if (!old.Contains(n) && n != tc)
{
old.Add(n);
}
tc.Neighbours = old.ToArray();
}
public GameObject configure(TerritoryController territory)
{
this.transform.SetParent(territory.transform);
this.transform.Translate(0, 0, -1);
this.GetComponent <TropaController>().territory = territory;
Color color = GameController.players[territory.player].GetComponent <PlayerBase>().color;
this.GetComponent <SpriteRenderer>().color = color;
return(this.gameObject);
}
public ArmyController LookupOccuantForTerritory(TerritoryController territory)
{
foreach (ArmyController army in AllArmies)
{
if (army.Location == territory)
{
return(army);
}
}
return(null);
}
/// <summary>
/// Places the unassigned army at territory.
/// </summary>
/// <returns><c>true</c>, if unassigned army at territory was placed, <c>false</c> in all other cases.</returns>
/// <param name="territory">Territory.</param>
public bool PlaceUnassignedArmyAtTerritory(TerritoryController territory)
{
if (UnassignedArmies.Length > 0)
{
UnassignedArmies[0].Location = SelectedTerritory;
return(true);
}
else
{
Debug.LogWarning("Cannot place army, no units available!\n# of Total Troops: " + Armies.Length + "\n# of Unassigned Troops: " + UnassignedArmies.Length + "\n# of Assigned Troops: " + AssignedArmies.Length);
return(false);
}
}
public override void Conquest(GameController got, TerritoryController source, TerritoryController target)
{
got.log.GetComponent <Text>().text = "Atacar - Conquistou";
clickDistribution = false;
clickAttack = false;
clickRedistribution = false;
showNext = true;
got.slider.SetActive(true);
var slider = got.slider.GetComponent <Slider>();
slider.minValue = 1;
slider.maxValue = Math.Min(3, source.getTropas() - 1);
got.log.GetComponent <Text>().text = "Mover " + slider.value;
}
public void addNeighbour(TerritoryController n)
{
TerritoryController[] newNArray = new TerritoryController[Neighbours.Length + 1];
for (int i = 0; i < Neighbours.Length; i++)
{
if (n == Neighbours[i])
{
return; //Element already in list. Return
}
newNArray[i] = Neighbours[i];
}
newNArray[newNArray.Length - 1] = n;
Neighbours = newNArray;
}
public void CreateTroop(TerritoryController territory, Vector3 position)
{
GameObject continent = territory.transform.parent.gameObject;
if (exercitos.ContainsKey(continent) && exercitos[continent] - exercitosAdd[continent] >= 1)
{
exercitosAdd[continent] += 1;
territory.CreateTroop(position);
}
else if (exercitos[this.gameObject] - exercitosAdd[this.gameObject] >= 1)
{
exercitosAdd[this.gameObject] += 1;
territory.CreateTroop(position);
}
}
protected void FindTerritories_Click(object sender, EventArgs e)
{
if (RegionList.SelectedIndex == 0)
{
errormsgs.Add("Select a region to obtain territories.");
LoadMessageDisplay(errormsgs, "alert alert-info");
TerritoryList.DataSource = null;
TerritoryList.DataBind();
EmployeesGridViewV4.DataSource = null;
EmployeesGridViewV4.DataBind();
}
else
{
try
{
TerritoryController sysmgr = new TerritoryController();
List <Territory> info = sysmgr.Territory_GetByRegion(int.Parse(RegionList.SelectedValue));
if (info.Count == 0)
{
errormsgs.Add("No data found for the region");
LoadMessageDisplay(errormsgs, "alert alert-info");
}
else
{
info.Sort((x, y) => x.TerritoryDescription.CompareTo(y.TerritoryDescription));
//Second Dropdown list drill down
TerritoryList.DataSource = info;
TerritoryList.DataTextField = nameof(Territory.TerritoryDescription);
TerritoryList.DataValueField = nameof(Territory.TerritoryID);
TerritoryList.DataBind();
TerritoryList.Items.Insert(0, "select....");
//GridView
EmployeesGridViewV4.DataSource = null;
EmployeesGridViewV4.DataBind();
}
}
catch (Exception ex)
{
errormsgs.Add(GetInnerException(ex).ToString());
LoadMessageDisplay(errormsgs, "alert alert-danger");
}
}
}
// Use this for initialization
void Start()
{
this.proRing = GetComponent <ProceduralRing>();
this.territoryController = GetComponent <TerritoryController>();
if (Network.isServer)
{
this.territoryController.OnTerritoryCaptured += this.HillCapturedEvent;
this.territoryController.OnTerritoryLost += this.HillLostEvent;
}
this.prevRadius = this.radius;
this.prevHeight = this.height;
// Initialize ring color
if (gameObject.renderer)
{
gameObject.renderer.material.color = Player.TeamToColor(Player.Team.None);
}
this.andBoxCollider = this.andBoxColliderObject.GetComponent <BoxCollider>();
// Initilize ring size
this.UpdateHillSize();
GameObject[] managerObjects = GameObject.FindGameObjectsWithTag("Manager");
if (managerObjects.Length > 0)
{
GameObject managerObject = managerObjects[0];
// Grab the Player Manager
this.playerManager = managerObject.GetComponent <PlayerManager>();
this.scoreManager = managerObject.GetComponent <ScoreManager>();
this.gameManger = managerObject.GetComponent <GameManager>();
// Need to update the hill color if the player changes color
this.playerManager.OnPlayerUpdated += this.PlayerUpdatedEvent;
}
}
public bool Redistribute(TerritoryController source, TerritoryController target, int quantity)
{
var found = false;
foreach (var n in source.neighborhood)
{
if (System.Object.ReferenceEquals(n, target))
{
found = true;
break;
}
}
if (!found)
{
return(false);
}
if (System.Object.ReferenceEquals(source, target))
{
return(false);
}
if (source.player != turn || target.player != turn)
{
return(false);
}
if (source.getTropas() <= quantity)
{
return(false);
}
if (source.getTropas() - redistributed[source] < quantity)
{
return(false);
}
for (var i = 0; i < quantity; i++)
{
target.CreateTroop(target.PointInArea());
redistributed[target] += 1;
source.DestroyTroop();
}
return(true);
}
void Start()
{
EditorUtility.DisplayProgressBar("SetNeighbours", gameObject.name, 0f);
tc = transform.GetComponent <TerritoryController>();
var hitColliders = Physics.OverlapSphere(transform.position, scanDistance);
Mesh t_mesh = transform.GetComponent <MeshFilter>().sharedMesh;
int progress = 0;
foreach (Collider col in hitColliders)
{
progress++;
EditorUtility.DisplayProgressBar("SetNeighbours", gameObject.name, (float)progress / hitColliders.Length);
float minDistance = Mathf.Infinity;
Mesh o_mesh = col.transform.GetComponent <MeshFilter>().sharedMesh;
int vertCounter = 0;
foreach (Vector3 vert in t_mesh.vertices)
{
foreach (Vector3 vert2 in o_mesh.vertices)
{
float distance = Vector3.Distance(transform.TransformPoint(vert), col.transform.TransformPoint(vert2));
if (distance < minDistance)
{
minDistance = distance;
}
}
}
if (minDistance < neigDistance)
{
addNeighbour(col.transform.GetComponent <TerritoryController>());
}
}
EditorUtility.ClearProgressBar();
DestroyImmediate(this);
}
private void Awake()
{
Instance = this;
}
public bool Attack(TerritoryController source, TerritoryController target)
{
if (source.player != turn || target.player == turn)
{
return(false);
}
bool isNeighborhood = false;
foreach (var n in source.neighborhood)
{
if (System.Object.ReferenceEquals(n, target))
{
isNeighborhood = true;
break;
}
}
if (!isNeighborhood)
{
return(false);
}
var attack = Math.Min(3, source.getTropas() - 1);
var defense = Math.Min(3, target.getTropas());
attackDice = new List <int>();
defenseDice = new List <int>();
for (var i = 0; i < attack; i++)
{
attackDice.Add(UnityEngine.Random.Range(1, 7));
}
for (var i = 0; i < defense; i++)
{
defenseDice.Add(UnityEngine.Random.Range(1, 7));
}
attackDice.Sort();
defenseDice.Sort();
attackDice.Reverse();
defenseDice.Reverse();
for (var i = 0; i < Math.Min(attack, defense); i++)
{
if (attackDice[i] > defenseDice[i])
{
target.DestroyTroop();
}
else
{
source.DestroyTroop();
}
}
this.attackSource = source;
this.attackTarget = target;
if (target.getTropas() == 0)
{
target.player = turn;
substate = 2;
}
else
{
substate = 1;
}
//this.GetComponent<MapController>().resetCamera();
for (var i = 0; i < 3; i++)
{
var apos = AttackDiceObject[i].transform.position;
var dpos = DefenseDiceObject[i].transform.position;
AttackDiceObject[i].transform.position = new Vector3(apos.x, apos.y, 700);
DefenseDiceObject[i].transform.position = new Vector3(dpos.x, dpos.y, 700);
}
for (var i = 0; i < attack; i++)
{
var apos = AttackDiceObject[i].transform.position;
AttackDiceObject[i].GetComponent <DiceController>().roll(attackDice[i]);
AttackDiceObject[i].transform.position = new Vector3(apos.x, apos.y, 200);
}
for (var i = 0; i < defense; i++)
{
var dpos = DefenseDiceObject[i].transform.position;
DefenseDiceObject[i].GetComponent <DiceController>().roll(defenseDice[i]);
DefenseDiceObject[i].transform.position = new Vector3(dpos.x, dpos.y, 200);
}
return(true);
}
// Use this for initialization
void Start()
{
try
{
DataManager.dataInstance = GameObject.Find("Loading").GetComponent<DataManager>();
if (panels.Length == 0)
{
panels = DataManager.dataInstance.panels.ToArray();
}
else//パネル保存
{
foreach (GameObject panel in panels)
{
bool exist = false;
foreach (GameObject dataP in DataManager.dataInstance.panels)
{
if (dataP == panel)
{
exist = true;
break;
}
}
if (!exist)
{
DataManager.dataInstance.panels.Add(panel);
}
}
}
}
catch { }
g = GameObject.Find("ObjectExpectation");
foreach(GameObject k in GameObject.FindGameObjectsWithTag("Kernel"))
{
if(k.GetComponent<KernelController>().mikata)
{
kerCon
= k.GetComponent<KernelController>();
break;
}
}
terCon = GameObject.Find("Territory").GetComponent<TerritoryController>();
camera = GameObject.FindGameObjectWithTag("MainCamera").GetComponent<Camera>();
#region 各コマンド初期化
Transform robotList = transform.FindChild("RobotList");
GameObject bt;
EventTrigger trigger;
EventTrigger.Entry entryDown, entryDrag, entryEndDrag;
br = new List<Button>();//ロボコマンド初期化
GameObject[] robots = kerCon.genRobots;
for (int i = 0; i < robots.GetLength(0); i++)
{
bt = (GameObject)Instantiate(Resources.Load("Prefabs/RoboButton"),
transform.position, transform.rotation);//新たなロボボタン
br.Add(bt.GetComponent<Button>());
br[i].transform.SetParent(robotList, true);
br[i].transform.localPosition = new Vector2(-400 + 160 * (i % 5), 0);
br[i].transform.localScale = Vector3.one;
RobotController r = robots[i].GetComponent<RobotController>();
int SIZE = 32;
Color[] c;
Sprite iconSprite;
if (r.is3d)
{
iconSprite = r.image_all;
}
else
{
Texture2D image = new Texture2D(SIZE, SIZE, TextureFormat.ARGB32, false);
c = robots[i].GetComponent<SpriteRenderer>().sprite.texture.GetPixels(
SIZE * (1 + (r.im_num % 4) * 3),
SIZE * (7 - 4 * (r.im_num / 4) - r.dire),
SIZE, SIZE);
image.SetPixels(0, 0, SIZE, SIZE, c);
image.Apply();
iconSprite = Sprite.Create(image, new Rect(0, 0, SIZE, SIZE),
new Vector2(0.5f, 0.5f), SIZE);
}
br[i].GetComponent<Image>().sprite = iconSprite;
br[i].transform.FindChild("Text").gameObject.SetActive(false);
//br[i].onClick.AddListener(() => SetNumber(i, true, 0));
trigger = br[i].GetComponent<EventTrigger>();
entryDown = new EventTrigger.Entry();
entryDown.eventID = EventTriggerType.PointerDown;
int genNo = i;
entryDown.callback.AddListener((x) => SetNumber(genNo, true, 0, genNo));
trigger.triggers.Add(entryDown);
}
Transform panelList = transform.FindChild("PanelList");
bp = new List<Button>();//パネルコマンド初期化
int panelCount = 0;
for (int i = 0; i < panels.GetLength(0); i++)
{
int generateCount = 1;
if (panels[i].GetComponent<PanelController>().turnable)//回転可能ならば、その分だけボタンを生成
{
generateCount = 4;
}
for (int j = 0; j < generateCount; j++)
{
bt = (GameObject)Instantiate(Resources.Load("Prefabs/PanButton"),
transform.position, Quaternion.Euler(0, 0, 90 * j));//新たなパネルボタン
bp.Add(bt.GetComponent<Button>());
bp[panelCount].transform.SetParent(panelList, true);
bp[panelCount].GetComponent<RectTransform>().anchoredPosition
= new Vector2(0, -100 - 160 * i);
bp[panelCount].transform.localScale
= panels[i].transform.FindChild("Icon").localScale;
bp[panelCount].transform.localEulerAngles
= panels[i].transform.FindChild("Icon").localEulerAngles;
bp[panelCount].GetComponent<Image>().sprite
= panels[i].transform.FindChild("Icon").GetComponent<SpriteRenderer>().sprite;
bp[panelCount].transform.FindChild("Text").gameObject.SetActive(false);
//bp[panelCount].onClick.AddListener(() => SetNumber(i, false, j));
trigger = bp[panelCount].GetComponent<EventTrigger>();
entryDown = new EventTrigger.Entry();
entryDown.eventID = EventTriggerType.PointerDown;
int genNo = i, dire = j, panelNo = panelCount;
entryDown.callback.AddListener((x) => SetNumber(genNo, false, dire, panelNo));
entryDown.callback.AddListener((x) => TouchDownScreen());
entryDrag= new EventTrigger.Entry();
entryDrag.eventID = EventTriggerType.Drag;
entryDrag.callback.AddListener((x) => TouchingPanelList());
trigger.triggers.Add(entryDown);
trigger.triggers.Add(entryDrag);
panelCount++;
}
}
#endregion
settedPanels = new GameObject[panels.Length];
setDire.SetActive(false);
//ChangeTab();
//OnMenu();
LimitScroll(mapSizeX, mapSizeY, false);
cautionCursors = new List<GameObject>();
comboCount = 0;
comboCountMax = 0;
comboWaitCount = 0;
gettedItems = new bool[items.Length];
SetCombo();
SetGetItem();
}
void HillCapturedEvent(MonoBehaviour sender, TerritoryController.TerritoryActivityEventArgs e)
{
// Called when the hill is captured
if(Network.isServer)
this.netView.RPC("RPC_KingHillController_HillCaptured", RPCMode.AllBuffered, e.player.networkView.owner.guid);
else
this.HillCaptured(e.player);
}
private void NetworkingClient_EventReceived(EventData obj)
{
ExitGames.Client.Photon.Hashtable evData = obj.CustomData != null ? obj.CustomData as ExitGames.Client.Photon.Hashtable : null;
if (obj.Code < 200)
{
Debug.Log("Event received with code " + obj.Code + " From : " + obj.Sender);
}
switch (obj.Code)
{
case EventNetwork.NEXT_STATE:
GameStatesController.OnChangeStateEvent(evData);
if ((evData["STATE"] as string).Equals(GameStatesEnum.SETUPGAME))
{
StartPositioning();
}
break;
case EventNetwork.NEXT_PLAYER:
SetNextPlayer();
break;
case EventNetwork.END_PLAYER_TURN:
StartTurn();
break;
case EventNetwork.SET_MOVING_STATE:
SetMoving();
break;
case EventNetwork.SET_DESTINATION:
this.selectedDefenderController = players.Find(el => el.Player.GetPlayerName().Equals(evData["DATA"] as string));
break;
case EventNetwork.SET_SELECTED_TERRITORY:
TerritoryController selectedTerr = getTerritoryByName(evData["DATA"] as string);
SetSelectedTerritory(selectedTerr);
break;
case EventNetwork.SET_DESTINATION_TERRITORY:
TerritoryController destinTerr = getTerritoryByName(evData["DATA"] as string);
SetDesinationTerritory(destinTerr);
break;
case EventNetwork.DISTRIBUTE_TERRITORIES:
foreach (DictionaryEntry values in evData)
{
PlayerController owner = players.Find(el => el.Player.GetPlayerName().Equals(values.Value as string));
TerritoryController territoryOwned = getTerritoryByName(values.Key as string);
if (owner && territoryOwned)
{
SetTerritoryOwner(territoryOwned, owner, false);
}
}
break;
case EventNetwork.PLAYER_ADD_TERRITORY:
PlayerController pcont2 = players.Find(el => el.Player.GetPlayerName().Equals(evData["SUBJECT"] as string));
TerritoryController terr = getTerritoryByName(evData["DATA"] as string);
if (pcont2 && terr)
{
pcont2.AddTerritory(terr.Territory);
}
break;
case EventNetwork.PLAYER_LOST_TERRITORY:
PlayerController pcont3 = players.Find(el => el.Player.GetPlayerName().Equals(evData["SUBJECT"] as string));
TerritoryController terr1 = getTerritoryByName(evData["DATA"] as string);
if (pcont3 && terr1)
{
pcont3.LostTerritory(terr1.Territory);
}
break;
case EventNetwork.PLAYER_ADD_ARMY:
PlayerController pcont = players.Find(el => el.Player.GetPlayerName().Equals(evData["SUBJECT"] as string));
if (pcont)
{
pcont.AddArmies((int)evData["DATA"]);
}
break;
case EventNetwork.PLAYER_LOST_ARMY:
PlayerController pcont1 = players.Find(el => el.Player.GetPlayerName().Equals(evData["SUBJECT"] as string));
if (pcont1)
{
pcont1.LostArmies((int)evData["DATA"]);
}
break;
case EventNetwork.PLAYER_START_ARMIES_COUNT:
PlayerController pcont4 = players.Find(el => el.Player.GetPlayerName().Equals(evData["SUBJECT"] as string));
if (pcont4)
{
pcont4.SetStartArmiesCount((int)evData["DATA"]);
}
break;
case EventNetwork.PLAYERS_CREATED:
CreatePlayers();
break;
case EventNetwork.TERRITORY_SET_OWNER:
TerritoryController subject = getTerritoryByName(evData["SUBJECT"] as string);
PlayerController pcontt = players.Find(el => el.Player.GetPlayerName().Equals(evData["DATA"] as string));
if (pcontt)
{
subject.SetOwner(pcontt);
}
break;
case EventNetwork.TERRITORY_ADD_ARMY:
TerritoryController subject1 = getTerritoryByName(evData["SUBJECT"] as string);
if (subject1)
{
subject1.AddArmies((int)evData["DATA"]);
}
break;
case EventNetwork.TERRITORY_LOST_ARMY:
TerritoryController subject2 = getTerritoryByName(evData["SUBJECT"] as string);
if (subject2)
{
subject2.RemoveArmies((int)evData["DATA"]);
}
break;
}
}
void ShowTerritoryProgress(TerritoryController.TerritoryData tData)
{
if(this.viewReady)
this.m_View.View.TriggerEvent("showTerritoryProgress", tData);
}
private void createRegion(List <Vector2> regionPoints, StarSystem target, bool buildOnServer)
{
GameObject createdSystem = Container.InstantiatePrefab(_settings.StarSystemPrefab);
createdSystem.transform.position = new Vector3(target.X, 0, target.Y);
createdSystem.name = "Star_" + target.Name;
// Might be building on the client in offline mode
if (buildOnServer)
{
NetworkServer.Spawn(createdSystem.gameObject);
}
createdSystem.GetComponentsInChildren <Text>()[0].text = target.Name;
TerritoryController tc = createdSystem.GetComponent <TerritoryController>();
foreach (Vector2 point in regionPoints)
{
tc.Points.Add(point);
}
StarSystemController ssCon = createdSystem.gameObject.GetComponent <StarSystemController>();
ssCon.StarName = target.Name;
// Set the starting faction
FactionController factCtrl = createdSystem.gameObject.GetComponent <FactionController>();
switch (target.Faction)
{
case "s":
factCtrl.CurrentFaction = Faction.Steiner;
break;
case "m":
factCtrl.CurrentFaction = Faction.Marik;
break;
case "l":
factCtrl.CurrentFaction = Faction.Liao;
break;
case "d":
factCtrl.CurrentFaction = Faction.Davion;
break;
case "k":
factCtrl.CurrentFaction = Faction.Kurita;
break;
case "c":
factCtrl.CurrentFaction = Faction.Comstar;
break;
default:
factCtrl.CurrentFaction = Faction.None;
break;
}
StarSystemData sysData = createdSystem.gameObject.GetComponent <StarSystemData>();
sysData.OrigX = target.OrigX;
sysData.OrigY = target.OrigY;
sysData.StarClass = target.StarClass;
if (target.DataAvailable)
{
sysData.IsDataKnown = true;
sysData.PlanetsKnown = target.PlanetsKnown;
sysData.PlanetsUnknown = target.PlanetsUnknown;
sysData.Gravity = target.Gravity;
sysData.Atmosphere = target.Atmosphere;
sysData.Water = target.Water;
sysData.Climate = target.Climate;
sysData.Terrain = target.Terrain;
sysData.Development = target.Development;
sysData.HasFlag = target.HasFlag;
}
}
public Attack(TerritoryController source, TerritoryController target, int pont)
{
this.source = source;
this.target = target;
this.pont = pont;
}
// Territories searching coroutine
IEnumerator SearchForTerritories()
{
while (true)
{
// Getting all nature patches corners
List <PatchController> naturePatches = PatchesController.instance.patches.FindAll(x => x.patchData.fraction == (int)AppConstants.Fraction.NATURE);
List <List <Vector2> > naturePatchesCorners = new List <List <Vector2> >();
foreach (PatchController naturePatch in naturePatches)
{
List <Vector2> naturePatchCorners = new List <Vector2>();
foreach (Vector3 flag in naturePatch.patchData.flags)
{
naturePatchCorners.Add(new Vector2(flag.x, flag.z));
}
naturePatchesCorners.Add(naturePatchCorners);
}
yield return(new WaitForEndOfFrame());
// Counting nature territories
List <KeyValuePair <List <Vector2>, int> > natureTerritories = Geometry.GetAllPolygonsMinimalIntersections(naturePatchesCorners);
yield return(new WaitForEndOfFrame());
// Removing territories without borders
for (int i = 0; i < natureTerritories.Count; i++)
{
foreach (Vector2 territoryCorner in natureTerritories[i].Key)
{
bool removed = false;
foreach (PatchController naturePatch in naturePatches)
{
for (int j = 1; j < naturePatch.patchData.flags.Count; j++)
{
Vector2 lineA = new Vector2(naturePatch.patchData.flags[j - 1].x, naturePatch.patchData.flags[j - 1].z);
Vector2 lineB = new Vector2(naturePatch.patchData.flags[j].x, naturePatch.patchData.flags[j].z);
if (Geometry.IsPointOnLine(lineA, lineB, territoryCorner))
{
if (!naturePatch.patchData.borders[j - 1])
{
natureTerritories.RemoveAt(i);
i--;
removed = true;
}
}
if (removed)
{
break;
}
}
if (removed)
{
break;
}
}
if (removed)
{
break;
}
}
}
yield return(new WaitForEndOfFrame());
// Creating territories
foreach (KeyValuePair <List <Vector2>, int> natureTerritory in natureTerritories)
{
int territoryId = GetOrderIndependentHashCode(natureTerritory.Key);
TerritoryController tc = territories.Find(x => x.territoryData.id.Equals(territoryId));
if (tc == null)
{
GameObject territoryObject = new GameObject("NatureTerritory");
territoryObject.transform.parent = this.transform;
TerritoryController controller = territoryObject.AddComponent <TerritoryController>();
controller.territoryData = new Territory(territoryId, natureTerritory.Key, (int)AppConstants.Fraction.NATURE, natureTerritory.Value);
territories.Add(controller);
}
else
{
tc.territoryData.id = territoryId;
tc.territoryData.corners = natureTerritory.Key;
tc.territoryData.fraction = (int)AppConstants.Fraction.NATURE;
tc.territoryData.patchesJoined = natureTerritory.Value;
}
}
yield return(new WaitForEndOfFrame());
// Getting all commercy patches corners
List <PatchController> commercyPatches = PatchesController.instance.patches.FindAll(x => x.patchData.fraction == (int)AppConstants.Fraction.COMMERCY);
List <List <Vector2> > commercyPatchesCorners = new List <List <Vector2> >();
foreach (PatchController commercyPatch in commercyPatches)
{
List <Vector2> commercyPatchCorners = new List <Vector2>();
foreach (Vector3 flag in commercyPatch.patchData.flags)
{
commercyPatchCorners.Add(new Vector2(flag.x, flag.z));
}
commercyPatchesCorners.Add(commercyPatchCorners);
}
yield return(new WaitForEndOfFrame());
// Counting commercy territories
List <KeyValuePair <List <Vector2>, int> > commercyTerritories = Geometry.GetAllPolygonsMinimalIntersections(commercyPatchesCorners);
yield return(new WaitForEndOfFrame());
// Removing territories without borders
for (int i = 0; i < commercyTerritories.Count; i++)
{
foreach (Vector2 territoryCorner in commercyTerritories[i].Key)
{
bool removed = false;
foreach (PatchController commercyPatch in commercyPatches)
{
for (int j = 1; j < commercyPatch.patchData.flags.Count; j++)
{
Vector2 lineA = new Vector2(commercyPatch.patchData.flags[j - 1].x, commercyPatch.patchData.flags[j - 1].z);
Vector2 lineB = new Vector2(commercyPatch.patchData.flags[j].x, commercyPatch.patchData.flags[j].z);
if (Geometry.IsPointOnLine(lineA, lineB, territoryCorner))
{
if (!commercyPatch.patchData.borders[j - 1])
{
commercyTerritories.RemoveAt(i);
i--;
removed = true;
}
}
if (removed)
{
break;
}
}
if (removed)
{
break;
}
}
if (removed)
{
break;
}
}
}
yield return(new WaitForEndOfFrame());
// Creating territories
foreach (KeyValuePair <List <Vector2>, int> commercyTerritory in commercyTerritories)
{
int territoryId = GetOrderIndependentHashCode(commercyTerritory.Key);
TerritoryController tc = territories.Find(x => x.territoryData.id.Equals(territoryId));
if (tc == null)
{
GameObject territoryObject = new GameObject("CommercyTerritory");
territoryObject.transform.parent = this.transform;
TerritoryController controller = territoryObject.AddComponent <TerritoryController>();
controller.territoryData = new Territory(territoryId, commercyTerritory.Key, (int)AppConstants.Fraction.COMMERCY, commercyTerritory.Value);
territories.Add(controller);
}
else
{
tc.territoryData.id = territoryId;
tc.territoryData.corners = commercyTerritory.Key;
tc.territoryData.fraction = (int)AppConstants.Fraction.COMMERCY;
tc.territoryData.patchesJoined = commercyTerritory.Value;
}
}
yield return(new WaitForEndOfFrame());
// Getting all industry patches corners
List <PatchController> industryPatches = PatchesController.instance.patches.FindAll(x => x.patchData.fraction == (int)AppConstants.Fraction.INDUSTRY);
List <List <Vector2> > industryPatchesCorners = new List <List <Vector2> >();
foreach (PatchController industryPatch in industryPatches)
{
List <Vector2> industryPatchCorners = new List <Vector2>();
foreach (Vector3 flag in industryPatch.patchData.flags)
{
industryPatchCorners.Add(new Vector2(flag.x, flag.z));
}
industryPatchesCorners.Add(industryPatchCorners);
}
yield return(new WaitForEndOfFrame());
// Counting industry territories
List <KeyValuePair <List <Vector2>, int> > industryTerritories = Geometry.GetAllPolygonsMinimalIntersections(industryPatchesCorners);
yield return(new WaitForEndOfFrame());
// Removing territories without borders
for (int i = 0; i < industryTerritories.Count; i++)
{
foreach (Vector2 territoryCorner in industryTerritories[i].Key)
{
bool removed = false;
foreach (PatchController industryPatch in industryPatches)
{
for (int j = 1; j < industryPatch.patchData.flags.Count; j++)
{
Vector2 lineA = new Vector2(industryPatch.patchData.flags[j - 1].x, industryPatch.patchData.flags[j - 1].z);
Vector2 lineB = new Vector2(industryPatch.patchData.flags[j].x, industryPatch.patchData.flags[j].z);
if (Geometry.IsPointOnLine(lineA, lineB, territoryCorner))
{
if (!industryPatch.patchData.borders[j - 1])
{
industryTerritories.RemoveAt(i);
i--;
removed = true;
}
}
if (removed)
{
break;
}
}
if (removed)
{
break;
}
}
if (removed)
{
break;
}
}
}
yield return(new WaitForEndOfFrame());
// Creating territories
foreach (KeyValuePair <List <Vector2>, int> industryTerritory in industryTerritories)
{
int territoryId = GetOrderIndependentHashCode(industryTerritory.Key);
TerritoryController tc = territories.Find(x => x.territoryData.id.Equals(territoryId));
if (tc == null)
{
GameObject territoryObject = new GameObject("IndustryTerritory");
territoryObject.transform.parent = this.transform;
TerritoryController controller = territoryObject.AddComponent <TerritoryController>();
controller.territoryData = new Territory(territoryId, industryTerritory.Key, (int)AppConstants.Fraction.INDUSTRY, industryTerritory.Value);
territories.Add(controller);
}
else
{
tc.territoryData.id = territoryId;
tc.territoryData.corners = industryTerritory.Key;
tc.territoryData.fraction = (int)AppConstants.Fraction.INDUSTRY;
tc.territoryData.patchesJoined = industryTerritory.Value;
}
}
yield return(new WaitForEndOfFrame());
// Removing inactive teritorries
for (int i = 0; i < territories.Count; i++)
{
bool toDelete = true;
if (natureTerritories.FindIndex(x => GetOrderIndependentHashCode(x.Key).Equals(territories[i].territoryData.id)) > -1)
{
toDelete = false;
}
if (toDelete)
{
if (commercyTerritories.FindIndex(x => GetOrderIndependentHashCode(x.Key).Equals(territories[i].territoryData.id)) > -1)
{
toDelete = false;
}
}
if (toDelete)
{
if (industryTerritories.FindIndex(x => GetOrderIndependentHashCode(x.Key).Equals(territories[i].territoryData.id)) > -1)
{
toDelete = false;
}
}
if (toDelete)
{
territories[i].Destroy();
}
}
yield return(new WaitForEndOfFrame());
// Setting objects boosts
// Generators
foreach (GeneratorController obj in GeneratorsController.instance.generators)
{
obj.TerritoryBoosted = 0;
Vector2 position = new Vector2(obj.generatorData.position.x, obj.generatorData.position.z);
foreach (TerritoryController territory in territories)
{
if (Geometry.PolygonContainsPoint(territory.territoryData.corners, position))
{
obj.TerritoryBoosted += territory.territoryData.patchesJoined;
}
}
obj.SetupTerritoryBoostText();
}
yield return(new WaitForEndOfFrame());
// Trees
foreach (TreeController obj in TreesController.instance.trees)
{
obj.TerritoryBoosted = 0;
Vector2 position = new Vector2(obj.treeData.position.x, obj.treeData.position.z);
foreach (TerritoryController territory in territories)
{
if (Geometry.PolygonContainsPoint(territory.territoryData.corners, position))
{
obj.TerritoryBoosted += territory.territoryData.patchesJoined;
}
}
obj.SetupTerritoryBoostText();
}
yield return(new WaitForEndOfFrame());
// Automations
foreach (AutomationController obj in AutomationsController.instance.automations)
{
obj.TerritoryBoosted = 0;
Vector2 position = new Vector2(obj.automationData.position.x, obj.automationData.position.z);
foreach (TerritoryController territory in territories)
{
if (Geometry.PolygonContainsPoint(territory.territoryData.corners, position))
{
obj.TerritoryBoosted += territory.territoryData.patchesJoined;
}
}
obj.SetupTerritoryBoostText();
}
yield return(new WaitForEndOfFrame());
// Wells
foreach (WellController obj in WellsController.instance.wells)
{
obj.TerritoryBoosted = 0;
Vector2 position = new Vector2(obj.wellData.position.x, obj.wellData.position.z);
foreach (TerritoryController territory in territories)
{
if (Geometry.PolygonContainsPoint(territory.territoryData.corners, position))
{
obj.TerritoryBoosted += territory.territoryData.patchesJoined;
}
}
obj.SetupTerritoryBoostText();
}
yield return(new WaitForEndOfFrame());
// Project Objects
foreach (ProjectObjectController obj in ProjectObjectsController.instance.projectObjects)
{
obj.TerritoryBoosted = 0;
Vector2 position = new Vector2(obj.projectObjectData.position.x, obj.projectObjectData.position.z);
foreach (TerritoryController territory in territories)
{
if (Geometry.PolygonContainsPoint(territory.territoryData.corners, position))
{
obj.TerritoryBoosted += territory.territoryData.patchesJoined;
}
}
obj.SetupTerritoryBoostText();
}
yield return(new WaitForSeconds(AppConstants.ServerSynchronizationIntervalInSeconds));
}
}
public static void handle(string msg)
{
Regex reg = new Regex(@"^#([\w\.\-]+)§([\w\.\-]+)&(.*?)$");
Match match = reg.Match(msg);
if (!match.Success)
{
Globals.DevConsole.print("Could not recognize message: " + msg);
return;
}
string msg_type = match.Groups[1].ToString();
switch (msg_type)
{
case "txm": {
string msg_sender = match.Groups[2].ToString();
string msg_content = match.Groups[3].ToString();
Globals.DevConsole.print(msg_content);
break;
} //regular Textmessage
case "trs": {
string ter_name = match.Groups[2].ToString();
string ter_owner = match.Groups[3].ToString();
TerritoryController t = GameObject.Find(ter_name).GetComponent <TerritoryController>();
TerritoryState newState = new TerritoryState(ter_name, ter_owner);
newState.Apply();
break;
} //TerritoryState
case "spt": {
string player_name = match.Groups[2].ToString();
string team_name = match.Groups[3].ToString();
Globals.getPlayerByName(player_name).team = (Globals.TEAMS)Enum.Parse(typeof(Globals.TEAMS), team_name); //TODO: Differentiating players by their name is terrible
break;
} //Set Player Team
case "uid": {
Globals.InstanceNetwork.gotPlayerId(int.Parse(match.Groups[2].ToString()));
break;
} //Receive player id froms erver
case "con": {
if (!Globals.InstanceNetwork.isHosting())
{
Globals.DevConsole.print("Confrimed player connection recevied while not hosting game");
return;
}
PlayerInfo player = new PlayerInfo(match.Groups[3].ToString());
player.id = int.Parse(match.Groups[2].ToString());
Globals.players.Add(player);
break;
} //Confrim new connected player
case "evt": {
string event_name = match.Groups[2].ToString();
switch (event_name)
{
case "startGame": {
Globals.startGame();
break;
}
}
break;
} //Start the game
}
}
public virtual void Conquest(GameController got, TerritoryController source, TerritoryController target)
{
}
// Use this for initialization
void Start()
{
this.proRing = GetComponent<ProceduralRing>();
this.territoryController = GetComponent<TerritoryController>();
if(Network.isServer)
{
this.territoryController.OnTerritoryCaptured += this.HillCapturedEvent;
this.territoryController.OnTerritoryLost += this.HillLostEvent;
}
this.prevRadius = this.radius;
this.prevHeight = this.height;
// Initialize ring color
if(gameObject.renderer)
gameObject.renderer.material.color = Player.TeamToColor(Player.Team.None);
this.andBoxCollider = this.andBoxColliderObject.GetComponent<BoxCollider>();
// Initilize ring size
this.UpdateHillSize();
GameObject[] managerObjects = GameObject.FindGameObjectsWithTag("Manager");
if(managerObjects.Length > 0)
{
GameObject managerObject = managerObjects[0];
// Grab the Player Manager
this.playerManager = managerObject.GetComponent<PlayerManager>();
this.scoreManager = managerObject.GetComponent<ScoreManager>();
this.gameManger = managerObject.GetComponent<GameManager>();
// Need to update the hill color if the player changes color
this.playerManager.OnPlayerUpdated += this.PlayerUpdatedEvent;
}
}
public Relocation(TerritoryController territory, TerritoryController origin, int distance)
{
this.territory = territory;
this.origin = origin;
this.distance = distance;
}
public new void SetSelectedTerritory(TerritoryController territory)
{
this.selectedTerritoy = territory;
UpdateAttackMoveInfo();
}
