//-----------------------------------------------------------------------
// setto la correzione dell'angolo del vettore eli
// con imput la direzione voluta
public static float AngleCorrection(Elicottero eli, float directionAngle)
{
// rinormalizza gli angoli all'interno del range 0/2pi
if (eli.rotation >= MathHelper.TwoPi)
{
eli.rotation = eli.rotation - MathHelper.TwoPi;
}
if (directionAngle >= MathHelper.TwoPi)
{
directionAngle = directionAngle - MathHelper.TwoPi;
}
if (eli.rotation < 0)
{
eli.rotation = eli.rotation + MathHelper.TwoPi; // trasla di +2pi
}
if (directionAngle < 0)
{
directionAngle = directionAngle + MathHelper.TwoPi; //trasla di +2pi
}
float delta = eli.rotation - directionAngle; // delta angle
// normalizza il delta per valori 0 / 2pi
if (delta < 0)
{
delta = delta + MathHelper.TwoPi;
}
if (delta > MathHelper.TwoPi)
{
delta = delta - MathHelper.TwoPi;
}
float dirPlusPi = eli.rotation + MathHelper.Pi;
if (dirPlusPi < 0)
{
dirPlusPi = dirPlusPi + MathHelper.TwoPi;
}
if (dirPlusPi > MathHelper.TwoPi)
{
dirPlusPi = dirPlusPi - MathHelper.TwoPi;
}
if (delta <= MathHelper.Pi && delta > angleMov)
{
eli.rotation = eli.rotation - angleMov;
return(eli.rotation);
}
if (delta > MathHelper.Pi && delta > angleMov)
{
eli.rotation = eli.rotation + angleMov;
return(eli.rotation);
}
return(eli.rotation);
}
// effettua il calcolo per muovere l'elicottero
// calcolo il vettore , lo normalizzo e gli assegno una velocità
public static void MoveEli(float speed, Elicottero eli, float x, float y, float elapsed)
{
eli.AngleToFly = AngleFlyTo(x, y, eli);
Vector2 direction = new Vector2((float)Math.Cos(AngleCorrection(eli, eli.AngleToFly)),
(float)Math.Sin(AngleCorrection(eli, eli.AngleToFly))); // calcolo del vettore di movimento
direction.Normalize(); // normalizzazione del vettore , 1 unità
eli.elivector2d += direction * SpeedinPixMin(eli.EliSpeed, eli.DistancetoRun) * elapsed;
}
// determina l'inserimento di un nuovo elicottero nella lista
public void InsertElementEli(ClockTimer time, int numEli, string id, int cat, float fuel, int troops, int cargo,
int maxToLoad, int offLoadWg, bool running, bool bladeSprd, bool isEff, bool initialPos, bool isFly, float fuelC)
{
// creazione del nuovo elicottero con valori inizializzati
Elicottero eli = new Elicottero(time, numEli, id, cat, fuel, troops, cargo,
maxToLoad, offLoadWg, running, bladeSprd, isEff, initialPos, isFly, fuelC); // creazione del nuovo elicottero con valori inizializzati
// inserisco l'elemento creato nella lista
ElicotteriList.Insert((numEli), eli);
}
} // 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
// eliste almeno un cargo in grado di trasportare le truppe sull'elicottero
// restituisce vero se esiste almeno un cargo che è possibile caricare sull'elicottero
public bool CheckCargoLoadOnEli(Elicottero eli, int singleSoldW)
{
foreach (Cargo cargo in this.CargoList)
{
if ((cargo.CargoW <= eli.WCargoLeftOnBoard) && (cargo.CargoP * singleSoldW <= eli.WTroopsLeftOnBoard))
{
return(true);
}
}
return(false);
}
// controllo il singolo Eli per verificare se è possibile impiegarlo per altri carghi
public void CheckThisEliCargoFull(Elicottero eli)
{
eli.IsCargoFull = true;
foreach (Cargo cargo in this.CargoList)
{
if ((cargo.ChecktotalCargoWeight() < eli.WCargoLeftOnBoard) && !cargo.IsEliC)
{
eli.IsCargoFull = false;
}
}
}
} // quando non nullo indica l'elicottero presente sullo spot
// costruttore della classe con l'inserimento dei dati
public Spot(int spotPos, bool spotRunnable, bool cat1D, bool cat2D, bool cat3D, bool cat1N, bool cat2N, bool cat3N)
{
this.SpotPos = spotPos; // viene assegnato un numero di pos allo spot
this.SpotRunnable = spotRunnable; // lo spot è creato funzionante
this.SpotOccupied = false; // lo spot non viene creato occupato
this.IsReservd = false; // lo spot non nasce riservato ad alcun elicottero
this.DayCanAccept.Cat1 = cat1D; // classe
this.DayCanAccept.Cat2 = cat2D;
this.DayCanAccept.Cat3 = cat3D;
this.NightCanAccept.Cat1 = cat1N;
this.NightCanAccept.Cat2 = cat2N;
this.NightCanAccept.Cat3 = cat3N;
// elicotteri
this.Eli = null; // nessun elicottero sul ponte
this.eliWhoReservd = null; // nessun elicottero riservante lo spot
}
// assegno un elicottero allo spot ed effettua il blocco
public bool SpotEliAssign (Elicottero eli, Spot spot)
{
if (spot != null
&& eli != null
&& !spot.IsReservd
&& !eli.IsBlocked) { // spot ed eli devono essere diversi da null
spot.IsReservd = true;// spot riservato
spot.eliWhoReservd = eli; // elicottero riservante
eli.Spotrequested = spot;// assegna lo spot all'elicottero
eli.hasSpotReserved = true; // l'elicottero riserva un posto
eli.EliBlock(SpotManager.timeNeedToMoveToDeck, 3); // elicottero bloccato per attività di movimentazione per 15 primi
// al termine del blocco eli.PosEli = true indica che l'elicottero ha assunto la posizione sul ponte
return true;// assegnazione avvenuta con successo
}
else return false;// assegnazione non avvenuta
}
// calcola l'angolo per la nuova posizione
public static float AngleFlyTo(float xpos, float ypos, Elicottero eli)
{
float Xdelta, Ydelta, val;
Xdelta = xpos - eli.elivector2d.X;
Ydelta = ypos - eli.elivector2d.Y;
// calcolo l'angolo tra l'elicottero ed il punto di arrivo
val = ((float)(Math.Atan((Ydelta) / (Xdelta))));
// if (Xdelta > 0 && Ydelta > 0)
// val = val;
if (Xdelta < 0 && Ydelta <= 0)
{
val = val + MathHelper.Pi;
}
if (Xdelta < 0 && Ydelta > 0)
{
val = val + MathHelper.Pi;
}
//----------------------------
//val = val + MathHelper.Pi;
if (val < 0)
{
val = val + MathHelper.TwoPi;
}
if (val > MathHelper.TwoPi)
{
val = val - MathHelper.TwoPi;
}
return(val);
}
// 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
}
//rimuovi l'elicottero dalla lista degli hoding
public void RemoveEli(HoldingPoint hp, Elicottero eli)
{
hp.EliHolding.Remove(eli);
}
//---------------------------------------------------------------
// METODI DI SUPPORTO ALLA GESTIONE DELLA CLASSE
// controlla che tutti gli elicotteri disponibili siano in volo
// cambia la destinazione dell'elicottero
public void ChangeEli(Elicottero eli, float x, float y)
{
eli.destination = new Point((int)x, (int)y);
// eli.destination.X = (int)x;
//eli.destination.Y = (int)y;
}
} // 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
// aggiungi l'elicottero alla lista di holding
public void AddEliHp(HoldingPoint hp, Elicottero eli)
{
hp.EliHolding.Add(eli);
}
// 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
// aggiungi l'elicottero alla lista
public void AddEliList(List <Elicottero> obj, Elicottero eli)
{
obj.Add(eli);
}
// DRAW ELI INFORMATIONS -- PREMERE IL TASTO CORRISPONDENTE AL RECORD DELL'ELICOTTERO PER VISUALIZZA LE INFORMAZIONI
void DrawEliInfo(Elicottero eli)
{
if (eli.LowFuel)
{
spriteBatch.DrawString(font2, "LOW FUEL", new Vector2(eli.elivector2d.X - 30, eli.elivector2d.Y), Color.Blue);
}
if (eli.isHotRef)
{
spriteBatch.DrawString(font2, "REFUELING", new Vector2(eli.elivector2d.X + 30, eli.elivector2d.Y), Color.Blue);
}
if (eli.IsBoarding)
{
spriteBatch.DrawString(font2, "BOARDING TRUPPE", new Vector2(eli.elivector2d.X - 15, eli.elivector2d.Y + 30), Color.Blue);
}
if (eli.IsBoardingCargo)
{
spriteBatch.DrawString(font2, "BOARDING CARGO", new Vector2(eli.elivector2d.X - 15, eli.elivector2d.Y + 30), Color.Blue);
}
if (eli.hasSpotReserved && !eli.PosEli)
{
spriteBatch.DrawString(font2, eli.IdEli + " IN MOVIMENTAZIONE", new Vector2(eli.elivector2d.X - 30, eli.elivector2d.Y - 15), Color.Blue);
}
if (!eli.IsRunning && eli.PosEli)
{
spriteBatch.DrawString(font2, eli.IdEli + " PRE_START CHECKS", new Vector2(eli.elivector2d.X - 30, eli.elivector2d.Y + 15), Color.Blue);
}
if (eli.IsRunning && !eli.IsBladeSpread)
{
spriteBatch.DrawString(font2, eli.IdEli + " BLADE SPREADING", new Vector2(eli.elivector2d.X - 30, eli.elivector2d.Y + 15), Color.Blue);
}
int keypress = 10;
Keys[] keyArray = (Keyboard.GetState().GetPressedKeys()); // pressione dei tasti numpad 1 - 9 per visualizzazione info elicottero
if (keyArray.Length > 0)
{
if (keyArray [0] >= Keys.NumPad1 && keyArray [0] <= Keys.NumPad9)
{
switch (keyArray [0])
{
case Keys.NumPad1:
keypress = 1; break;
case Keys.NumPad2:
keypress = 2; break;
case Keys.NumPad3:
keypress = 3; break;
case Keys.NumPad4:
keypress = 4; break;
case Keys.NumPad5:
keypress = 5; break;
case Keys.NumPad6:
keypress = 6; break;
case Keys.NumPad7:
keypress = 7; break;
case Keys.NumPad8:
keypress = 8; break;
case Keys.NumPad9:
keypress = 9; break;
}
}
}
if (eli.NumEli == keypress - 1)
{
spriteBatch.DrawString(font2, eli.IdEli, new Vector2(eli.elivector2d.X - 10, eli.elivector2d.Y), Color.Blue); // nome eli
spriteBatch.DrawString(font2, "RUNNING: " + eli.IsRunning.ToString(), new Vector2
(eli.elivector2d.X + 20, eli.elivector2d.Y - StaticSimulator.spacing), Color.Red);
spriteBatch.DrawString(font2, "BLADE SPREAD: " + eli.IsBladeSpread.ToString(), new Vector2
(eli.elivector2d.X + 20, eli.elivector2d.Y - StaticSimulator.spacing * 2), Color.Red);
spriteBatch.DrawString(font2, "READY: " + eli.isREADYstatus.ToString(), new Vector2
(eli.elivector2d.X + 20, eli.elivector2d.Y - StaticSimulator.spacing * 3), Color.Red);
spriteBatch.DrawString(font2, "REQUIRED: " + eli.isRequiredForOP, new Vector2
(eli.elivector2d.X + 20, eli.elivector2d.Y - StaticSimulator.spacing * 4), Color.Red);
spriteBatch.DrawString(font2, "FUEL: " + eli.Fuel, new Vector2
(eli.elivector2d.X + 20, eli.elivector2d.Y - StaticSimulator.spacing * 5), Color.Red);
spriteBatch.DrawString(font2, "FLY: " + eli.IsFlying, new Vector2
(eli.elivector2d.X - 110, eli.elivector2d.Y - StaticSimulator.spacing), Color.Red);
spriteBatch.DrawString(font2, "BLOCKED: " + eli.IsBlocked, new Vector2
(eli.elivector2d.X - 110, eli.elivector2d.Y - StaticSimulator.spacing * 2), Color.Red);
spriteBatch.DrawString(font2, "IS HOLDING: " + eli.IsHolding, new Vector2
(eli.elivector2d.X - 110, eli.elivector2d.Y - StaticSimulator.spacing * 3), Color.Red);
spriteBatch.DrawString(font2, "TRUPPE : " + eli.EliSoldierList.Count, new Vector2
(eli.elivector2d.X - 110, eli.elivector2d.Y - StaticSimulator.spacing * 4), Color.Red);
if (SimMovL.CargoM != null)
{
spriteBatch.DrawString(font2, "CARGO : " + eli.EliCargoList.Count, new Vector2
(eli.elivector2d.X - 110, eli.elivector2d.Y - StaticSimulator.spacing * 5), Color.Red);
}
spriteBatch.DrawString(font2, "DIREZIONE: " + eli.DirToGo.ToString(), new Vector2
(eli.elivector2d.X - 110, eli.elivector2d.Y + StaticSimulator.spacing), Color.Red);
spriteBatch.DrawString(font2, "LOW FUEL: " + eli.LowFuel, new Vector2
(eli.elivector2d.X - 110, eli.elivector2d.Y + StaticSimulator.spacing * 2), Color.Red);
spriteBatch.DrawString(font2, "ELI FULL: " + eli.IsFull, new Vector2
(eli.elivector2d.X - 110, eli.elivector2d.Y + StaticSimulator.spacing * 3), Color.Red);
spriteBatch.DrawString(font2, "ANGLE toFLY: " + eli.AngleToFly, new Vector2
(eli.elivector2d.X - 110, eli.elivector2d.Y + StaticSimulator.spacing * 4), Color.Red);
spriteBatch.DrawString(font2, "IS SPEED: " + eli.EliSpeed, new Vector2
(eli.elivector2d.X - 110, eli.elivector2d.Y + StaticSimulator.spacing * 5), Color.Red);
spriteBatch.DrawString(font2, "FREE W CARGO: " + eli.WCargoLeftOnBoard, new Vector2
(eli.elivector2d.X + 20, eli.elivector2d.Y + StaticSimulator.spacing), Color.Red);
spriteBatch.DrawString(font2, "FREE W TROOPS: " + eli.WTroopsLeftOnBoard, new Vector2
(eli.elivector2d.X + 20, eli.elivector2d.Y + StaticSimulator.spacing * 2), Color.Red);
spriteBatch.DrawString(font2, "ANGOLO ATTUALE: " + eli.rotation, new Vector2
(eli.elivector2d.X + 20, eli.elivector2d.Y + StaticSimulator.spacing * 3), Color.Red);
spriteBatch.DrawString(font2, "DISTANZA AL PUNTO: " + eli.DIstanceToPnT, new Vector2
(eli.elivector2d.X + 20, eli.elivector2d.Y + StaticSimulator.spacing * 4), Color.Red);
}
} // termine metodo draw info
