public PlacedOrder(HOUSE _name, Region _regionFrom, Region _regionTo, ORDER_TYPE _order)
{
this.ownerPlayerName = _name;
this.regionFrom = _regionFrom;
this.regionTo = _regionTo;
this.order = _order;
}
public Unit CreateShip(HOUSE h)
{
ID = 0;
player = h;
type = UNIT_TYPE.KNIGHT;
defeated = false;
attackPoint = 1;
defendPoint = 1;
cost = 1;
return this;
}
public Unit CreateSoldier(HOUSE h)
{
ID = 0;
player = h;
type = UNIT_TYPE.SOLDIER;
defeated = false;
attackPoint = 1;
defendPoint = 1;
cost = 1;
return this;
}
public Unit CreateMachine(HOUSE h)
{
ID = 0;
player = h;
type = UNIT_TYPE.MACHINE;
defeated = false;
attackPoint = 4; // akkor negy ha erod/varat tamad amugy 0
defendPoint = 0;
cost = 2;
return this;
}
public void mustering(HOUSE playerName, string typeOfUnit)
{
CPlayer plyr = findPlayerByName(playerName);
Assert.IsNull(plyr);
if (typeOfUnit == "ship" || typeOfUnit == "trooper")
{
if (checkMusteringPoints(plyr, typeOfUnit))
--plyr.musteringPoints;
}
else if (typeOfUnit == "siege" || typeOfUnit == "horseman")
{
if (checkMusteringPoints(plyr, typeOfUnit))
plyr.musteringPoints -= 2;
}
}
//erofassok alapjan szamola
public float GetPlayerPoints( HOUSE h )
{
foreach (var p in m_lPlayerList)
{
if (p.playerHouse != h)
continue;
float nscore = 0;
nscore += p.numberOfCities * 2;
nscore += m_lUnitsList.Where(u => (u.player == p.playerHouse) && ((u.type == UNIT_TYPE.KNIGHT) || (u.type == UNIT_TYPE.SOLDIER))).Count() * 1.75f;
nscore += p.numberOfPowerTokens * 1.5f;
nscore += (1 / p.positionOnSwordInfluencetrack + 1);
nscore += (1 / ((p.positionOnRavenInfluencetrack +1) / 2));
nscore += (1 / p.positionOnSwordInfluencetrack +1 );
return nscore;
}
throw new IndexOutOfRangeException();
}
private void CheckWinner( HOUSE h )
{
int sum = 0;
foreach (var item in m_lRegionList)
{
if (item.house == h)
{
sum++;
}
}
if (sum >= 7)
{
AddToOutput("================================");
AddToOutput("Jatek nyertesek:\n");
AddToOutput("The Winner with 7 castle is: " + h);
throw new HaveWinnerException();
}
}
private bool ReconcileIsBetter(HOUSE h)
{
//elso lepesbebn lemasoljuk az osszes adatot h ne basztassuk azokat
int actualpos = PositionOnScoreBoard(h);
//elrakjuk az eredeti pontokat hogy visszatudjuk allitani ha megse jo
// HOUSE, SUPPLY, POWER
List<Tuple<HOUSE, int, int>> eredeti = new List<Tuple<HOUSE, int, int>>();
foreach (var item in m_lPlayerList)
{
eredeti.Add(new Tuple<HOUSE, int, int>(item.playerHouse, item.musteringPoints, item.numberOfPowerTokens));
}
//vegrehajtjuk
Reconcile();
int newPos = PositionOnScoreBoard(h);
if (newPos <= actualpos)
{//ha jobb pozicio lett reconcile után v ugyanaz akkor ROLLBACK és truereturn
//parasztrolbekk
for (int i = 0; i < m_lPlayerList.Count; i++)
{
for (int j = 0; j < eredeti.Count; j++)
{
if (m_lPlayerList[i].playerHouse == eredeti[j].Item1)
{
m_lPlayerList[i].musteringPoints = eredeti[j].Item2; ;
m_lPlayerList[i].numberOfPowerTokens = eredeti[j].Item3;
}
}
}
return true;
}
else
{
//ha nem akkor ROLEBACK és FALSE
//parasztrolbekk
for (int i = 0; i < m_lPlayerList.Count; i++)
{
for (int j = 0; j < eredeti.Count; j++)
{
if (m_lPlayerList[i].playerHouse == eredeti[j].Item1)
{
m_lPlayerList[i].musteringPoints = eredeti[j].Item2; ;
m_lPlayerList[i].numberOfPowerTokens = eredeti[j].Item3;
}
}
}
return false;
}
//return true;
}
//hivatalos szabalyzat szerint szamolva
public int PositionOnScoreBoard(HOUSE h)
{
List<Tuple<HOUSE, int>> sorrend = new List<Tuple<HOUSE, int>>();
foreach (var item in m_lPlayerList)
{
int score = 0;
score += m_lRegionList.Where(r => (r.house == item.playerHouse && (r.castle || r.city))).Count();
sorrend.Add(new Tuple<HOUSE, int>(item.playerHouse, score));
}
sorrend.Sort((x, y) => x.Item2.CompareTo(y.Item2));
sorrend.Reverse();
List<HOUSE> holtversenyzok = new List<HOUSE>();
//akkor van holtverseny ha az elsonek a pontjaival egyenlo van valakinek
//azert egyrol indul mert ha 0rol menne akkor mindig az elso belekerulne, mert egyenlo onmagaval
for (int i = 1; i < sorrend.Count; i++)
{
if (sorrend[0].Item2 == sorrend[i].Item2)
{
holtversenyzok.Add(sorrend[i].Item1);
}
}
//nincs holtverseny
if ( /*holtverseny == false*/ holtversenyzok.Count == 0)
{
for (int i = 0; i < sorrend.Count; i++)
{
if (sorrend[i].Item1 == h)
{
return i;
}
}
}
else
{
//elso lepesben a vegleges sorrend vege megvan a sorrendben
//ezert a holtversenyzoket kiszedjuk onnan
for (int i = 0; i < holtversenyzok.Count; i++)
{
sorrend.RemoveAll(t => t.Item1 == holtversenyzok[i]);
}
//mos megnezzuk h kinekek van tobb tobb erodje
List<Tuple<HOUSE, int>> sorrend2 = new List<Tuple<HOUSE, int>>();
foreach (var item in m_lPlayerList)
{
if (holtversenyzok.Contains(item.playerHouse))
{
int score = 0;
score += m_lRegionList.Where(r => (r.house == item.playerHouse && (r.castle))).Count();
sorrend2.Add(new Tuple<HOUSE, int>(item.playerHouse, score));
}
}
sorrend2.Sort((x, y) => x.Item2.CompareTo(y.Item2));
sorrend2.Reverse();
holtversenyzok.Clear();
//akkor van holtverseny ha az elsonek a pontjaival egyenlo van valakinek
for (int i = 1; i < sorrend2.Count; i++)
{
if (sorrend2[0].Item2 == sorrend2[i].Item2)
{
holtversenyzok.Add(sorrend2[i].Item1);
}
}
//osszerakjuk a listat
for (int i = 0; i < sorrend.Count; i++)
{
foreach (var item in sorrend)
{
sorrend2.Add(item);
}
}
sorrend = sorrend2;
//nincs holtverseny
if ( /*holtverseny == false*/ holtversenyzok.Count == 0)
{
for (int i = 0; i < sorrend.Count; i++)
{
if (sorrend[i].Item1 == h)
{
return i;
}
}
}
else
{
//megminidg dontotetlen, iylenkor jonnek a supplykat nezuk amit ugye nem szamolunk, ezrt powertoken
//elso lepesben a vegleges sorrend vege megvan a sorrendben
//ezert a holtversenyzoket kiszedjuk onnan
for (int i = 0; i < holtversenyzok.Count; i++)
{
sorrend.RemoveAll(t => t.Item1 == holtversenyzok[i]);
}
//mos megnezzuk h kinekek van tobb tobb erodje
List<Tuple<HOUSE, int>> sorrend3 = new List<Tuple<HOUSE, int>>();
foreach (var item in m_lPlayerList)
{
if (holtversenyzok.Contains(item.playerHouse))
{
int score = 0;
score += m_lRegionList.Where(r => (r.house == item.playerHouse && (r.castle))).Count();
sorrend3.Add(new Tuple<HOUSE, int>(item.playerHouse, score));
}
}
sorrend3.Sort((x, y) => x.Item2.CompareTo(y.Item2));
sorrend3.Reverse();
holtversenyzok.Clear();
//akkor van holtverseny ha az elsonek a pontjaival egyenlo van valakinek
for (int i = 1; i < sorrend3.Count; i++)
{
if (sorrend3[0].Item2 == sorrend3[i].Item2)
{
holtversenyzok.Add(sorrend3[i].Item1);
}
}
//osszerakjuk a listat
for (int i = 0; i < sorrend.Count; i++)
{
foreach (var item in sorrend)
{
sorrend3.Add(item);
}
}
sorrend = sorrend3;
//nincs holtverseny
if ( /*holtverseny == false*/ holtversenyzok.Count == 0)
{
for (int i = 0; i < sorrend.Count; i++)
{
if (sorrend[i].Item1 == h)
{
return i;
}
}
}
else
{
//itt mar a holtverseny csak a az egysegek erejen mulik
//elso lepesben a vegleges sorrend vege megvan a sorrendben
//ezert a holtversenyzoket kiszedjuk onnan
for (int i = 0; i < holtversenyzok.Count; i++)
{
sorrend.RemoveAll(t => t.Item1 == holtversenyzok[i]);
}
//mos megnezzuk h kinekek van tobb tobb erodje
List<Tuple<HOUSE, int>> sorrend4 = new List<Tuple<HOUSE, int>>();
foreach (var item in m_lPlayerList)
{
if (holtversenyzok.Contains(item.playerHouse))
{
int score = 0;
score += m_lUnitsList.Where(u => (u.player == item.playerHouse)).Count();
sorrend4.Add(new Tuple<HOUSE, int>(item.playerHouse, score));
}
}
sorrend4.Sort((x, y) => x.Item2.CompareTo(y.Item2));
sorrend4.Reverse();
holtversenyzok.Clear();
//akkor van holtverseny ha az elsonek a pontjaival egyenlo van valakinek
for (int i = 1; i < sorrend4.Count; i++)
{
if (sorrend4[0].Item2 == sorrend4[i].Item2)
{
holtversenyzok.Add(sorrend4[i].Item1);
}
}
//osszerakjuk a listat
for (int i = 0; i < sorrend.Count; i++)
{
foreach (var item in sorrend)
{
sorrend4.Add(item);
}
}
sorrend = sorrend4;
//
//ez mar a veglegs igy feleslegs a vizsgalat
//if ( /*holtverseny == false*/ holtversenyzok.Count == 0)
{
for (int i = 0; i < sorrend.Count; i++)
{
if (sorrend[i].Item1 == h)
{
return i;
}
}
}
}
}
}
throw new Exception();
}
public PlacedOrderStruct(HOUSE _name, regionStruct _region, OrderStruct _order)
{
this.ownerPlayerName = _name;
this.region = _region;
this.order = _order;
}
public void Support(HOUSE player1, HOUSE player2, ref int tamadoPont, ref int vedoPont)
{
Random rnd = new Random();
int res = rnd.Next(0, 3);
switch (res)
{
case 0:
tamadoPont++;
break;
case 1:
vedoPont++;
break;
default:
break;
}
}
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";
}
//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));
}
}
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();
}
public CPlayer GetPlayerByHouse(HOUSE h)
{
foreach (var item in mPlayerList)
{
if (item.PlayerHouse == h)
{
return item;
}
}
return null;
}
public CPlayer findPlayerByName(HOUSE requestedName)
{
CPlayer ret = null;
foreach (var item in mPlayerList)
{
if (item.playerHouse == requestedName)
ret = item;
}
return ret;
}
public unitStruct CreateKnight(HOUSE h)
{
ID = 0;
player = h;
type = UNIT_TYPE.KNIGHT;
defeated = false;
attackPoint = 2;
defendPoint = 2;
cost = 2;
return this;
}
