} // flag di fine simulazione
// costruttore della classe
public SimMover(Spot.day_night _dnOps, InfoWindow _winI, TroopsManager _troopM, EliManager _eliM, SpotManager _spotM, CargoManager _cargoM)
{
this.DNOps = _dnOps; // passo la struttua giorno notte
this.WinI = _winI; // passo la finestra informazioni
this.TroopM = _troopM; // passo il manager truppe
this.EliM = _eliM; // passo il manager elicotteri
this.SpotM = _spotM; // passo il manager spot
this.CargoM = _cargoM; // passo il manager cargo
this.Speed = 100; // set iniziale della velocità pari a 100 knots
this.EndProgramState = false; // inizializzo l'end state a falso
}
} // fine metodo
// controlla se l'elicottero puo' ospitare il numero di truppe indicato
// restituisce vero se l'operazione è fattibile falso se invece l'operazione non è fattibile
public bool EliTroopsCheck (int troopsN, Elicottero eli , TroopsManager TroopsM)
{
int k; // var indice
int totW = 0;//peso totale delle truppe
if (TroopsM.TroopList.Count >= troopsN) {// controllo se ho le truppe che servono
for (k=0; k< troopsN; k++)
totW = totW + TroopsM.SingleSoldierW;// controllo il peso totale necessario
if (totW < eli.WTroopsLeftOnBoard) return true; // risultato
}return false;
} // fine metodo
public InfoWindow winI; // finestra informazioni
// al costruttore viene passato il numero di truppe, la lista è ancora vuota
// e viene allocato lo spazio in memoria necessario
protected TruppeOptions(int Troop, InfoWindow _winI) : base(Gtk.WindowType.Toplevel)
{
this.winI = _winI;
this._troop = Troop;
this.Build();
// viene creato il manager delle truppe
// con il factory method
// l'opzione 1 indica che si tratta di un troops manager
TroopM = (TroopsManager)FactoryManager.Make(1, Troop, winI); // creazione manager
this.winI.InsertSomeText("TROOPS MANAGER: effettuata creazione manager per truppe");
// viene definita l'istanza del numero di elementi richiesti
TroopM.MakeList(Troop); // creazione della lista truppe
}
// le classi statiche non hanno un costruttore
// con la variabile elementi viene indicato il numero iniziale di elementi che dovra' vestire il manager.
public static AbstractManager Make(int id, int elementi, InfoWindow winI)
{
switch (id)
{
case 0:
default: return(EliManager.Instance(elementi, winI)); // manager per elicotteri
case 1: return(TroopsManager.Instance(elementi, winI)); // manager per truppe
case 2: return(SpotManager.Instance(elementi, winI)); // manager per spot
case 3: return(CargoManager.Instance(elementi, winI)); //manager per cargo
}
}
public bool assignEnded; // se TRUE indica l'assegnazione iniziale degli spot dedicati
// al simulatore vengono passate tutte le informazioni necessarie alla simulazione degli eventi
public Simulator(int distance, Spot.day_night _dnOps, InfoWindow _winI, TroopsManager _troopM, EliManager _eliM, SpotManager _spotM, CargoManager _cargoM)
{
// passo al simulatore TUTTE le informazioni necessarie
this.DNOps = _dnOps; // operazione day night
this.TroopM = _troopM; // manager truppe e lista truppe
this.EliM = _eliM; // manager eli e lista eli
this.SpotM = _spotM; // magaer spot e lista spot
this.CargoM = _cargoM; // manager cargo e lista cargo
this.WinI = _winI; // information window
this.Distance = distance; // pass il paramentro distanz
this.WinI.InsertSomeText("SIMULATOR: simulatore creato. Effettuo l'inizializzazione....");
// creazione della logica di gesitione e della grafica di funzionamento
simMoverLogic = new SimMover(this.DNOps, this.WinI, this.TroopM, this.EliM, this.SpotM, this.CargoM);
simulG = new GrafXNA(this.simMoverLogic); // costruzione del supporto grafico di riferimento
}
// restituisce l'elicottero efficiente in grado di contenere il cargo specificato
// con le truppe necessarie
// viene effettuato anche il controllo sugli operatori necessari per la movimentazione
// del cargo stesso, Viene impiegato prima l'elicottero con il maggior peso dsponibile
public Elicottero EliAbleToCargo(Cargo cargo, TroopsManager troopM)
{
int minTWeight = 0; // peso totale minimo tra cargo e truppe a bordo trovato su elicotteri disponibili
Elicottero eliMinW = null; // elicottero efficiente che ha il maggior carico disponibile
foreach (Elicottero eli in this.ElicotteriList) // per ogni elicottero in lista
// controllo che lo spot sia occupato da un elicottero efficiente, e che abbia lo spazio per cargo e truppe richieste
{
if ((eli.isRequiredForOP && eli.Go_goback && !eli.IsBlocked && eli.IsEfficient && !eli.IsCargoFull && !eli.IsFlying &&
eli.WCargoLeftOnBoard >= cargo.ChecktotalCargoWeight()))
{
// controllo che l'elicottero sia quello ceh offre la maggior disponibilità di cargo
if ((eli.WCargoLeftOnBoard) > minTWeight)
{
minTWeight = eli.WCargoLeftOnBoard;
eliMinW = eli; // assegno l'elicottero
}
}
}
return(eliMinW); // ritorno l'elicottero trovato se non lo trova rotorna null
}
// LIST DISPOSER MODULES
// - controllo il numero di spot occupati
// - calcolo lo spazio totate sugli eli
// - distribuisco le truppe equamente sugli elicotteri
public void EliSpotTroopDistribution (SpotManager SpotM , TroopsManager TroopsM , InfoWindow winI)
{
int totWEli=SpotM.TotalWEliSpotForTroopS(); // calcolo il peso totale disponibile dagli elicotteri sugli spot
int totWTroops = TroopsM.TroopList.Count*TroopsM.SingleSoldierW; // calcolo il peso totale delle truppe da imbarcare
int w_Embarcable=0;// peso imbarcabile corrispondente al minore tra il peso totale disponibile ed il peso totale truppe
int troopsE=0;// truppe imbarcabili
int i=0; // variabile indice
if (totWTroops<totWEli) w_Embarcable=totWTroops; else w_Embarcable=totWEli; // se il peso totale dell truppe da imbarcare è
// minore rispetto al peso totale disponibile sugli elicotteri
// allora le truppe imbarcabili saranno il minimo tra i due valori
troopsE=w_Embarcable/TroopsM.SingleSoldierW;//trasformo il peso imbarcabile in uomini da imbarcare
winI.InsertSomeText("TROOPS DISPOSER: ponte di volo occupato da: "+SpotM.TotalElionDeck()
+ " Elicotteri sul ponte pronti per l'imbarco di "+troopsE +" truppe");
//trasferisco ogno uomo su ogni elicottero disponibile con una distribuzione alternata
//su tutti gli elicotteri disponibili, la distribuzione di reitera fino a a quando tutti gli uomini
// sono stati spostati sugli elicotteri.
if (troopsE>0) // se esistono truppe da imbarcare
while ( i<troopsE) // continua fino a quando l'indice è inferiore alle truppe
{
foreach (Spot spot in SpotM.Spotlist) // per ogni spot
{ // se spot occupato da un elicottero in moto e pale aperte e l'elicottero puo' ospitare le truppe, allora effettuo il carico
if (spot != null && spot.Eli != null
&& !spot.Eli.IsBlocked // eli non bloccato
&&!spot.Eli.IsFull // eli non pieno di cargo e truppe
&& !spot.Eli.isTroopsFull // eli non pieno di truppe
&& spot.Eli.IsRunning // eli in moto
&& spot.Eli.IsBladeSpread // eli a pale a perte
&& (TroopsM.TroopList.Count>0) // eli con truppe a bordo
&& (spot.Eli.WTroopsLeftOnBoard >= TroopsM.SingleSoldierW)) {// truppe accettabili superano il peso del singolo
// scambio di lista, simulo che la truppa imbarca sull'elicottero sistemato sul ponte, la lista verra poi passata alla landing zone
// per permettere lo sbarco della truppa
TroopsM.TroopList [TroopsM.TroopList.Count - 1].IsEli = true; // imposto la truppa in elicottero
spot.Eli.IstroopsOnBoard = true; // elicottero ha truppe a bordo
try{
// sposto la truppa dalla lista truppe a bordo
TroopsM.MoveElement (TroopsM.TroopList, spot.Eli.EliSoldierList, TroopsM.TroopList [(TroopsM.TroopList.Count) - 1]);
}
catch{
System.Console.WriteLine ("ERRORE SPOSTAMENTO TRUPPE");
} // alla lista truppe sull'elicottero
spot.Eli.IsBoarding = true; // l'elicottero sta imbarcando truppe
// diminuisco il peso totale disponibile sull'eli
spot.Eli.WTroopsLeftOnBoard = (spot.Eli.WTroopsLeftOnBoard - TroopsM.SingleSoldierW);
if (spot.Eli.WTroopsLeftOnBoard < TroopsM.SingleSoldierW)
spot.Eli.isTroopsFull = true; // modifico la flag di full truppe
if (spot.Eli.isTroopsFull && spot.Eli.IsCargoFull)
spot.Eli.IsFull = true;; // modifico la flag di full cargo e truppe
i++; // VAR INDICE,indica il numero di truppe spostate
}}}// fine metodo
// inserisco attesa elicotteri imbarco truppe se la variaibile is boarding is TRUE
foreach (Spot spot in SpotM.Spotlist) { // per ogni spot
if (spot.Eli != null && spot.Eli.IsBoarding) // gestione tempi attesa
spot.Eli.EliBlock (StaticSimulator.timeToEmbarcTroops, 8); // blocco l'eli e resetto la variabile isBoarding to false
}
} // fine metodo
// istanza singleton è prevista l'esistenza di un'unica finestra
public static TroopsManager Instance(int Element, InfoWindow winI)
{
if (instance == null) instance= new TroopsManager( Element , winI );
return instance; // ritorno il costruttore
}
// FINE METODI INSERIMENTO RIMOZIONE
// ----------------------------------------------------------------------------------------------
// list disposer methods
// distribuzione del cargo sull'elicottero che lo puo' ospitare
// il metodo serve per distribuire il cargo a bordo degli elicotteri
// che possono effettuare il trasporto
// blocca temporalmente l'elicottero che effettua il trasferimento di cargo
public void CargoDistribution(InfoWindow winI, EliManager EliM, TroopsManager TroopM)
{
// variaibli d'impiego locale
int i = 0; // index
int maxCargoNum = this.CargoList.Count; // quanti pacchi di cargo devo distribuire
Cargo cargo = null;
Elicottero eli = null;
if (this.CargoList != null && this.CargoList.Count != 0) // controlla che la lista cargo contenga elementi
// è stato usato un indice per l'impossibilità di operare sulla lista dinamicamente con un foreach
// cancellando i dati e leggendoli insieme.
{
while ((i < this.CargoList.Count)) // continua fino a quando l'indice raggiunge il valore massimo di elementi
{
cargo = this.CargoList [i]; // cargo da assegnare
if (!cargo.IsEliC && // il cargo vede essere caricabile su uno degli elicotteri
cargo.IsFittable) // controlla se il cargo non è ancora stato assegnato
{
eli = EliM.EliAbleToCargo(cargo, TroopM); // definisce l'elicottero in grado di ospitare il cargo
//l'elicottero per ospitare il cargo non deve essere necessariamente sul ponte di volo
// controlla che l'elicottero assegnato esista e se esistono le condizioni per poter accettare il cargo
if (eli != null && !eli.IsCargoFull && // elicottero non vede essere cargo full
!eli.IsFlying && // non deve essere in volo
!eli.IsBlocked && // no deve essere time blocked
eli.IsEfficient && // deve essere efficiente
eli.isRequiredForOP) // deve essere richiesto per l'operazione
{
eli.IsBoardingCargo = true; // eli inizia ad imbarcare il cargo
eli.WCargoLeftOnBoard = (eli.WCargoLeftOnBoard - cargo.ChecktotalCargoWeight()); // sottraggo il peso del cargo al carico utile dell'eli
// tale peso comprende le truppe che fanno parte del cargo
this.MoveElement(this.CargoList, eli.EliCargoList, cargo); // effettua lo spostamento necessario setto la flag del cargo a bordo
this.CheckThisEliCargoFull(eli); // controlla se esistono altri cargo che possono essere
//inseriti altrimenti CARGO FULL set flag
cargo.IsEliC = true; // la flag del cargo viene settata in elicottero
cargo.Eli = eli; // assegno al cargo l'elicottero su cui viaggia
eli.EliBlock(CargoManager.CargoLoadTiming, 5); // blocco l'elicottero N ticks per operazioni di cargo
// al termine dell'attesa IsCargoOnBoard variable e' TRUE
winI.InsertSomeText("CARGO DISPOSER: è stato assegnato: " + cargo.CargoString +
" , restano ancora " + this.CargoList.Count + " elementi CARGO da imbarcare");
i++; // passo al rec ord successivo
}
else
{
i++; // incremento il contatore del cargo, cambio cargo
}
}
} // fine while
}
else
{
winI.InsertSomeText("TROOPS DISPOSER: nessuna lista di CARGO è stata definita");
}
} // NotFiniteNumberException metodo distribuzione cargo
} // fine metodo
//----------------------------------------------------------------------------------
// metodo di supporto alla classe serve per attuare l'inizializzazione delle macchine,
// controllo se gli elicotteri proposti sono tutti necessari per l'operazione
// se ad esempio ho 3 elicotteriche possono trasportarte 10 truppe per un totate di
// 30 persone mentre ho solo 15 persone disponibili gli elciotteri necessari saranno
// solo 2. il terzo quindi risulterà non impiegabile
// tuttavia va controllato anche che l'elicottero risulti non necessario anche per
// il trasporto del cargo
public void Check_Eli_Usability(InfoWindow WinI, TroopsManager TroopM, CargoManager CargoM)
{
WinI.InsertSomeText("SIMULATOR : controllo effettiva NECESSITA' degli elicotteri inseriti per la missione");
int TroopTotW = TroopM.TroopList.Count * TroopM.SingleSoldierW; // peso totale delle truppe
int EliTotW = this.ElicotteriList.Sum(x => x.WTroopsLeftOnBoard); // peso totale disponibile sugli elicotteri
int diffT_E = EliTotW - TroopTotW; // calcolo la differenza tra il peso totale trsportabile e il peso totale da trasportare
List <Cargo> SupportCargoList = new List <Cargo> (); // lista cargo di supporto
Elicottero eliMinW = this.ElicotteriList.Find(y => y.WTroopsLeftOnBoard == (this.ElicotteriList.Min(x => x.WTroopsLeftOnBoard)));
// elicottero con peso minimo disponibile nella lista elicotteri
// l'algoritmo elimina tutti gli elicotteri che offrono meno peso per il trasporto
// dopo che viene definita la quantità di peso totale necessaria
while (diffT_E > 0 && diffT_E > eliMinW.WTroopsLeftOnBoard)
{
bool found = false; // bool di supporto al metodo
int supportCounter = 0; // bool var di supporto
if (SupportCargoList.Count > 0)
{
SupportCargoList.Clear(); // reset list
}
if (diffT_E > eliMinW.WTroopsLeftOnBoard) //se la differenza tra il peso totale delle truppe
// trasportabile ed il peso totale disponibile sugli elicotteri
// è maggiore del peso disponibile sull'elicottero con peso trasportabile minimo allora ho trovato un
// elicottero candidato
{
this.SupportEliList.Add(eliMinW); // aggiungo l'elciottero alla lista
//di supporto come candidato all'eliminazione
// devo ora controllare che l'elicottero sia anche indispensabile per l'attività di trasporto cargo
if (CargoM != null && CargoM.CargoList != null)
{
// estrapolo elenco cargo che puo' ospitare l'elicottero candidato
foreach (Cargo cargo in CargoM.CargoList.FindAll(x => (x.ChecktotalCargoWeight() <= eliMinW.WCargoLeftOnBoard)))
{
SupportCargoList.Add(cargo); // inserisco i valori trovati all'interno della lista di supporto
}
// DEVO CONTROLLARE
// 1 CHE NON POSSA TRASPORTARE NESSUN CARGO
// 2 CHE QUALORA POSSA TRASPORTARE DEL CARGO QUESTO NON SIA TRASPORTABILE DA ALTRI ELICOTTERI
// SE UNA O L'ALTRA CONDIZIONE SONO VERE L'ELICOTTERO PUO' ESSERE ELIMINATO DALL'ELENCO
if (SupportCargoList.Count > 0) // controllo che non possa trasportare nessun cargo
// conrtollo tutti i cargo presenti nell'elenco in quanto devono essere tutti
// trasportabili da altri elicotteri
{
foreach (Cargo cargo in SupportCargoList)
{
found = false; // resetto la variabile bool di supporto
// per ogni altro elicotteo NON MINIMO PESO effettuo il confronto con il cargo
foreach (Elicottero eli in this.ElicotteriList.FindAll(x => x != eliMinW))
{
if (eli.WCargoLeftOnBoard >= cargo.ChecktotalCargoWeight()) // se esiste un elicottero che puo' imbarcare il cargo
//incremento il contatore, anche gli altri cargo nell'elenco devono essere inclusi nella condizione
{
found = true;
}
} // end loop su eli
// se ho trovato almeno un elemento in grado di accettare il cargo la var bool found è settata su vero
// quindi posso incrementare il counter
if (found)
{
supportCounter++; // se lo trova il cargo nella lista cargo di supporto
}
//che poteva trasportare l'eliminW ora lo puo' trasportare qualun altro
} // end loop su cargo
// se il numero degli elicotteri che possono ospitare il cargo eguaglia il numero del cargo da ospitare
//l'elicottero non è necessario
if (supportCounter == SupportCargoList.Count)
{
// posso eliminare l'elicottero dall'elenco elicotteri
this.ElicotteriList.Remove(eliMinW);
WinI.InsertSomeText("SIMULATOR : rimosso elicottero: " + eliMinW.IdEli + " l'eli risulta non necessario");
}
else
{
// altrimenti devo rimuoverlo dall'elenco dei candidati
this.SupportEliList.Remove(eliMinW);
}
} // end if cargo count >0 ELICOTTERO INUTILE PER L'OPERAZIONE ELIMINARE ELICOTTERO DALL'ELENCO
else
{
// elicottero inutile per l'operazione
this.ElicotteriList.Remove(eliMinW);
// l'elicottero viene cosi lasciato nell'elenco
// degli elicotteri di supporto non utilizzabili
WinI.InsertSomeText("SIMULATOR : rimosso elicottero: " + eliMinW.IdEli + " l'eli risulta non necessario");
}
} // fine if CARGO NULL INESISTENTE
else
{
// elicottero inutile per l'operazione
this.ElicotteriList.Remove(eliMinW);
WinI.InsertSomeText("SIMULATOR : rimosso elicottero: " + eliMinW.IdEli + " l'eli risulta non necessario");
}
} // fine if differenza l'elicottero è utile per l'operazione
// update delle variabili
EliTotW = this.ElicotteriList.Sum(x => x.WTroopsLeftOnBoard); // peso totale disponibile sugli elicotteri
diffT_E = EliTotW - TroopTotW; // calcolo la differenza tra il peso totale trsportabile e il peso totale da trasportare
eliMinW = this.ElicotteriList.Find(y => y.WTroopsLeftOnBoard ==
(this.ElicotteriList.Min(x => x.WTroopsLeftOnBoard))); //determino il nuovo min
} // fine while
} // fine metodo Check_Eli_Usability
