Esempio n. 1
0
        }                                               // 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
        }
Esempio n. 2
0
		} // 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
Esempio n. 3
0
 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
 }
Esempio n. 4
0
        // 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
            }
        }
Esempio n. 5
0
        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
        }
Esempio n. 6
0
        // 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
        }
Esempio n. 7
0
		// 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
Esempio n. 8
0
		// 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	
		}
Esempio n. 9
0
        // 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
Esempio n. 10
0
        }         // 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