Пример #1
0
 // istanza singleton è prevista l'esistenza di un'unica finestra
 public static CargoManager Instance(int numCargo, InfoWindow winI)
 {
     if (instance == null)
     {
         instance = new CargoManager(numCargo, winI);
     }
     return(instance);            // ritorno il costruttore
 }
Пример #2
0
        static private MainWindow MainWin = MainWindow.Instance(); // identifica la finestra principale in modo che possa essere ritrovata alla chiusura di questa


        protected CargoOptions(int _cargo, InfoWindow _win) :  base(Gtk.WindowType.Toplevel)
        {
            this.WinI     = _win;       // gli passo la finestra informazioni
            this.cargoTot = _cargo;
            WinI.InsertSomeText("OPZIONI CARGO: --> EFFETTUATA APERTURA FINESTRA OPZIONI CARGO <--");
            CargoM = (CargoManager)FactoryManager.Make(3, this.cargoTot, this.WinI); // viene creato lo Spot Manager tramite factory method
            CargoM.MakeList(cargoTot);                                               // crea la  lista iniziale di un numero di spot impostato
            this.Build();
            this.label1.Text = "Numero di Record cargo #  " + (this.cargoRec + 1) + " Record inseriti: " + CargoM.CargoList.Count + " Record disponibili: " + this.cargoTot;
            this.InitValue();
        }
Пример #3
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
            }
        }
Пример #4
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
        }
Пример #5
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
        }
Пример #6
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