Пример #1
0
		// 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 
		}
Пример #2
0
        // LIST DISPOSER METODI - metodi di movimentazione degli elementi in relazione agli altri manager
        #region list disposer
        // sposta gli elicotteri sugli spot se questi possono contenerli
        public void MoveEliOnSpot(SpotManager SpotM, Spot.day_night DN, InfoWindow WinI)
        {
            bool elidispoSuccess;             // flag disposizione avvenuta con successo

            // controllo se esistono elicotteri che possono essere ospitati dagli spot per le caratteristiche
            // che hanno elicottero e spot
            foreach (Elicottero eli in this.ElicotteriList)
            {
                if (!eli.IsBlocked &&              // controllo se l'elico non è bloccato ed è in hangar
                    !eli.PosEli &&                     // eli è in hangar
                    !eli.hasSpotReserved                        // eli non ha riservato uno spot
                    )
                {
                    Spot _spot = SpotM.SpotToHostaCat(eli.CatEli, DN);                          //ritorno il primo spot in grado di ospitare l'elicottero

                    if (_spot != null)                                                          // se lo spot è stato trovato
                    {
                        WinI.InsertSomeText("Spot trovato per assegnazione: " + _spot.SpotPos); // scrittura info

                        // viene se l'elicottero è efficiente, la posizione è in hangar
                        //e lo spot esiste e non è riservato ad altri elicotteri
                        // inoltre possono essere movimentati solo due elicotteri alla volta

                        if (elidispoSuccess = SpotM.SpotEliAssign(eli, _spot))                                   // prova ad assegnare l'elicottero
                        {
                            WinI.InsertSomeText("DISPOSER: movimentato elicottero : "
                                                + eli.IdEli + " su spot: " + eli.Spotrequested.SpotPos);
                        }
                    }
                    else
                    {
                        WinI.InsertSomeText("DISPOSER: movimentazione elicottero " + eli.IdEli + " non effettuabile");
                    }
                }         //termine IF
            }             // termin foreach elicottero ciclo
        }
Пример #3
0
        }                                                                    // termine metodo

        //--------------------------------------------------------------------

        // metodo di controllo elicotteri in holding
        // vengono controllati tutti gli elicotteri in holding sia in direzione per sbarco truppe
        // sia in direzione per rientro a bordo
        // al termine del controllo o viene mantenuto l'holding attesa
        // oppure viene assegnata una nuova direzione di movimento
        public void HPCheckAndChange()
        {
            //int eliHolding;
            int eliForces;
            //controlla lo stato della lista degli elicotteri in holdin

            int dirHoldGO   = EliM.HoldingP.EliHolding.FindAll(eli => eli.Go_goback == true).Count;            // conta gli elicotteri all'interno della LZ dir to GO
            int dirHoldBACK = EliM.HoldingP.EliHolding.FindAll(eli => eli.Go_goback == false).Count;           // eli con direzione nave in attesa


            //eliHolding = EliM.HoldingP.EliHolding.Count- dirHoldGO; // numero  elicotteri in holding attualmente
            eliForces = EliM.EliForce();              // tutte le forze elicottero utilizzabili
            // per l'assalto mi serve che ci siano tutti gli elicotteri impiegabili in una sola ondata

            if (dirHoldGO == eliForces)               // se gli elicotteri sono tutti presenti allora inizia l'assalto
            {
                foreach (Elicottero eli in EliM.ElicotteriList)
                {
                    if (eli.IsHolding && eli.Go_goback)                // se l'eliocottero è in holding e ha direzione ANDATA
                    {
                        eli.DirToGo         = Elicottero.Direction.lz; // gli elicotteri assumono tutti la direzione della LZ
                        eli.isApproaching   = false;                   // resetta l'approaching
                        eli.EliSpeed        = this.Speed;              // NECESSARIA?
                        eli.isOnDestination = false;                   // l'elicottero non è piu' a destinazione
                        eli.IsHolding       = false;                   // l'elicottero non è piu' in holding
                        EliM.RemoveEli(EliM.HoldingP, eli);            // rimuovi gli elicotteri dall'HP
                        WinI.InsertSomeText("HOLDING POINT : elicottero : " + eli.IdEli + " lascia l'HP time: " + eli.current_time.ToString());
                        WinI.InsertEvent(eli.current_time, "OUT HP ", eli.IdEli, eli.NumEli);
                    }
                }
            }


            // controllo che ci sia uno spot libero per l'elicottero in holding e con direzione Nave
            // se lo spot esiste lo assegnao all'elicottero
            if (dirHoldBACK > 0)
            {
                foreach (Elicottero eli in EliM.ElicotteriList)
                {
                    if (eli.IsHolding && !eli.Go_goback)
                    {
                        Spot spot = SpotM.SpotToHostaCat(eli.CatEli, DNOps);
                        if (spot != null)                                    // se lo spot non è nullo procedo verso ship
                        {
                            eli.isOnDestination = false;                     // resett flag
                            eli.isApproaching   = false;                     // resetta l'approaching
                            eli.SpotAssigned    = spot;                      // assegnazione spot
                            eli.IsHolding       = false;                     // reset flag
                            eli.DirToGo         = Elicottero.Direction.ship; // assegno nuova direzione
                            eli.EliSpeed        = Speed;
                            spot.IsReservd      = true;                      // lo spot è riservato
                            spot.eliWhoReservd  = eli;                       // l'elicottero che ha richiesto il reserve
                            EliM.RemoveEli(EliM.HoldingP, eli);              // rimuovi gli elicotteri dall'HP
                            WinI.InsertSomeText("HOLDING POINT : elicottero : "
                                                + eli.IdEli + " lascia l'HP time: " + eli.current_time.ToString());
                            WinI.InsertEvent(eli.current_time, "OUT HP", eli.IdEli, eli.NumEli);
                        }
                    }
                }
            }
            this.AssignEli();              // assegna la nuova destinazione vettoriale in base alla LZ
            SpotM.CheckState();            // ricontrollo stato ponte
        }
Пример #4
0
        }         // fine classe

        //------------------------------------------------------------------------

        // metodo per il disimbarco delle truppe sulla LZ
        public void LZTroopsandCargo_Disembark_changeDST()
        {
            foreach (Elicottero eli in EliM.LandingZoneL.LZeliList)
            {
                if (eli.isLZ &&               // Se l'elicottero è sulla LZ
                    !eli.IsBlocked                        // non è bloccato
                    // ha cargo o truppe a bordo
                    && (eli.EliSoldierList.Count > 0 || eli.EliCargoList.Count > 0)
                    )
                {
                    // scarico le truppe e modifico le variaibli
                    if (eli.IstroopsOnBoard &&
                        !eli.IsBlocked)                            // se l'elicottero ha la flag di truppe a bordo le scarico

                    {
                        eli.EliBlock(StaticSimulator.timeToDisembarkTroops, 9);                  // blocco elicottero 2 minuti per scarico truppe
                    }
                    // qui si setta elitroopsisonboard == false FLAG , viene inoltre cancellata la lista truppe da bordo eli


                    // scarico il cargo e modifico le variaibili ( la cargo list essite ed è 0 se non cè cargo)
                    if (!eli.IstroopsOnBoard &&
                        eli.IsCargoOnBoard &&
                        !eli.IsBlocked)                            // se l'elicottero ha scaricato le truppe
                    // ma ancora non ha scaricato il cargo , allora deve scaricare anche il cargo

                    // il blocco degli eli per scaricare il cargo avviene in modo incrementale per il numero di cargo presente a bordo
                    // ogni cargo ha in media una necessita' di scarico di 3 minuti
                    {
                        eli.EliBlock(CargoManager.CargoTimeTodisembark * eli.EliCargoList.Count, 6);
                    }

                    if (CargoM != null)
                    {
                        CargoM.CheckThisEliCargoFull(eli);                                          // controllo l'eli
                    }
                }

                if (CargoM != null)
                {
                    CargoM.CheckEli_CargoFull(EliM);                                         // il metodo controlla che esista ancora un cargo
                }
                //che possa essere inserto in elicottero

                // se l'elicottero non è bloccato
                // non ha cargo a bordo
                // non ha truppe a bordo
                // procedi all'assegnazione del rientro
                if (eli.isLZ &&
                    !eli.IsBlocked &&
                    !eli.IsCargoOnBoard &&
                    !eli.IstroopsOnBoard)
                {
                    //---------------------CARGO E PERSONALE SCARICATO
                    //-------------------- ASSEGNAZIONE SPOT PER IL RIENTRO
                    eli.Go_goback = false;                          // setta l'eli per il rientro
                    eli.IsFull    = false;                          // resetto la variabile di carico completo

                    // controllo l'esistenza di uno spot in grado di ospitare l'elicottero al rientro dalla LZ
                    Spot spot = SpotM.SpotToHostaCat(eli.CatEli, DNOps);

                    if (spot != null)
                    {                                                            // se lo spot non è nullo procedo verso ship
                        eli.DirToGo = Elicottero.Direction.ship;                 // assegno direzione Ship
                        SpotM.Spotlist.Find(x => x == spot).IsReservd = true;    // spot riservato per l'elicottero
                        eli.SpotAssigned = spot;                                 // spot assegnato all'elicottero
                        SpotM.Spotlist.Find(x => x == spot).eliWhoReservd = eli; // l'elicottero che ha richiesto il reserve
                        SpotM.CheckState();                                      // assegnazione dello spot cambio di stato del manager
                    }
                    else
                    {
                        eli.DirToGo = Elicottero.Direction.hp;                                 // se il ponte è occupato vado
                    }
                    // resto in atesa nell'holding point


                    //--------------------------------------------
                    // reset variabili di stato eli per il rientro
                    eli.isApproaching   = false;
                    eli.EliSpeed        = this.Speed;             // resetto la velocità dell'eli
                    eli.isOnDestination = false;                  // resetto la destinazione
                    eli.isLZ            = false;                  // resetto la flag LZ
                    this.AssignEli();                             // assegno il vettore della nuova destinazione

                    WinI.InsertSomeText("LANDING ZONE : elicottero : " + eli.IdEli + " lascia LZ time: " + eli.current_time.ToString());
                    WinI.InsertEvent(eli.current_time, "T/O LZ", eli.IdEli, eli.NumEli);
                }
            }             // termine scansione elioctteri sulla LZ
            // cancellare l'eli dalla LZ
            if (EliM.LandingZoneL.LZeliList.Count > 0)
            {
                EliM.LandingZoneL.LZeliList.RemoveAll(x => x.isLZ == false); // rimuovi gli elicotteri dalla LZ che sono stati rilasciati
            }
        }                                                                    // termine metodo
Пример #5
0
        // setta la flag in blocco per il tempo necessario all'operazione
        public void EliBlock(int ticks, int k)
        {
            bool passFlag = false;


            if (!this.IsBlocked && k != -1)             // se l'elicottero non è bloccato resetto il timer

            {
                time             = new TimeSpan(0, 0, ticks);   // BLOCCO PER UN NUMERO DI TICKS
                time             = this.timer.GetTime() + time; // tempo massimo di blocco
                this.blockReason = k;                           // salvo la motivazione di blocco NON POSSO RESETTARE LE MOTIVAZIONI DI
                // BLOCCO SE L'ELICOTTERO NON E' SBLOCCATO
                this.IsBlocked = true;
            }

            if (time <= timer.GetTime() && this.IsBlocked)
            {
                passFlag = true;                 // se supero il tempo necessario la variabile passa diventa true
            }

            if (passFlag)             // la passflag sblocchera l'accesso alle casistiche
            {
                // definizione dei blocchi temporali con il segnale che le ha generate


                if (this.blockReason == 1)
                {
                    this.IsRunning = true;                                         // messa in moto
                }
                if (this.blockReason == 2)
                {
                    this.IsBladeSpread = true;              // pale aperte
                }
                if (this.blockReason == 3)                  // blocco per riposizionamento
                {
                    this.PosEli       = true;               // posizione sullo spot
                    this.SpotAssigned = this.Spotrequested;
                    this.SpotAssigned.SpotOccupied = true;  // spot occupato
                    this.SpotAssigned.Eli          = this;  // assegna lo spot all'elicottero
                    this.SpotAssigned.IsReservd    = false; // lo spot è occupato non è piu' riservato
                    this.hasSpotReserved           = false;
                    this.Spotrequested             = null;
                }

                // SEGNALE 4 ATTESA PER APERTURA PALE
                if (this.blockReason == 4)
                {
                    this.IsBladeSpread = true;
                }

                // SEGNALE 5 ATTESA PER INSERIMENTO CARGO
                if (this.blockReason == 5)
                {
                    this.IsBoardingCargo = false;                   // termine del boarding cargo
                    this.IsCargoOnBoard  = true;                    // cargo a bordo flag
                }
                // SEGNALE 6 ATTESA PER SCARICO DEL CARGO
                if (this.blockReason == 6)
                {
                    this.IsCargoOnBoard = false;                     // cargo unloading time
                    foreach (Cargo cargo in this.EliCargoList)
                    {
                        cargo.IsEliC = false;                       // il cargo e' a terra
                        cargo.Eli    = null;
                        cargo.isLand = true;                        // setto la flag per cargo a terra
                        // vettore cargo a terra
                        cargo.CargoVector      = this.elivector2d + (new Vector2(StaticSimulator.CargoVectorPosX, StaticSimulator.CargoVectorPosY));
                        this.WCargoLeftOnBoard = this.WCargoLeftOnBoard + cargo.ChecktotalCargoWeight(); // aumento il peso totale destinato al cargo
                        this.LZ.LZCargo.Add(cargo);                                                      // aggiungo elementi alla lista cargo presente sulla LZ
                    }
                    this.EliCargoList.Clear();                                                           //
                    this.IsCargoFull    = false;
                    this.IsCargoOnBoard = false;
                }

                // SEGNALE 7 ATTESA PER HOT REF
                // due volte la distanza di andata e ritorno dalla LZ + 20 minuti di carburante
                if (this.blockReason == 7)
                {
                    this.Fuel     = this.Fuelrequired(MainWindow.Elioptions.EliM.ElicotteriList.Count);
                    this.isHotRef = false;                     // resetto la variabile hot ref e ripristino il
                    // normale afflusso dicarburante
                }

                // SEGNALE 8 ATTESA PER IMBARCO TRUPPE
                if (this.blockReason == 8)
                {
                    this.IsBoarding = false;                                        // CARICO TRUPPE - alla fine resetto la variabile il boarding a falso
                }
                // SEGNALE 9 ATTESA PER SCARICO TRUPPE
                if (this.blockReason == 9)
                {
                    foreach (Soldier troop in this.EliSoldierList)
                    {
                        troop.IsEli  = false;                       // le truppe sono a terra
                        troop.IsLand = true;                        // setto le flags per eli a terra
                        // vettore truppa a terra
                        troop.vectoreTroop = this.elivector2d + (new Vector2
                                                                     (StaticSimulator.TroopsVectorPosX + StaticSimulator.RandomIntGenerator(10),
                                                                     StaticSimulator.TroopsVectorPosY + StaticSimulator.RandomIntGenerator(10)));

                        this.LZ.LZSoldierList.Add(troop);                                 // aggiungo elementi alla lista della LZ
                        this.WTroopsLeftOnBoard = this.WTroopsLeftOnBoard + troop.Weight; // aumento il peso totale destinato alle truppe
                    }

                    this.EliSoldierList.Clear();                    // libera la lista sull' elicottero
                    this.IstroopsOnBoard = false;                   // SCARICO TRUPPE
                    this.isTroopsFull    = false;                   // l'elicottero essendo scarico resetta anche la variabile FULL
                }


                // FINE BLOCCO PER TUTTI I SEGNALI
                this.IsBlocked = false; // sblocco la variabile blocco
            }
        }                               // termine time
Пример #6
0
        public TimeSpan current_time;         // rappresenta l'update del timer corrente


        // costruttore della classe elicottero
        public Elicottero(ClockTimer timerCon, 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)
        {
            // passo le variabili inizializzate all'oggetto elicottero

            this.NumEli             = numEli;
            this.IdEli              = Id;
            this.CatEli             = Cat;
            this.Fuel               = Fuel;
            this.WTroopsLeftOnBoard = Troops;
            this.WCargoLeftOnBoard  = Cargo;
            this.MaxTOLoad          = MaxToLoad;
            this.OffLoadWeight      = OffLoadWG;
            this.IsRunning          = Running;
            this.IsRefueling        = false;    // l'elicottero non parte mai in fase di refueling
            this.IsBladeSpread      = BladeSprd;
            this.IsEfficient        = IsEff;
            this.IsFlying           = IsFly;
            this.PosEli             = InitialPos;            // posizione iniziale Hangar o Ponte
            this.FuelC              = FuelC;                 // consumo di carburante all'ora
            this.SpotAssigned       = null;                  // assegnazione spot inizializzata a null
            this.LowFuel            = false;                 // setto il lowfuel state a falso, alla messa in moto viene ricontrollato.
            this.EliCrash           = false;                 // setta la flagh di crash a falso
            this.IsBlocked          = false;                 // l'elicottero non parte bloccato
            this.isREADYstatus      = false;                 // l'elicottero inizializzato non pronto
            this.IsHolding          = false;                 // l'elicottero è inizializzato non in holding
            this.isLZ               = false;                 // elicottero sulla LZ
            this.hasSpotReserved    = false;
            this.rotation           = 0;                     // rotazione iniziale
            this.quota              = 0.6f;                  // quota iniziale
            this.isRequiredForOP    = true;                  // elicottero richiesto per l'operazione di default
            this.IstroopsOnBoard    = false;                 // truppe a bordo
            this.IsCargoOnBoard     = false;                 // l'elicottero parte senza cargo
            this.Go_goback          = true;                  // setto l'andata
            this.IsFull             = false;                 // elicottero parte vuoto
            this.IsCargoFull        = false;                 // cargo full
            this.isTroopsFull       = false;                 // truppe full
            this.isApproaching      = false;                 // approach to destinaiton
            this.isHotRef           = false;                 // flas hot ref su falso
            this.IsBoardingCargo    = false;                 // sett iniziale imbarco cargo falso
            this.EliSoldierList     = new List <Soldier>(0); // ogni elicottero detiene la sua lista di soldati
            this.EliCargoList       = new List <Cargo>(0);   // ogni elicottero detiene la lista del proprio cargo
            this.DirToGo            = Direction.ship;        // inizalizzato per direzione holding point
            this.IsBoarding         = false;                 // l'elcittero è iizializzato a caricamento truppe falso


            // il peso totale è dato dal peso dell'elicottero scarico + il peso del carburante + il peso delle truppe + il peso del cargo
            this.TotalWeightCalculated = this.ToTWGCalculus();

            //timer attachment: ogni elicottero e' dotato di un timer
            // serve per sincronizzare le operazioni
            this.timer = timerCon;             // definizione del timer
            this.timer.Attach(this);           // attachment del timer secondo il pattern Observer
            // l'elicottero entra a far parte della lista di observers
            // il notify() del timer provvederà all'update dei clock di tutti gli observer


            this.elivector2d = new Vector2(0f, 0f);         // creazione del vettore di movimento verrà usato dal framework grafico monogame
            // indica la posizione attuale del velivolo sullo schermo
            this.destination = new Point(0, 0);             // destinazione dell'elicottero espressa con una struttura point X e Y


            this.EliSpeed = 0f;             // viene settato il parametro velocita' iniziale dell'eli
        }