Exemplo n.º 1
0
 // istanza singleton è prevista l'esistenza di un'unica finestra
 public static EliManager Instance(int numeroEli, InfoWindow winI)
 {
     if (instance == null)
     {
         instance = new EliManager(numeroEli, winI);
     }
     return(instance);            // ritorno il costruttore
 }
Exemplo n.º 2
0
 // finestra informazioni
 // viene definita la lista per la generazione degli elicotteri
 // da aggiungere dinamicamente all'elenco
 // COSTRUTTORE alla classe viene passato il numero di record iniziali
 protected EliOptions(int totEli, InfoWindow _win) : base(Gtk.WindowType.Toplevel)
 {
     this.Build();                                                    // disegna fisicamente la finestra
     this._totEliC = totEli;                                          // passo la variabile con il numero di elicotteri
     this.win      = _win;                                            // finestra informazioni
     this.EliM     = (EliManager)FactoryManager.Make(0, totEli, win); // il manager crea l'elimanager
     EliM.MakeList(0);                                                // viene definita l'istanza della lista di elementi
     this.InitValue();                                                // azzera valori dopo la creazione
 }
Exemplo n.º 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
            }
        }
Exemplo n.º 4
0
        // controllo che ogni cargo sia trasportabile da almeno 1 elicottero
        // altrimenti il cargo è unfittable
        public void CheckCargoIsFittable(EliManager EliM)
        {
            foreach (Cargo cargo in this.CargoList)             // per ogni cargo
            {
                foreach (Elicottero eli in EliM.ElicotteriList) // per ogni elicottero

                // nota le truppe sono inserite come CARGO e quindi fanno parte della pesata totale del cargo
                // la classe cargo è infatti composta da una lista di truppe assegnate aventi come peso
                // il peso basico del soldato inserio per i soldati
                {
                    if (eli.WCargoLeftOnBoard > cargo.ChecktotalCargoWeight())
                    {
                        cargo.IsFittable = true;                         // switch cargo flag
                        return;
                    }
                }
                cargo.IsFittable = false;
            }
        }
Exemplo n.º 5
0
        }        // NotFiniteNumberException metodo distribuzione cargo

        // il metodo controlla che esista ancora un cargo che possa essere inserto in elicottero
        // il metodo va riproposto dopo ogni inserimento di cargo
        // nonchè dopo ogni scarico
        public void CheckEli_CargoFull(EliManager EliM)
        {
            foreach (Elicottero eli in EliM.ElicotteriList)
            {
                eli.IsCargoFull = true;

                if (eli.isRequiredForOP && eli.IsEfficient)                  // se l'elicottero è efficiente e richiesto per l'op
                {
                    foreach (Cargo cargo in this.CargoList)                  // controlla che esista ancora un cargo utile
                    {
                        if ((cargo.ChecktotalCargoWeight() < eli.WCargoLeftOnBoard) && !cargo.IsEliC)
                        {
                            eli.IsCargoFull = false;
                        }
                    }
                }
            }
            this.CheckState();              // aggiorno lo stato
        }
Exemplo n.º 6
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
        }
Exemplo n.º 7
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
        }
Exemplo n.º 8
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