/// </deck questions>
private void Mustering()
{
GameState gs = new GameState();
gs.RegionList = m_lRegionList;
gs.UnitsList = m_lUnitsList;
gs.PlayerList = m_lPlayerList;
//bevonni a mustering pointal fogunk
foreach (var item in m_lPlayerList)
{
item.Recruit(gs, item.playerHouse, ref m_lUnitsList);
}
}
private void ExecutePlanningPart()
{
GameState gs = new GameState();
gs.m_lBannedOrders = m_lBannedOrders;
gs.PlayerList = m_lPlayerList;
gs.RegionList = m_lRegionList;
gs.UnitsList = m_lUnitsList;
foreach (var item in m_lPlayerList)
{
item.PlaceOrders(gs, item.playerHouse, ref m_lPlacedOrderList);
AddToOutput(item.playerHouse + " finish the planning.");
}
bool firstLineAdded = false;
foreach (var item in m_lPlayerList)
{
string osszes = null;
foreach (var item2 in m_lPlacedOrderList)
{
if (item2.ownerPlayerName == item.playerHouse)
{
if (!firstLineAdded)
{
osszes += item2.ownerPlayerName + "\n" + "===================\n";
firstLineAdded = !firstLineAdded;
}
osszes += "\n";
osszes += item2.ToString();
osszes += "\n";
}
}
//MessageBox.Show(osszes);
firstLineAdded = !firstLineAdded;
}
AddToOutput("planning part finished");
}
private void ExecuteActionPart()
{
//CSAK SORRENDRE HASZNALJUK, ADATMODOSITASRA NEEE
List<HOUSE> playerOrdered = new List<HOUSE>();
List<Tuple<HOUSE, int>> playerordered_helper = new List<Tuple<HOUSE, int>>();
foreach (var item in m_lPlayerList)
{
playerordered_helper.Add(new Tuple<HOUSE, int>(item.playerHouse, item.positionOnThroneInfluencetrack - 1));
}
playerordered_helper.OrderBy(p => p.Item2);
foreach (var item in playerordered_helper)
{
playerOrdered.Add(item.Item1);
}
List<PlacedOrder> RaidList = new List<PlacedOrder>();
List<PlacedOrder> AttackList = new List<PlacedOrder>();
List<PlacedOrder> ConsList = new List<PlacedOrder>();
List<PlacedOrder> DefenseList = new List<PlacedOrder>();
List<PlacedOrder> SupList = new List<PlacedOrder>();
foreach (var item in m_lPlacedOrderList)
{
if ((item.order == ORDER_TYPE.RAID) || (item.order == ORDER_TYPE.RAID_PLUS))
{
RaidList.Add(item);
continue;
}
if ((item.order == ORDER_TYPE.ATTACK_MINUS) || (item.order == ORDER_TYPE.ATTACK_NORMAL) || (item.order == ORDER_TYPE.ATTACK_PLUS))
{
AttackList.Add(item);
continue;
}
if ((item.order == ORDER_TYPE.CONDSOLIDATE) || (item.order == ORDER_TYPE.CONDSOLIDATE_PLUS))
{
ConsList.Add(item);
continue;
}
if ((item.order == ORDER_TYPE.DEFEND_PLUS) || (item.order == ORDER_TYPE.DEFEND_PLUSPLUS))
{
DefenseList.Add(item);
continue;
}
if ((item.order == ORDER_TYPE.SUPPORT) || (item.order == ORDER_TYPE.SUPPORT_PLUS))
{
SupList.Add(item);
continue;
}
}
// GameState gs = new GameState();
// gs.PlayerList = m_lPlayerList;
// gs.RegionList = m_lRegionList;
// gs.UnitsList = m_lUnitsList;
// string descText;
// m_lPlayerList.Where(p => p.playerHouse == playerOrdered[actualRaider]).FirstOrDefault().ExecuteAttack(gs, playerOrdered[actualRaider], ref m_lPlacedOrderList, ExecuteTokenType.ATTACK, ref m_lUnitsList, out descText);
// // m_lPlayerList.Where(p => p.playerHouse == playerOrdered[actualRaider]).FirstOrDefault().ExecuteConsolidate(gs, playerOrdered[actualRaider], ref m_lPlacedOrderList, ExecuteTokenType.CONSOLIDATE, ref m_lRegionList);
// AddToOutput(descText);
if (RaidList.Count > 0)
{
while (RaidList.Count > 0)
{
for (int i = 0; i < 6; i++)
{
if (RaidList.Count(r => r.ownerPlayerName == playerOrdered[i]) > 0)
{
GameState gs = new GameState();
gs.PlayerList = m_lPlayerList;
gs.RegionList = m_lRegionList;
gs.UnitsList = m_lUnitsList;
string descText;
m_lPlayerList.Where(p => p.playerHouse == playerOrdered[i]).FirstOrDefault()
.ExecuteRaid(gs, playerOrdered[i], ref RaidList, ref AttackList, ref ConsList, ref DefenseList, ref SupList, out descText );
AddToOutput(descText);
// itt erdemes lenne visszaterni a használt raidparancs sorszámával amit a raidlistben a helye,
//vagy magaval a raiddal
//azzal toroljuk is kis
}
}
}
}
if (AttackList.Count > 0)
{
while (AttackList.Count > 0)
{
for (int i = 0; i < 6; i++)
{
if (AttackList.Count(r => r.ownerPlayerName == playerOrdered[i]) > 0)
{
GameState gs = new GameState();
gs.PlayerList = m_lPlayerList;
gs.RegionList = m_lRegionList;
gs.UnitsList = m_lUnitsList;
string descText;
AttackList.Remove(m_lPlayerList.Where(p => p.playerHouse == playerOrdered[i]).FirstOrDefault()
.ExecuteAttack(gs, playerOrdered[i], ref AttackList, ref m_lUnitsList, out descText,this));
AddToOutput(descText);
}
}
}
}
if (ConsList.Count > 0)
{
while (ConsList.Count > 0)
{
for (int i = 0; i < 6; i++)
{
if (ConsList.Count(r => r.ownerPlayerName == playerOrdered[i]) > 0)
{
GameState gs = new GameState();
gs.PlayerList = m_lPlayerList;
gs.RegionList = m_lRegionList;
gs.UnitsList = m_lUnitsList;
string descText;
ConsList.Remove(m_lPlayerList.Where(p => p.playerHouse == playerOrdered[i]).FirstOrDefault()
.ExecuteConsolidate(gs, playerOrdered[i], ref ConsList, ref m_lRegionList, out descText));
AddToOutput(descText);
CheckWinner(playerOrdered[i]);
}
}
}
}
////raid
//if (m_lPlacedOrderList.Where(o => (o.order == ORDER_TYPE.RAID) || (o.order == ORDER_TYPE.RAID_PLUS)).Count() > 0)
//{
// int numberOfRaid = m_lPlacedOrderList.Where(o => (o.order == ORDER_TYPE.RAID) || (o.order == ORDER_TYPE.RAID_PLUS)).Count();
//
// int actualRaider = 6;
//
// //elso kivalasztasa
// foreach (var item in m_lPlacedOrderList.Where(o => (o.order == ORDER_TYPE.RAID) || (o.order == ORDER_TYPE.RAID_PLUS)))
// {
// if (playerOrdered.IndexOf(item.ownerPlayerName) < actualRaider)
// {
// actualRaider = playerOrdered.IndexOf(item.ownerPlayerName);
// }
// }
// // vegig raidelunk
// for (int i = 0; i < numberOfRaid; i++)
// {
// //itt hivjuk meg a raid elvegzeset, ha van
// // lambdával nézzük meg h van-e
// if (m_lPlacedOrderList.Where(o => (o.order == ORDER_TYPE.RAID) || (o.order == ORDER_TYPE.RAID_PLUS) || (o.ownerPlayerName == playerOrdered[actualRaider])).Count() > 0)
// {
// //m_lPlayerList.Where( p => p.playerHouse == playerOrdered[actualRaider] ).FirstOrDefault().ExecuteRaid();
// }
//
//
// // actualRaidernovelese
// //kovetkezo allitas okosabban kell
// actualRaider++;
// if (actualRaider == 6)
// {
// actualRaider = 0;
// }
//
// while (m_lPlacedOrderList.Where(o => (o.order == ORDER_TYPE.RAID) || (o.order == ORDER_TYPE.RAID_PLUS) || (o.ownerPlayerName == playerOrdered[actualRaider])).Count() == 0)
// {
// actualRaider++;
// if (actualRaider == 6)
// {
// actualRaider = 0;
// }
// }
//
// }
//}
////attack
//if (m_lPlacedOrderList.Where(o => (o.order == ORDER_TYPE.ATTACK_MINUS) || (o.order == ORDER_TYPE.ATTACK_NORMAL) || (o.order == ORDER_TYPE.ATTACK_PLUS)).Count() > 0)
//{
// int numberOfRaid = m_lPlacedOrderList.Where(o => (o.order == ORDER_TYPE.ATTACK_MINUS) || (o.order == ORDER_TYPE.ATTACK_NORMAL) || (o.order == ORDER_TYPE.ATTACK_PLUS)).Count();
//
// int actualRaider = 6;
//
// //elso kivalasztasa
// foreach (var item in m_lPlacedOrderList.Where(o => (o.order == ORDER_TYPE.ATTACK_MINUS) || (o.order == ORDER_TYPE.ATTACK_NORMAL) || (o.order == ORDER_TYPE.ATTACK_PLUS)))
// {
// if (playerOrdered.IndexOf(item.ownerPlayerName) < actualRaider)
// {
// actualRaider = playerOrdered.IndexOf(item.ownerPlayerName);
// }
// }
// // vegig raidelunk
// for (int i = 0; i < numberOfRaid; i++)
// {
// //itt hivjuk meg a raid elvegzeset, ha van
// // lambdával nézzük meg h van-e
// if (m_lPlacedOrderList.Where(o => (o.order == ORDER_TYPE.ATTACK_MINUS) || (o.order == ORDER_TYPE.ATTACK_NORMAL) || (o.order == ORDER_TYPE.ATTACK_PLUS)).Count() > 0)
// {
// GameState gs = new GameState();
// gs.PlayerList = m_lPlayerList;
// gs.RegionList = m_lRegionList;
// gs.UnitsList = m_lUnitsList;
// string descText;
// m_lPlayerList.Where(p => p.playerHouse == playerOrdered[actualRaider]).FirstOrDefault().ExecuteAttack(gs, playerOrdered[actualRaider], ref m_lPlacedOrderList, ExecuteTokenType.ATTACK, ref m_lUnitsList, out descText);
// // m_lPlayerList.Where(p => p.playerHouse == playerOrdered[actualRaider]).FirstOrDefault().ExecuteConsolidate(gs, playerOrdered[actualRaider], ref m_lPlacedOrderList, ExecuteTokenType.CONSOLIDATE, ref m_lRegionList);
// AddToOutput(descText);
// }
//
//
// // actualRaidernovelese
// //kovetkezo allitas okosabban kell
// //actualRaider++;
// //if (actualRaider == 6)
// //{
// // actualRaider = 0;
// //}
//
// while (m_lPlacedOrderList.Where(o => (o.order == ORDER_TYPE.ATTACK_MINUS) || (o.order == ORDER_TYPE.ATTACK_NORMAL) || (o.order == ORDER_TYPE.ATTACK_PLUS)).Count() == 0)
// {
// actualRaider++;
// if (actualRaider > 6)
// {
// actualRaider = 0;
// }
// }
//
// }
//}
//cons
//if (m_lPlacedOrderList.Where(o => (o.order == ORDER_TYPE.CONDSOLIDATE) || (o.order == ORDER_TYPE.CONDSOLIDATE_PLUS)).Count() > 0)
//{
// int numberOfRaid = m_lPlacedOrderList.Where(o => (o.order == ORDER_TYPE.CONDSOLIDATE) || (o.order == ORDER_TYPE.CONDSOLIDATE_PLUS)).Count();
//
// int actualRaider = 6;
//
// //elso kivalasztasa
// foreach (var item in m_lPlacedOrderList.Where(o => (o.order == ORDER_TYPE.CONDSOLIDATE) || (o.order == ORDER_TYPE.CONDSOLIDATE_PLUS)))
// {
// if (playerOrdered.IndexOf(item.ownerPlayerName) < actualRaider)
// {
// actualRaider = playerOrdered.IndexOf(item.ownerPlayerName);
// }
// }
// // vegig raidelunk
// for (int i = 0; i < numberOfRaid; i++)
// {
// //itt hivjuk meg a raid elvegzeset, ha van
// // lambdával nézzük meg h van-e
// if (m_lPlacedOrderList.Where(o => (o.order == ORDER_TYPE.CONDSOLIDATE) || (o.order == ORDER_TYPE.CONDSOLIDATE_PLUS) || (o.ownerPlayerName == playerOrdered[actualRaider])).Count() > 0)
// {
// GameState gs = new GameState();
// gs.PlayerList = m_lPlayerList;
// gs.RegionList = m_lRegionList;
// gs.UnitsList = m_lUnitsList;
// m_lPlayerList.Where( p => p.playerHouse == playerOrdered[actualRaider] ).FirstOrDefault().ExecuteConsolidate(gs, playerOrdered[actualRaider], ref m_lPlacedOrderList, ExecuteTokenType.CONSOLIDATE, ref m_lRegionList );
// }
//
//
// // actualRaidernovelese
// //kovetkezo allitas okosabban kell
// //actualRaider++;
// //if (actualRaider == 6)
// //{
// // actualRaider = 0;
// //}
//
// while (m_lPlacedOrderList.Where(o => (o.order == ORDER_TYPE.CONDSOLIDATE) || (o.order == ORDER_TYPE.CONDSOLIDATE_PLUS) || (o.ownerPlayerName == playerOrdered[actualRaider])).Count() > 0)
// {
// actualRaider++;
// if (actualRaider > 6)
// {
// actualRaider = 0;
// }
// }
//
// }
//}
m_lPlacedOrderList.Clear();
}
//paramlista: Gamestate, kivagyoken, ebbe pakolom a parancsaim
public void PlaceOrders(GameState gs, HOUSE h, ref List<PlacedOrder> PlacedOrderList)
{
//from-to
List<Tuple<Region, Region>> FinalAttackOrderList = new List<Tuple<Region, Region>>();
List<Tuple<Region, Region>> FinalRaidOrderList = new List<Tuple<Region, Region>>();
List<Tuple<Region, Region>> FinalDefenseOrderList = new List<Tuple<Region, Region>>();
List<Tuple<Region, Region>> FinalSupportOrderList = new List<Tuple<Region, Region>>();//ezzel magunkat erosithetjuk, erdemes a tamadasok, vedekzesek melle rakni
List<Tuple<Region, Region>> FinalKoronaOrderList = new List<Tuple<Region, Region>>();
//raidhoz v vedekezeshez eltesszuk
//olyan megye ami szomszedos, de rajta van elenseg
//EZT ELTESSZUK KESOBBRE
List<Region> EnemyNextToUs = new List<Region>();
List<Region> SAJATMEGYE = new List<Region>();
List<Region> SAJATMEGYESEREGGEL = new List<Region>();//nyilvan valoan csak ezekre rakunk majd attackott
List<Region> sajatOsszesMEGYE = new List<Region>();
List<Region> MEGYEELLENSEGESMeletttunk = new List<Region>();
foreach (var item in gs.UnitsList)
{
if (item.player == h)
{
if (!SAJATMEGYE.Contains(item.position) && !SAJATMEGYESEREGGEL.Contains(item.position) && !sajatOsszesMEGYE.Contains(item.position))
{
SAJATMEGYESEREGGEL.Add(item.position);
sajatOsszesMEGYE.Add(item.position);
}
}
}
foreach (var item in gs.RegionList)
{
if ( item.house == h )
{
if (!SAJATMEGYE.Contains(item) && !SAJATMEGYESEREGGEL.Contains(item) && !sajatOsszesMEGYE.Contains(item))
{
SAJATMEGYE.Add(item);
sajatOsszesMEGYE.Add(item);
}
}
}
foreach (var item in gs.UnitsList)
{
if (item.player != h && item.player != HOUSE.NONE)
{
for (int i = 0; i < sajatOsszesMEGYE.Count; i++)
{
if (sajatOsszesMEGYE[i].neighbours.Contains(item.position))
{
if (!MEGYEELLENSEGESMeletttunk.Contains(item.position))
MEGYEELLENSEGESMeletttunk.Add(item.position);
}
}
}
}
// ATTACK:
// itt csinálunk 2 db INFLUENCE MAP-ot:
// - 7 db város szempontjából (tobb korre is meg lehet nezni h melyikek a legfontosabbak)
// - ellenfelek hol halyezkednke el
// => ez lesz az influence map
// - megnezzuk hova tudunk mozogni a sereggekkel, mekkora eroval
// => goal map
// => vegeredmeny: influence map + goal map
// ezután összelayerezzuk oket, 1:1-hez aranyban és az egyik kapott területek elfoglallása a cél.
//annak a kornyekre teszunk attackot
// RAID:
// ellenseges terulet 1 tavolsagon belul
// minnelnagyobb a sereg, annal valoszinubb h oda teszunk raidot
//attackkal egyutt erdems hasznalni
// DEFENSE:
// akkor rakjuk ha melletunk nagyobb sereg van & varunk van a kornyeken
//
// TAMOGATAS:
// csak DEFENSE, v egyenlo nagysagu sereg melle rakjuk
//
// KORONA:
// tok biztonságos pozikra rakjuk ( tok feleslegsen
//
//
//7db varoshoz lepesek:
// 0. lepes: - tarolo lista megalkotasa
// 0.2 lepes: sajat megyeink kivetele ebbol
// 1. lepes: - minden megyehez 0-es float erteket rendelni,
// 2. lepes: - minden varhoz/kastelyhoz 2-es float ertek ( ha ellensege akkor 1e)sf
// 3. lepes: - var/kastely megyek ertekeik felet adjak a szomszedos megy ertekehez
// 4. lepes: - 3.lepes rekurziv ismeltles szomszedos megyekre
// 5. lepes: - mostmar tudjuk merre kell terjeszkedni, erdemes megnezni hogy mi hol vagyunk es merre kell menni
// 0. lepes
//regio, pont, adotte mar pontot
//mivel a tuple readonly ezért 1 struktba rakjuk
List<HetVarosStruct> HetVarosList = new List<HetVarosStruct>();
foreach (var item in gs.RegionList)
{
//0 - 0.2 lepes:
if (!item.isSea && item.house != h)
{
HetVarosStruct v;
v.addotEMarPontot = false;
v.pont = 0.0f;
v.regio = item;
//1es lepes iis
HetVarosList.Add(v);
}
}
//2lepes
for (int i = 0; i < HetVarosList.Count; i++)
{
HetVarosStruct temp = HetVarosList[i];
if (HetVarosList[i].regio.castle || HetVarosList[i].regio.city)
{
//senkie mehet neki a ket pont
if (HetVarosList[i].regio.house == HOUSE.NONE)
{
temp.pont += 2.0f;
}
else
{//elensege
temp.pont += 1.0f;
}
}
HetVarosList.Remove(HetVarosList[i]);
HetVarosList.Insert(i, temp);
}
//3 REKKUrZIV pontosztas
List<Region> pontOsztok = new List<Region>();
List<Region> pontOsztokAkoviKorben = new List<Region>();
foreach (var item in HetVarosList)
{
//a megyek osztjak a pontokat a szomszedoknak
if (item.pont != 0.0f)
pontOsztok.Add(item.regio);
}
//ez eugye akkor áll meg ha minden nyomorult megye osztott pontot, az utolsó senkinek nem fog de nmebaj hadd legyen jó nekki is es oszthason pontot
while (pontOsztok.Count > 0)
{
pontOsztokAkoviKorben.Clear();
for (int i = 0; i < pontOsztok.Count; i++)
{
for (int j = 0; j < pontOsztok[i].neighbours.Count; j++)
{
for (int k = 0; k < HetVarosList.Count; k++)
{
if (HetVarosList[k].regio == pontOsztok[i].neighbours[j] && HetVarosList[k].addotEMarPontot == false)
{
HetVarosStruct temp = HetVarosList[k];
temp.pont = HetVarosList.Find(v => v.regio == pontOsztok[i]).pont / 2;
HetVarosList.Remove(HetVarosList[k]);
HetVarosList.Insert(k, temp);
if (!pontOsztokAkoviKorben.Contains(temp.regio))
pontOsztokAkoviKorben.Add(temp.regio);
}
}
}
//beallitjuk h ez a terulet mar ne kapjon pontot
for (int x = 0; x < HetVarosList.Count; x++)
{
if (HetVarosList[x].regio == pontOsztok[i])
{
HetVarosStruct temp = HetVarosList[x];
temp.addotEMarPontot = true;
HetVarosList.Remove(HetVarosList[x]);
HetVarosList.Insert(x, temp);
}
}
}
// fekeszulunk a kovi iteraciora
pontOsztok = pontOsztokAkoviKorben;
}
//egyerusitett orders: 1.0v
// cons: egységek helyére, ha a terulet a mienk akkor megyunk tovább, random - OK
// attak:ha milyenk a hely akkor megyunk tovabb, pl varra - OK
// def: ha meletunk elenségvan és én vár vagyok -OK
// sup: ha melettem nincs ellenseg es van melettem def - OK
// raid: raid-def-sup komboba, ha melettem ellenségvan és van melettem def - OK
for (int i = 0; i < SAJATMEGYESEREGGEL.Count; i++)
{
// milyenk
if (SAJATMEGYESEREGGEL[i].house == h )
{
Random rnd = new Random();
int number = rnd.Next(0, SAJATMEGYESEREGGEL[i].neighbours.Count);
if (sajatOsszesMEGYE.Contains(SAJATMEGYESEREGGEL[i]))
{
FinalAttackOrderList.Add(new Tuple<Region, Region>(SAJATMEGYESEREGGEL[i], SAJATMEGYESEREGGEL[i].neighbours[number]));
sajatOsszesMEGYE.Remove(SAJATMEGYESEREGGEL[i]);
}
}
else
{
if (sajatOsszesMEGYE.Contains(SAJATMEGYESEREGGEL[i]))
{
FinalKoronaOrderList.Add(new Tuple<Region, Region>(SAJATMEGYESEREGGEL[i], null));
sajatOsszesMEGYE.Remove(SAJATMEGYESEREGGEL[i]);
}
}
}
int max = sajatOsszesMEGYE.Count;
for (int i = 0; i < max; i++)
{
//ha melettunk kozvetlenul ellenseg van akkor
if (MEGYEELLENSEGESMeletttunk.Contains(sajatOsszesMEGYE[i]))
{
// ezt a sort kikommenteltem mert 1 nemtom miert van itt, 2 breakel
//if (sajatOsszesMEGYE.Contains(SAJATMEGYESEREGGEL[i]))
{
FinalDefenseOrderList.Add(new Tuple<Region, Region>(sajatOsszesMEGYE[i], null));
//sajatOsszesMEGYE.Remove(sajatOsszesMEGYE[i]);
//continue;
}
}
bool vanEmarMellettunkDef = false; // "az kizárt, mert nemtudom' "
foreach (var item in FinalDefenseOrderList)
{
foreach (var item2 in sajatOsszesMEGYE[i].neighbours)
{
vanEmarMellettunkDef = true;
}
}
bool defensVanEMarRajtam = false;
foreach (var item in FinalDefenseOrderList)
{
if (item.Item1 == sajatOsszesMEGYE[i])
{
defensVanEMarRajtam = true;
}
}
//melettem def és meletem ellenseg is ÉS rajtam is defvan akkor le operalom a def-et, kap raidot, aztjólvan meg szupportot
if (MEGYEELLENSEGESMeletttunk.Contains(sajatOsszesMEGYE[i]) && vanEmarMellettunkDef && defensVanEMarRajtam )
{
if (defensVanEMarRajtam)
{
FinalDefenseOrderList.Remove(new Tuple<Region, Region>(sajatOsszesMEGYE[i], null));
FinalRaidOrderList.Add(new Tuple<Region, Region>(sajatOsszesMEGYE[i], null));
}
else
{
FinalRaidOrderList.Add(new Tuple<Region, Region>(sajatOsszesMEGYE[i], null));
//sajatOsszesMEGYE.Remove(sajatOsszesMEGYE[i]);
continue;
}
}
else if (!MEGYEELLENSEGESMeletttunk.Contains(sajatOsszesMEGYE[i]) && vanEmarMellettunkDef)
{
if (defensVanEMarRajtam)
{
FinalDefenseOrderList.Remove(new Tuple<Region, Region>(sajatOsszesMEGYE[i], null));
FinalSupportOrderList.Add(new Tuple<Region, Region>(sajatOsszesMEGYE[i], null));
}
else
{
FinalSupportOrderList.Add(new Tuple<Region, Region>(sajatOsszesMEGYE[i], null));
//sajatOsszesMEGYE.Remove(sajatOsszesMEGYE[i]);
continue;
}
}
}
//////////////////////mostmar megvannak a pontok
//////////////////////most megnezzuk h a megyeinknek, és az elerhetomegyeinknek mennyi pontja van
////////////////////List<Tuple<Region, float>> elerhetoMegyekEsPontok = new List<Tuple<Region, float>>();
////////////////////
////////////////////for (int j = 0; j < HetVarosList.Count; j++)
////////////////////{
//////////////////// for (int i = 0; i < SAJATMEGYESEREGGEL.Count; i++)
//////////////////// {
//////////////////// if (HetVarosList[j].regio == SAJATMEGYESEREGGEL[i])
//////////////////// {
//////////////////// if (elerhetoMegyekEsPontok.Find(a => a.Item1 == HetVarosList[j].regio) == null)
//////////////////// {
//////////////////// elerhetoMegyekEsPontok.Add(new Tuple<Region, float>(HetVarosList[j].regio, HetVarosList[j].pont));
//////////////////// }
//////////////////// }
////////////////////
//////////////////// for (int k = 0; k < SAJATMEGYESEREGGEL[i].neighbours.Count; k++)
//////////////////// {
//////////////////// if (HetVarosList[j].regio == SAJATMEGYESEREGGEL[i].neighbours[k])
//////////////////// {
//////////////////// if (elerhetoMegyekEsPontok.Find(a => a.Item1 == HetVarosList[j].regio) == null)
//////////////////// {
//////////////////// elerhetoMegyekEsPontok.Add(new Tuple<Region, float>(HetVarosList[j].regio, HetVarosList[j].pont));
//////////////////// }
//////////////////// }
//////////////////// }
//////////////////// }
////////////////////}
////////////////////
//////////////////////csokeno sorrenben
////////////////////elerhetoMegyekEsPontok = elerhetoMegyekEsPontok.OrderBy(item => item.Item2).ToList();
////////////////////elerhetoMegyekEsPontok.Reverse();
////////////////////
////////////////////
////////////////////for (int j = 0; j < SAJATMEGYESEREGGEL.Count; j++)
////////////////////{
//////////////////// if (SAJATMEGYESEREGGEL[j].castle || SAJATMEGYESEREGGEL[j].city)
//////////////////// {
//////////////////// if (SAJATMEGYESEREGGEL[j].house == HOUSE.NONE) //elfoglaltuk-e
//////////////////// {
//////////////////// //ha igen akkor megtamadjuk
//////////////////// //ha tehetünk rá parit
//////////////////// if (sajatOsszesMEGYE.Contains(SAJATMEGYESEREGGEL[j]))
//////////////////// {
//////////////////// FinalKoronaOrderList.Add(new Tuple<Region, Region>(SAJATMEGYESEREGGEL[j], null));
//////////////////// sajatOsszesMEGYE.Remove(SAJATMEGYESEREGGEL[j]);
//////////////////// }
//////////////////// }
//////////////////// else
//////////////////// {
//////////////////// //elvileg ez a mienk, es igy jó elsz
//////////////////// //megyunk tovabb
//////////////////// for (int i = 0; i < elerhetoMegyekEsPontok.Count; i++)
//////////////////// {
//////////////////// //mivel rendezet az elso ami okes arra megyunk
//////////////////// for (int k = 0; k < SAJATMEGYESEREGGEL[j].neighbours.Count; k++)
//////////////////// {
//////////////////// if (SAJATMEGYESEREGGEL[j].neighbours[k].name == elerhetoMegyekEsPontok[i].Item1.name)
//////////////////// {
//////////////////// if (sajatOsszesMEGYE.Contains(SAJATMEGYESEREGGEL[j]))
//////////////////// {
//////////////////// FinalAttackOrderList.Add(new Tuple<Region, Region>(SAJATMEGYESEREGGEL[j], elerhetoMegyekEsPontok[i].Item1));
//////////////////// sajatOsszesMEGYE.Remove(SAJATMEGYESEREGGEL[j]);
//////////////////// }
//////////////////// }
//////////////////// }
//////////////////// }
//////////////////// }
//////////////////// }
//////////////////// else
//////////////////// {
//////////////////// //nincsitlofaszse, megnezzuk hova erdemes lepni
//////////////////// for (int i = 0; i < elerhetoMegyekEsPontok.Count; i++)
//////////////////// {
//////////////////// //mivel rendezet az elso ami okes arra megyunk
//////////////////// for (int k = 0; k < SAJATMEGYESEREGGEL[j].neighbours.Count; k++)
//////////////////// {
//////////////////// if (SAJATMEGYESEREGGEL[j].neighbours[k].name == elerhetoMegyekEsPontok[i].Item1.name)
//////////////////// {
//////////////////// if (sajatOsszesMEGYE.Contains(SAJATMEGYESEREGGEL[j]))
//////////////////// {
//////////////////// FinalAttackOrderList.Add(new Tuple<Region, Region>(SAJATMEGYESEREGGEL[j], elerhetoMegyekEsPontok[i].Item1));
//////////////////// sajatOsszesMEGYE.Remove(SAJATMEGYESEREGGEL[j]);
//////////////////// }
//////////////////// }
//////////////////// }
//////////////////// }
//////////////////// }
////////////////////
////////////////////
////////////////////
////////////////////
////////////////////}
////// List<Region> kozvetlenMegyek = new List<Region>();
////// //levalogatjuk a szamunkra erdekeset, vagyhat amit tamadhatunk amit raidelhetunk amit esetleg foglalhatunk
////// for (int i = 0; i < HetVarosList.Count; i++)
////// {
////// if (IsSzomszedosMegyeE(HetVarosList[i].regio, sajatOsszesMEGYE))
////// {
////// if (!kozvetlenMegyek.Contains(HetVarosList[i].regio))
////// {
////// kozvetlenMegyek.Add(HetVarosList[i].regio);
////// }
////// }
////// }
//////
////////elsore megnezzuk hogy van-e itt 2 pontos megye, mert azt tamadjuk
//////List<Region> ketpontosMegye = new List<Region>();
//////for (int i = 0; i < kozvetlenMegyek.Count; i++ )
////// {
////// for (int j = 0; j < HetVarosList.Count; j++)
////// {
////// if (kozvetlenMegyek[i].name == HetVarosList[j].regio.name && (HetVarosList[j].pont > 1 && HetVarosList[j].pont <= 2))
////// {
////// if( !ketpontosMegye.Contains(kozvetlenMegyek[i]))
////// ketpontosMegye.Add((kozvetlenMegyek[i]));
////// }
////// } //if (HetVarosList.Where(a => a.regio == kozvetlenMegyek[i]).First().pont >= 2.0f)
////// }
//////
//////
//////for (int j = 0; j < SAJATMEGYESEREGGEL.Count; j++)
//////{
////// if (SAJATMEGYESEREGGEL[j].castle || SAJATMEGYESEREGGEL[j].city)
////// {
////// if (SAJATMEGYESEREGGEL[j].house == HOUSE.NONE) //elfoglaltuk-e
////// {
////// //ha igen akkor megtamadjuk
////// //ha tehetünk rá parit
////// if (sajatOsszesMEGYE.Contains(SAJATMEGYESEREGGEL[j]))
////// {
////// FinalKoronaOrderList.Add(new Tuple<Region, Region>(SAJATMEGYESEREGGEL[j], null));
////// sajatOsszesMEGYE.Remove(SAJATMEGYESEREGGEL[j]);
////// }
//////
////// }
////// }
//////}
//////
//////
//////
////// //na ezek abszolut támadhatóak,
////// //namármost figyelembe veszuk h alattunk 2 pontos megy van-e és ha igen és nem a mien akkor azt elfoglaljuk inkább ellenben mozgunk
//////
////// for (int i = 0; i < ketpontosMegye.Count; i++)
//////{
////// for (int j = 0; j < SAJATMEGYESEREGGEL.Count; j++)
////// {
////// if (ketpontosMegye[i].neighbours.Contains(SAJATMEGYESEREGGEL[j]))
////// {
////// if (SAJATMEGYESEREGGEL[j].castle || SAJATMEGYESEREGGEL[j].city)
////// {
////// if (SAJATMEGYESEREGGEL[j].house == h) //elfoglaltuk-e
////// {
////// //ha igen akkor megtamadjuk
////// //ha tehetünk rá parit
////// if (sajatOsszesMEGYE.Contains(SAJATMEGYESEREGGEL[j]))
////// {
////// FinalAttackOrderList.Add(new Tuple<Region, Region>(SAJATMEGYESEREGGEL[j], ketpontosMegye[i]));
////// sajatOsszesMEGYE.Remove(SAJATMEGYESEREGGEL[j]);
////// }
//////
////// }
////// else
////// {
////// if (sajatOsszesMEGYE.Contains(SAJATMEGYESEREGGEL[j]))
////// {
////// //ha nem a mienk akkor placeljuk
////// FinalKoronaOrderList.Add(new Tuple<Region, Region>(SAJATMEGYESEREGGEL[j], null));
////// sajatOsszesMEGYE.Remove(SAJATMEGYESEREGGEL[j]);
////// }
////// }
////// }
////// else
////// {
////// //amin allunk nincs ertekes pont
////// //hat megtamadjuk a msikat
////// if (sajatOsszesMEGYE.Contains(SAJATMEGYESEREGGEL[j]))
////// {
////// //ha nem a mienk akkor placeljuk
////// FinalAttackOrderList.Add(new Tuple<Region, Region>(SAJATMEGYESEREGGEL[j], ketpontosMegye[i]));
////// sajatOsszesMEGYE.Remove(SAJATMEGYESEREGGEL[j]);
////// }
////// }
////// }
////// }
//////}
//////
//////
//////List<Region> egyvkevesebbpontosMegye = new List<Region>();
//////for (int i = 0; i < kozvetlenMegyek.Count; i++)
//////{
////// for (int j = 0; j < HetVarosList.Count; j++)
////// {
////// if (kozvetlenMegyek[i].name == HetVarosList[j].regio.name && (HetVarosList[j].pont > 1 && HetVarosList[j].pont <= 2))
////// {
////// if (!egyvkevesebbpontosMegye.Contains(kozvetlenMegyek[i]))
////// egyvkevesebbpontosMegye.Add((kozvetlenMegyek[i]));
////// }
////// } //if (HetVarosList.Where(a => a.regio == kozvetlenMegyek[i]).First().pont >= 2.0f)
//////}
//////
//////for (int i = 0; i < egyvkevesebbpontosMegye.Count; i++)
//////{
////// for (int j = 0; j < SAJATMEGYESEREGGEL.Count; j++)
////// {
////// if (SAJATMEGYESEREGGEL[j].house == h)
////// {
////// if (MEGYEELLENSEGESMeletttunk.Contains(SAJATMEGYESEREGGEL[j]))
////// {
////// Region szomszedosmegyeamilehethtamad = null;
////// for (int k = 0; k < MEGYEELLENSEGESMeletttunk.Count; k++)
////// {
////// if (MEGYEELLENSEGESMeletttunk[k].neighbours.Contains(SAJATMEGYESEREGGEL[j]))
////// {
////// szomszedosmegyeamilehethtamad = MEGYEELLENSEGESMeletttunk[k];
////// break;
////// }
////// }
//////
////// if (szomszedosmegyeamilehethtamad != null)
////// {
//////
////// if (this.SeregemNagyobbE(gs, h, SAJATMEGYESEREGGEL[j], szomszedosmegyeamilehethtamad, false))
////// {
////// if (sajatOsszesMEGYE.Contains(SAJATMEGYESEREGGEL[j]))
////// {
////// //ha nem a mienk akkor placeljuk
////// FinalAttackOrderList.Add(new Tuple<Region, Region>(SAJATMEGYESEREGGEL[j], szomszedosmegyeamilehethtamad));
////// sajatOsszesMEGYE.Remove(SAJATMEGYESEREGGEL[j]);
////// }
//////
////// }
////// else
////// {
////// if (sajatOsszesMEGYE.Contains(SAJATMEGYESEREGGEL[j]))
////// {
////// //ha nem a mienk akkor placeljuk
////// FinalDefenseOrderList.Add(new Tuple<Region, Region>(SAJATMEGYESEREGGEL[j], null));
////// sajatOsszesMEGYE.Remove(SAJATMEGYESEREGGEL[j]);
////// }
//////
////// }
////// }
////// }
////// else
////// {
////// if (sajatOsszesMEGYE.Contains(SAJATMEGYESEREGGEL[j]))
////// {
////// //ha nem a mienk akkor placeljuk
////// FinalKoronaOrderList.Add(new Tuple<Region, Region>(SAJATMEGYESEREGGEL[j], null));
////// sajatOsszesMEGYE.Remove(SAJATMEGYESEREGGEL[j]);
////// }
////// }
////// }
////// }
//////}
//////
//////
//////
//////
//////List<Region> egynelkevesebbpontosmegye = new List<Region>();
//////for (int i = 0; i < kozvetlenMegyek.Count; i++)
//////{
////// for (int j = 0; j < HetVarosList.Count; j++)
////// {
////// if (kozvetlenMegyek[i].name == HetVarosList[j].regio.name && (HetVarosList[j].pont <= 1))
////// {
////// if (!egynelkevesebbpontosmegye.Contains(kozvetlenMegyek[i]))
////// egynelkevesebbpontosmegye.Add((kozvetlenMegyek[i]));
////// }
////// } //if (HetVarosList.Where(a => a.regio == kozvetlenMegyek[i]).First().pont >= 2.0f)
//////}
//////
//////for (int i = 0; i < egynelkevesebbpontosmegye.Count; i++)
//////{
////// for (int j = 0; j < SAJATMEGYESEREGGEL.Count; j++)
////// {
////// if (SAJATMEGYESEREGGEL[j] == egynelkevesebbpontosmegye[i])
////// {
////// if (sajatOsszesMEGYE.Contains(SAJATMEGYESEREGGEL[j]))
////// {
////// //ha nem a mienk akkor placeljuk
////// FinalKoronaOrderList.Add(new Tuple<Region, Region>(SAJATMEGYESEREGGEL[j], null));
////// sajatOsszesMEGYE.Remove(SAJATMEGYE[i]);
////// }
////// }
////// }
//////
//////}
//////
//////
//////for (int i = 0; i < SAJATMEGYE.Count; i++)
//////{
////// for (int j = 0; j < FinalDefenseOrderList.Count; j++)
////// {
////// if (SAJATMEGYE[i].neighbours.Contains(FinalDefenseOrderList[j].Item1))
////// {
////// if (sajatOsszesMEGYE.Contains(SAJATMEGYE[i]))
////// {
////// //ha nem a mienk akkor placeljuk
////// FinalSupportOrderList.Add(new Tuple<Region, Region>(SAJATMEGYE[i], null));
////// sajatOsszesMEGYE.Remove(SAJATMEGYE[i]);
////// }
////// }
////// }
//////
//////}
//if (egyvkevesebbpontosMegye[i].neighbours.Contains(SAJATMEGYESEREGGEL[j]))
//{
// //itt kellegy lista h hol van az ellenség hol van és azt megnézni h a szomszédos megyeken van-e elenség mert ott masszivan védekezni fogunk
// // if (egyvkevesebbpontosMegye[i].neighbours )
// {
//
// }
//}
// //utolsó lepesben megnezzuk h ebbol melyik van hozzank kozel
// List<Region> megkellTamadniVaros = new List<Region>();
//
// // azt tudjuk hogy 2 pontot er 1db szabad varos, 1pontot 1 elfoglalt
// //legfontosabb elsokorben szomszedos megyekben 2 es 2+os varosok kersese
// //ha ilyen nincs akkor az egyeseknel 2 pont alatt az 1pontos megyek ahol van varos az az ELLENESEGE erre nagyon figyeljunk
// //ezekbol pickeljuk a bestet
// //csata parancshatasara az egysegek MOST EGYOTT MOZOGNAK
//
// // sajat megyeink
// List<Region> OrderableRegions = new List<Region>();
//
// foreach (var item in gs.RegionList.Where(r => r.house == h))
// {
// OrderableRegions.Add(item);
// }
//
// //kozvetlenul elerheto megyek
// // sajat megye, kozvetlen szomszedja, ponterteke
// List<Tuple<Region, Region, float>> NeighbourRegionsPOINT = new List<Tuple<Region, Region, float>>();
//
// foreach (var item in SAJATMEGYE)
// {
// foreach (var neighb in item.neighbours)
// {
// foreach (var v in HetVarosList)
// {
// if (v.regio == neighb)
// {
// //itt bejohet olyan hiba h 3 megye tamadhatja ugyanazt
// //ezert fogjuk es megnezzuk h iylen tuple van-e mar es ha nincs akkor veszuk fe
// if (NeighbourRegionsPOINT.Where(nrp => nrp.Item2 == neighb).Count() == 0)
// NeighbourRegionsPOINT.Add(new Tuple<Region, Region, float>(item, neighb, v.pont));
// }
// }
// }
// }
//
// //erdemes megnezni h a listazott es pontozott megyek szomszedjainak milyen ertekei vannak(ha csokkene akkor egyezes eseten erdemes a masikat pickeleni)
//
// //csokenno rendezett sorrend
// NeighbourRegionsPOINT.OrderBy(np => np.Item3);
// NeighbourRegionsPOINT.Reverse();
//
// for (int i = 0; i < NeighbourRegionsPOINT.Count; i++)
// {
//
// //elso es legfontosabb ha olyan helyen alnak az egysegekek ahol a terulet meg nem az enyem akkor koronazok
// if (NeighbourRegionsPOINT[i].Item1.house == HOUSE.NONE && VanEIttEgysegem(gs,NeighbourRegionsPOINT[i].Item1, h) && SAJATMEGYE.Contains(NeighbourRegionsPOINT[i].Item1))
// {
// FinalKoronaOrderList.Add(NeighbourRegionsPOINT[i].Item1);
// SAJATMEGYE.Remove(NeighbourRegionsPOINT[i].Item1);
// }
//
// //ez egy kurvajo hely ennek a szomszedjara tuti rakunk tamadas parancsot
// if (NeighbourRegionsPOINT[i].Item3 >= 2 && SAJATMEGYE.Contains(NeighbourRegionsPOINT[i].Item1))
// {
// FinalAttackOrderList.Add(NeighbourRegionsPOINT[i].Item1);
// SAJATMEGYE.Remove(NeighbourRegionsPOINT[i].Item1);
// }
//
// if (NeighbourRegionsPOINT[i].Item3 > 1 && SAJATMEGYE.Contains(NeighbourRegionsPOINT[i].Item1))
// {
// FinalAttackOrderList.Add(NeighbourRegionsPOINT[i].Item1);
// SAJATMEGYE.Remove(NeighbourRegionsPOINT[i].Item1);
// }
//
// //ellensegge, itt okoskodni kell majd !!
// if (NeighbourRegionsPOINT[i].Item3 == 1 && NeighbourRegionsPOINT[i].Item2.house != HOUSE.NONE && SAJATMEGYE.Contains(NeighbourRegionsPOINT[i].Item1))
// {
// if (SeregemNagyobbE(gs, h, NeighbourRegionsPOINT[i].Item1, NeighbourRegionsPOINT[i].Item2, true))
// {
// //nagyobb a seregem daraljuk le
// FinalAttackOrderList.Add(NeighbourRegionsPOINT[i].Item1);
// SAJATMEGYE.Remove(NeighbourRegionsPOINT[i].Item1);
// }
// else
// {
// EnemyNextToUs.Add(NeighbourRegionsPOINT[i].Item2);
// }
// }
//
// //ezek nem olyan jó helyek de ezekre is rakunk
// if (NeighbourRegionsPOINT[i].Item3 < 1 && SAJATMEGYE.Contains(NeighbourRegionsPOINT[i].Item1))
// {
// if (NeighbourRegionsPOINT[i].Item3 < 0.12f)
// {
// FinalKoronaOrderList.Add(NeighbourRegionsPOINT[i].Item1);
// }
// else
// {
// FinalAttackOrderList.Add(NeighbourRegionsPOINT[i].Item1);
// }
//
// SAJATMEGYE.Remove(NeighbourRegionsPOINT[i].Item1);
// }
// }
// }
//
// //VEDEKEZES/RAID
//
// //megnezzuk h mire tamadhat, ill kivesszuk a legvaloszinubbet
//
// List<Region> veszelyeztettmegyeim = new List<Region>();
//
// // nagyon fontos lesz az a megye, ahol van varam/varosom, van melette ellenseg az kap
// //na ezek a megyek alavetoen raidot kapnak, de a varosos megyek def + supportot a szomszedjai
// List<Region> jelentosenVeszelyeztettMegyek = new List<Region>();
//
// foreach (var item in EnemyNextToUs)
// {
// foreach (var neighb in item.neighbours)
// {
// if (!veszelyeztettmegyeim.Contains(item))
// {
// //RAIDmEZOK
// veszelyeztettmegyeim.Add(item);
// }
// }
// }
//
// foreach (var item in EnemyNextToUs)
// {
// foreach (var neighb in item.neighbours)
// {
// //mienk és van rajta valami amit fájna elvesziteni,... ez egy ellegge szomoru dolog(lenne)
// //ezert ezek lesznek a DEFFENSE MEZOK
// if (neighb.house == h && (item.castle || item.city))
// {
// jelentosenVeszelyeztettMegyek.Add(neighb);
// }
// }
// }
//
// //na már most
// // az attacknal mar vettunk fel megyeket, na az ugy jó
// // aztán a raid-ot elvileg attol fuggetlenul pakoljuk le, az is jó
// // a DEFENSE jelentosege erosebb mint a RAID, ezert ha RAIDBAN es DEF-ben is van azonos megye a RAIDBOL kivesszuk
// // SUPPORT SZIGORUAN DEFFENSE MELLE megy kibaszott fontos, es sokat ha lehet
// // a maradekra az a retek koronas fos token aminek a nevet mindig elfeljtem
//
// FinalDefenseOrderList = jelentosenVeszelyeztettMegyek;
//
// foreach (var item in veszelyeztettmegyeim)
// {
// if (SAJATMEGYE.Contains(item))
// {
// FinalRaidOrderList.Add(item);
// SAJATMEGYE.Remove(item);
// }
// }
//
// foreach (var item in jelentosenVeszelyeztettMegyek)
// {
// foreach (var neighb in item.neighbours)
// {
// //if (!FinalDefenseOrderList.Contains(item) && !FinalRaidOrderList.Contains(item) && !FinalAttackOrderList.Contains(item))
// if(SAJATMEGYE.Contains(item))
// {
// FinalSupportOrderList.Add(item);
// SAJATMEGYE.Remove(item);
//
// }
// }
// }
//
// // na marmost ha maradt meg megyem akkor teszunk ra koronat
// foreach (var item in gs.RegionList)
// {
// if (item.house == h)
// {
// if (SAJATMEGYE.Contains(item))
// {
// FinalKoronaOrderList.Add(item);
// SAJATMEGYE.Remove(item);
//
// }
// }
// }
//
//namarmost fogjuk es placedorderekke alakitjuk oket
foreach (var item in FinalAttackOrderList)
{
if (!gs.m_lBannedOrders.Contains(ORDER_TYPE.ATTACK_PLUS))
PlacedOrderList.Add(new PlacedOrder(h, item.Item1, item.Item2, ORDER_TYPE.ATTACK_PLUS));
else if (!gs.m_lBannedOrders.Contains(ORDER_TYPE.ATTACK_NORMAL))
PlacedOrderList.Add(new PlacedOrder(h, item.Item1, item.Item2, ORDER_TYPE.ATTACK_PLUS));
else
PlacedOrderList.Add(new PlacedOrder(h, item.Item1, item.Item2, ORDER_TYPE.ATTACK_PLUS));
}
foreach (var item in FinalDefenseOrderList)
{
if (!gs.m_lBannedOrders.Contains(ORDER_TYPE.DEFEND_PLUSPLUS))
PlacedOrderList.Add(new PlacedOrder(h, item.Item1, item.Item2, ORDER_TYPE.DEFEND_PLUSPLUS));
else
PlacedOrderList.Add(new PlacedOrder(h, item.Item1, item.Item2, ORDER_TYPE.DEFEND_PLUS));
}
foreach (var item in FinalSupportOrderList)
{
if (!gs.m_lBannedOrders.Contains(ORDER_TYPE.SUPPORT_PLUS))
PlacedOrderList.Add(new PlacedOrder(h, item.Item1, item.Item2, ORDER_TYPE.SUPPORT_PLUS));
else
PlacedOrderList.Add(new PlacedOrder(h, item.Item1, item.Item2, ORDER_TYPE.SUPPORT));
}
foreach (var item in FinalRaidOrderList)
{
if (!gs.m_lBannedOrders.Contains(ORDER_TYPE.RAID_PLUS))
PlacedOrderList.Add(new PlacedOrder(h, item.Item1, item.Item2, ORDER_TYPE.RAID_PLUS));
else
PlacedOrderList.Add(new PlacedOrder(h, item.Item1, item.Item2, ORDER_TYPE.RAID));
}
foreach (var item in FinalKoronaOrderList)
{
if (!gs.m_lBannedOrders.Contains(ORDER_TYPE.CONDSOLIDATE_PLUS))
PlacedOrderList.Add(new PlacedOrder(h, item.Item1, item.Item2, ORDER_TYPE.CONDSOLIDATE_PLUS));
else
PlacedOrderList.Add(new PlacedOrder(h, item.Item1, item.Item2, ORDER_TYPE.CONDSOLIDATE));
}
}
public void Recruit( GameState gs, GAME.MODELS.HOUSE h, ref List<GAME.MODELS.Unit> unitList )
{
//kinyerjuk a szajbatekert, de lenyeges adatokat az aktualis allasbol
//ez a max elkoltheto
int MusteringPoints = gs.PlayerList.Where(p => p.playerHouse == h).First().musteringPoints;
//megnezzuk h mi lenne a legjobb belole
int allUnitCount = gs.UnitsList.Where(u => u.player == h).Count();
int soldierCount = gs.UnitsList.Count(u => u.player == h && u.type == GAME.MODELS.UNIT_TYPE.SOLDIER);
int knightCount = gs.UnitsList.Count(u => u.player == h && u.type == GAME.MODELS.UNIT_TYPE.KNIGHT);
int machineCount = gs.UnitsList.Count(u => u.player == h && u.type == GAME.MODELS.UNIT_TYPE.MACHINE);
bool recSold = false;
bool recKnight = false;
bool recMach = false;
//torekedunk az S-K-M 40-40-20 aranyra
if ( (soldierCount / allUnitCount) < 0.4f)
{
//katonat vonunk be
recSold = true;
}
if ((knightCount / allUnitCount) < 0.4f)
{
//katonat vonunk be
recKnight = true;
}
if ((machineCount / allUnitCount) < 0.2f)
{
//katonat vonunk be
recMach = true;
}
//mostmar tudjuk h mit kell bevonni
// kiszamoljuk h menyi DB-t kellene bevonni, majd ezt aranyositjuk az összes bevonhato pont alapjan
int shouldrecS = 0;
int shouldrecK = 0;
int shouldrecM = 0;
if (recSold) shouldrecS = Convert.ToInt32(allUnitCount * 0.4f);
if (recKnight) shouldrecK = Convert.ToInt32(allUnitCount * 0.4f);
if (recMach) shouldrecM = Convert.ToInt32(allUnitCount * 0.2f);
int shouldRecPointS = shouldrecS * 1;
int shouldRecPointK = shouldrecS * 2;
int shouldRecPointM = shouldrecS * 2;
int totalShouldRecPoint = shouldRecPointS + shouldRecPointK + shouldRecPointM;
if (MusteringPoints == totalShouldRecPoint)
{
//akkor bevonhatjuk mindet
}
if (MusteringPoints > totalShouldRecPoint)
{
//aranyositani kell, felszorozni az arannyal a bevonas darabszamat h noljon
float arany = (MusteringPoints / totalShouldRecPoint);
if (recSold) shouldrecS = Convert.ToInt32(shouldrecS * arany);
if (recKnight) shouldrecK = Convert.ToInt32(shouldrecK * arany);
if (recMach) shouldrecM = Convert.ToInt32(shouldrecM * arany);
}
//KESOBB MEGKELLNEZNI
// if (MusteringPoints < totalShouldRecPoint)
// {
// //aranyositani kell, be kell az arannyal a bevonas darabszamat h csokkenjen
// float arany = (MusteringPoints / totalShouldRecPoint) * 100;
// if (recSold) shouldrecS = (int)Math.Round(shouldrecS * arany);
// if (recKnight) shouldrecK = (int)Math.Round(shouldrecK * arany);
// if (recMach) shouldrecM = (int)Math.Round(shouldrecM * arany);
// }
//mostmar faszan megvan hanyat vonunk be, most megnzzuk hova vonhatjuk be oket
List<GAME.MODELS.Region> lehetsegesHelyek = new List<GAME.MODELS.Region>();
foreach (var item in gs.RegionList)
{
if ( item.house == h )
{
lehetsegesHelyek.Add(item);
}
}
//most ki kell szamolni hogy ezek kozul hova erdemes mekkora esellyel
//legfontosabb: szomszedos erod, szomszedos varos, sajaterod
List<GAME.MODELS.Region> TEMPlehetsegesHelyek = new List<GAME.MODELS.Region>();
foreach (var item in lehetsegesHelyek)
{
if (item.castle || item.city)
{
TEMPlehetsegesHelyek.Add(item);
}
else
{
foreach (var n in item.neighbours)
{
if (n.city || n.castle)
{
TEMPlehetsegesHelyek.Add(item);
}
}
}
}
//leszurtuk a "jelentektelen" helyeket
lehetsegesHelyek = TEMPlehetsegesHelyek;
// MAJD HA MEG LESZ IDO MARCIUS VEGEN HAHAHA - AKKOR
////itt sulyozni fogjuk azt h hova kellene bevonni a lehetseges helyek kozul
//List<Tuple<GAME.MODELS.Region, float>> sulyozottHelyek = new List<Tuple<GAME.MODELS.Region, float>>();
//
//foreach (var item in lehetsegesHelyek)
//{
// //sulyozasi szempontok:
// // - milyen egysegunk van ott
//}
string[] avaiableNext = new string[] { "S", "S", "K", "K", "M" };
string next = "S";
int freeID = gs.UnitsList.Count;
Random rnd = new Random();
int random = rnd.Next(0, lehetsegesHelyek.Count);
while ( ( shouldrecK <= 0 && shouldrecS <= 0 && shouldrecM <= 0) || MusteringPoints >= 0)
{
switch (next)
{
case "S":
if (MusteringPoints-1 < 0)
{
goto end;
}
GAME.MODELS.Unit u = new GAME.MODELS.Unit();
u.ID = freeID;
freeID++;
u.player = h;
u.position = lehetsegesHelyek[rnd.Next(0, lehetsegesHelyek.Count)];
unitList.Add(u);
MusteringPoints = MusteringPoints - 1;
shouldrecS--;
next = avaiableNext[rnd.Next(0, avaiableNext.Count())];
break;
case "K":
if (MusteringPoints - 2 < 0)
{
goto end;
}
u = new GAME.MODELS.Unit();
u.ID = freeID;
freeID++;
u.player = h;
u.position = lehetsegesHelyek[rnd.Next(0, lehetsegesHelyek.Count)];
unitList.Add(u);
MusteringPoints = MusteringPoints - 2;
shouldrecK--;
next = avaiableNext[rnd.Next(0, avaiableNext.Count())];
break;
case "M":
if (MusteringPoints - 2 < 0)
{
goto end;
}
u = new GAME.MODELS.Unit();
u.ID = freeID;
freeID++;
u.player = h;
u.position = lehetsegesHelyek[rnd.Next(0, lehetsegesHelyek.Count)];
unitList.Add(u);
MusteringPoints = MusteringPoints - 2;
shouldrecM--;
next = avaiableNext[rnd.Next(0, avaiableNext.Count())];
break;
default:
break;
}
}
end:
return;
}
public void ExecuteRaid(GameState gs, HOUSE h, ref List<PlacedOrder> raidList, ref List<PlacedOrder> attackList, ref List<PlacedOrder> consList, ref List<PlacedOrder> defList, ref List<PlacedOrder> supList, out string desc)
{
//azt tudjuk h akkor van pakolva raid ha mellettünk ellenség van
//namármost megnézzük a raidlistában h melyik raidok a mieink
//megnézzükh melyik meleltt van ellenség és random választunk
List<PlacedOrder> amibolValaszthatunk = new List<PlacedOrder>();
foreach (var item in raidList)
{
if (item.ownerPlayerName == h)
{
if (!amibolValaszthatunk.Contains(item))
{
amibolValaszthatunk.Add(item);
}
}
}
if (amibolValaszthatunk.Count > 0)
{
PlacedOrder vegrehajtando = amibolValaszthatunk[0];
//keressük meg h hova táamadhatok
List<Region> lehetsegesMegye = new List<Region>();
//ellensege a megye v ellenseg van rajta
foreach (var item in gs.UnitsList)
{
if (item.player != h)
{
//szóval ellenség,... a kis gyenyó
if (vegrehajtando.regionFrom.neighbours.Contains(item.position))
{
//esmegszomszedos is
if (!lehetsegesMegye.Contains(item.position))
{
lehetsegesMegye.Add(item.position);
}
}
}
}
foreach (var item in gs.RegionList)
{
if (vegrehajtando.regionFrom.neighbours.Contains(item))
{
if (item.house != h)
{
//ha nem a milyen de szomszedunk
if (!lehetsegesMegye.Contains(item))
{
lehetsegesMegye.Add(item);
}
}
}
}
if (lehetsegesMegye.Count > 0)
{
vegrehajtando.regionTo = lehetsegesMegye[0];
if (attackList.Count(a => a.regionFrom == vegrehajtando.regionTo) > 0)
{
attackList.Remove(attackList.Find(a => a.regionFrom == vegrehajtando.regionTo));
desc = h + " use " + vegrehajtando.order + " from: " + vegrehajtando.regionFrom.name + " to " + vegrehajtando.regionTo.name;
raidList.Remove(vegrehajtando);
return;
}
if (raidList.Count(a => a.regionFrom == vegrehajtando.regionTo) > 0)
{
raidList.Remove(raidList.Find(a => a.regionFrom == vegrehajtando.regionTo));
desc = h + " use " + vegrehajtando.order + " from: " + vegrehajtando.regionFrom.name + " to " + vegrehajtando.regionTo.name;
raidList.Remove(vegrehajtando);
return;
}
if (consList.Count(a => a.regionFrom == vegrehajtando.regionTo) > 0)
{
consList.Remove(consList.Find(a => a.regionFrom == vegrehajtando.regionTo));
desc = h + " use " + vegrehajtando.order + " from: " + vegrehajtando.regionFrom.name + " to " + vegrehajtando.regionTo.name;
raidList.Remove(vegrehajtando);
return;
}
if (defList.Count(a => a.regionFrom == vegrehajtando.regionTo) > 0)
{
defList.Remove(defList.Find(a => a.regionFrom == vegrehajtando.regionTo));
desc = h + " use " + vegrehajtando.order + " from: " + vegrehajtando.regionFrom.name + " to " + vegrehajtando.regionTo.name;
raidList.Remove(vegrehajtando);
return;
}
if (supList.Count(a => a.regionFrom == vegrehajtando.regionTo) > 0)
{
supList.Remove(supList.Find(a => a.regionFrom == vegrehajtando.regionTo));
desc = h + " use " + vegrehajtando.order + " from: " + vegrehajtando.regionFrom.name + " to " + vegrehajtando.regionTo.name;
raidList.Remove(vegrehajtando);
return;
}
}
if (raidList.Contains(vegrehajtando))
{
raidList.Remove(vegrehajtando);
}
}
//// most megnezzuk h melettunk hol van serreg
////erdemes azt megnezni hogy mi az amit csak egy parancscsal érek el, es mi az amit többel is,
////mert akkor zzal kell leszedni amivel csak egyszer erjuk el
//
//
//List<regioPont> regioHanyszorerjukEl = new List<regioPont>();
//
//foreach (var item in amibolValaszthatunk)
//{
// foreach (var n in item.regionFrom.neighbours)
// {
// foreach (var unit in gs.UnitsList)
// {
// //ha az akis paraszt nem a milyen és a szomszédos région áll akkor bizony hozzáadjuk a listhoz
// if (unit.player != h && unit.position == n)
// {
// regioPont newR;
// newR.regioFrom = item.regionFrom;
// newR.regioTo = n;
// newR.pont = 1;
// if ( regioHanyszorerjukEl.Where( a => a.regioTo == n).Count() > 0)
// {
// int aktpont = regioHanyszorerjukEl.Find(a => a.regioTo == n).pont;
// regioHanyszorerjukEl.Remove(regioHanyszorerjukEl.Find(a => a.regioTo == n));
// newR.pont = aktpont;
// }
//
// regioHanyszorerjukEl.Add(newR);
// break;
// }
// }
// }
//}
//
////namostmár megvan h mi hányszor erheto el,.. lehetoleg novekvo sorrendbe pakolva hasznaljuk
//
//regioHanyszorerjukEl = regioHanyszorerjukEl.OrderBy(i => i.pont).ToList();
//
////novekvo sorrenben van
//
//
//PlacedOrder vegrehajtando;
//
//if (regioHanyszorerjukEl.Count > 0)
//{
// vegrehajtando = amibolValaszthatunk.Find(m => m.regionFrom == regioHanyszorerjukEl[0].regioFrom);
// if (vegrehajtando == null)
// {
// throw new Exception();
// }
//
//
// //vegrejatas
//
// //mekkeressuk h odamilyen parancsot raktak és azt leszedjuk
//
// if( attackList.Count(a => a.regionFrom == vegrehajtando.regionTo) > 0 )
// {
// attackList.Remove(attackList.Find(a => a.regionFrom == vegrehajtando.regionTo));
// desc = h + " use " + vegrehajtando.order + " from: " + vegrehajtando.regionFrom.name + " to " + vegrehajtando.regionTo.name;
// raidList.Remove(vegrehajtando);
// return;
// }
//
// if (raidList.Count(a => a.regionFrom == vegrehajtando.regionTo) > 0)
// {
// raidList.Remove(raidList.Find(a => a.regionFrom == vegrehajtando.regionTo));
// desc = h + " use " + vegrehajtando.order + " from: " + vegrehajtando.regionFrom.name + " to " + vegrehajtando.regionTo.name;
// raidList.Remove(vegrehajtando);
// return;
// }
//
// if (consList.Count(a => a.regionFrom == vegrehajtando.regionTo) > 0)
// {
// consList.Remove(consList.Find(a => a.regionFrom == vegrehajtando.regionTo));
// desc = h + " use " + vegrehajtando.order + " from: " + vegrehajtando.regionFrom.name + " to " + vegrehajtando.regionTo.name;
// raidList.Remove(vegrehajtando);
// return;
// }
//
// if (defList.Count(a => a.regionFrom == vegrehajtando.regionTo) > 0)
// {
// defList.Remove(defList.Find(a => a.regionFrom == vegrehajtando.regionTo));
// desc = h + " use " + vegrehajtando.order + " from: " + vegrehajtando.regionFrom.name + " to " + vegrehajtando.regionTo.name;
// raidList.Remove(vegrehajtando);
// return;
// }
//
// if (supList.Count(a => a.regionFrom == vegrehajtando.regionTo) > 0)
// {
// supList.Remove(supList.Find(a => a.regionFrom == vegrehajtando.regionTo));
// desc = h + " use " + vegrehajtando.order + " from: " + vegrehajtando.regionFrom.name + " to " + vegrehajtando.regionTo.name;
// raidList.Remove(vegrehajtando);
// return;
// }
//
//
//}
desc = " raiddalvmi baj van";
}
public PlacedOrder ExecuteAttack(GameState gs, GAME.MODELS.HOUSE h, ref List<PlacedOrder> placedOrderList, ref List<Unit> unitList, out string descText, GameInfo gInfo)
{
descText = null;
List<PlacedOrder> amibolValaszthatunk = new List<PlacedOrder>();
foreach (var item in placedOrderList)
{
if (item.order == ORDER_TYPE.ATTACK_MINUS || item.order == ORDER_TYPE.ATTACK_NORMAL || item.order == ORDER_TYPE.ATTACK_PLUS)
{
if (item.ownerPlayerName == h)
{
amibolValaszthatunk.Add(item);
}
}
}
// na szoval
///mindig az elsot hajtjuk vegre
if (amibolValaszthatunk.Count != 0)
{
PlacedOrder vegrehajtando = amibolValaszthatunk[0];
descText = h.ToString();
//megnezzuk van-e ellenseg a target teruleten
//ehhez tudnnonk kellh holvan ellenseg
List<Region> ezenAmegyenEllensegVan = new List<Region>();
foreach (var item in unitList)
{
if (item.player != h && item.player != HOUSE.NONE)
{
if (!ezenAmegyenEllensegVan.Contains(item.position))
{
ezenAmegyenEllensegVan.Add(item.position);
}
}
}
if (ezenAmegyenEllensegVan.Contains(vegrehajtando.regionTo))
{
//csata
// itt asszem bekéne hivni gameinfobol a csatát
if (gInfo.Battle(ref unitList, ref gs.RegionList, vegrehajtando.regionFrom, vegrehajtando.regionTo))
{
//megnyertuk a csattat
//atmuvoljuk a seregunket
HOUSE vesztes = HOUSE.NONE;
foreach (var item in unitList)
{
//osszegyujtjok h kik vannak itt es koet rajkuk a sajt helyukre
if (item.position == vegrehajtando.regionTo)
{
vesztes = item.player;
}
}
if (vesztes == HOUSE.NONE)
{
throw new Exception("bajvanbaj,...\nTCS\n");
}
//most szetdobjuk oket a tobbi mezore
List<Region> lehetsegesmegyekazathelyezesre = new List<Region>();
foreach (var item in vegrehajtando.regionTo.neighbours)
{
if ((item.house == vesztes) || ( item.house == HOUSE.NONE))
{
if (!lehetsegesmegyekazathelyezesre.Contains(item))
{
lehetsegesmegyekazathelyezesre.Add(item);
}
}
}
descText = h + " execute attack(battle) from " + vegrehajtando.regionFrom.name + " to " + vegrehajtando.regionTo.name + " ( result: WIN )";
foreach (var item in unitList)
{
if (item.position == vegrehajtando.regionTo)
{
Random rnd = new Random();
item.position = lehetsegesmegyekazathelyezesre[rnd.Next(0, lehetsegesmegyekazathelyezesre.Count)];
descText += "\n defeated unit: " + item.type + " ( ID: " + item.ID + " ) moved to: " + item.position.name;
}
}
return vegrehajtando;
}
else
{
descText = h + " execute attack(battle) from " + vegrehajtando.regionFrom.name + " to " + vegrehajtando.regionTo.name + " ( result: LOST )";
return vegrehajtando;
}
}
else
{//movin'
int sum = 0;
foreach (var item in unitList)
{
//elvileg csak a sajatuk van itt
if (item.position == vegrehajtando.regionFrom)
{
item.position = vegrehajtando.regionTo;
sum++;
}
}
descText = h + " execute attack(move) from " + vegrehajtando.regionFrom.name + " to " + vegrehajtando.regionTo.name + " ( moved unit: " + sum + " )";
}
//vegultoroljuk
return vegrehajtando;
}
throw new Exception("itt valami elvan baszva");
}
public PlacedOrder ExecuteConsolidate(GameState gs, GAME.MODELS.HOUSE h, ref List<PlacedOrder> placedOrderList, ref List<Region> regionList, out string descText)
{
List<PlacedOrder> amibolValaszthatunk = new List<PlacedOrder>();
foreach (var item in placedOrderList)
{
if (item.order == ORDER_TYPE.CONDSOLIDATE || item.order == ORDER_TYPE.CONDSOLIDATE_PLUS)
{
if (item.ownerPlayerName == h)
{
amibolValaszthatunk.Add(item);
}
}
}
// na szoval
//ezek igazabol terulet foglalo tokenek, szoval ahol vegrehajtjuk ott az a mienklesz
if( amibolValaszthatunk.Count > 0 )
{
PlacedOrder vegreh = amibolValaszthatunk[0];
for (int i = 0; i < regionList.Count; i++)
{
if (regionList[i].name == vegreh.regionFrom.name)
{
regionList[i].house = h;
}
}
descText = h + " use " + vegreh.order.ToString() + " at: " + vegreh.regionFrom.name;
return vegreh;
}
throw new Exception("szintén");
//foreach (var item in amibolValaszthatunk)
//{
// Region temp = new Region();
// for( int i = 0; i < regionList.Count; i++)
// {
// if ( item.regionFrom.name == regionList[i].name)
// {
// temp = regionList[i];
// temp.house = h;
// regionList.Remove(regionList[i]);
// regionList.Insert(i, temp);
// }
// }
//}
//
////mostmar h jol elfoglaltuk a helyeket, toroljuk a parancsokat
//
//foreach (var v in amibolValaszthatunk)
//{
// for (int i = 0; i < placedOrderList.Count; i++)
// {
// if (v.regionFrom == placedOrderList[i].regionFrom)
// {
// placedOrderList.Remove(placedOrderList[i]);
// }
// }
//}
}
private bool VanEIttEgysegem(GameState gs, Region item2, HOUSE h)
{
foreach (var item in gs.UnitsList)
{
if (item.position.name == item2.name && item.player == h)
{
return true;
}
}
return false;
}
private bool SeregemNagyobbE(GameState gs, HOUSE h, Region sajatRegio, Region SzomszedosEllensegesRegio, bool VarostTamadokE)
{
int seregemEreje = 0;
int ellensegEreje = 0;
foreach (var item in gs.UnitsList)
{
if (item.position == SzomszedosEllensegesRegio )
{
if (item.type == UNIT_TYPE.MACHINE)
{
ellensegEreje += 0;
}
ellensegEreje += item.attackPoint;
}
if (item.position == sajatRegio)
{
if (item.type == UNIT_TYPE.MACHINE)
{
if (VarostTamadokE)
{
seregemEreje += item.attackPoint;
}
else
{
seregemEreje += 0;
}
}
seregemEreje += item.attackPoint;
}
}
if (seregemEreje == ellensegEreje)
{
//akkor majd megraidoljuk
return false;
}
if (seregemEreje > ellensegEreje)
{
//nyugodtan megtamadhatjuk a gecibe
return true;
}
else
{
return false;
}
throw new Exception();
}
