Ejemplo n.º 1
0
        // METODO DI INIZIALIZZAZIONE: viene utilizzato per inizializzare i valori e gli oggetti grafici
        protected override void Initialize()          // metodo eseguito all'inizio del programma
        // serve per inizializzare le variabili
        {
            //inizializzazione variabili grafiche per deifinizione shcermo
            graphics.PreferredBackBufferWidth  = 1024;                     // impostazione schermo
            graphics.PreferredBackBufferHeight = 768;                      // impostazione schermo
            GraphicsDevice.PresentationParameters.BackBufferWidth  = 1024; //IMPOSTAZIONI GRAFICHE
            GraphicsDevice.PresentationParameters.BackBufferHeight = 768;  // IMPOSTAZIONI GRAFICHE

            spriteBatch  = new SpriteBatch(GraphicsDevice);                // nuovo oggetto spritebatch per la visualizzazione
            backgroudPOS = new Vector2(0f, 0f);                            // posizione iniziale del background img
            // inizliazzazione posiz LZ
            SimMovL.EliM.LandingZoneL.LZvector = new Vector2(SimMovL.EliM.LandingZoneL.LZposition.X, SimMovL.EliM.LandingZoneL.LZposition.Y);

            int disposerContent = (StaticSimulator.shipY1Y2spacing) / SimMovL.EliM.initEliNum;             // calcolo degli interspazi sul ponte

            // per la disposizione grafica degli elicotteri
            // poisiziono elicotteri sul ponte
            foreach (Elicottero eli in SimMovL.EliM.ElicotteriList)
            {
                eli.rotation = StaticSimulator.SetRotationAngle(StaticSimulator.InitialRotationAsset);                  // prende gradi

                eli.elivector2d = new Vector2(eli.elivector2d.X + StaticSimulator.shipborderLandX,
                                              eli.elivector2d.Y + StaticSimulator.shipborderLandYdown - 20 - (eli.NumEli) * disposerContent);
            }

            Window.AllowUserResizing = true;             // l'untente pu' dimesionare la finestra
            graphics.IsFullScreen    = true;             // simulazione windowed
            graphics.ApplyChanges();                     // applico i cambiamenti alla grafica
            base.Initialize();
        }
Ejemplo n.º 2
0
        //---------------------------------------------------------------------

        //---------------------------------------------------------------------
        #region [ MATEMATICA DEI MOVIMENTI GRAFICI]

        public void EliMovingLogic(float elaspedT)
        {
            //----------------------------------------------------------------------------------------------------
            // per ogni elicottero controlla la destinazione e permetti la rotazione per raggiungere la destinazione
            foreach (Elicottero eli in EliM.ElicotteriList)
            {
                eli.DIstanceToPnT = (StaticSimulator.DistancePtoP((float)eli.destination.X, (float)eli.destination.Y, eli.elivector2d.X, eli.elivector2d.Y));               // distanza obiettivo

                // muove gli elicotteri alla destinazione
                if (!eli.IsBlocked && eli.IsFlying && !eli.isOnDestination)
                {
                    if (!eli.isApproaching)
                    {
                        eli.EliSpeed = this.Speed;
                    }
                    StaticSimulator.MoveEli(eli.EliSpeed, eli, (float)eli.destination.X, (float)eli.destination.Y, elaspedT);
                }

                eli.DIstanceToPnT = (StaticSimulator.DistancePtoP((float)eli.destination.X, (float)eli.destination.Y, eli.elivector2d.X, eli.elivector2d.Y));
                // controllo la distanza dal destinazione
                if ((eli.DirToGo == Elicottero.Direction.hp) &&             // la direzione dell'eli è lhp
                    (eli.DIstanceToPnT < 30) &&                    // la distanza è inferiore a 30px
                    !eli.isOnDestination)                     // e l'elicottero non è ancora flaggato a destinazione// se è arrivato a destinazione
                {
                    eli.isApproaching   = true;               // approach to destination smette di prendere la velocità dalla formazione e la riduce per l'atterraggio
                    eli.isOnDestination = true;               // sotto i 20 px l'elicotter è a destinazione nell'HP
                    eli.IsHolding       = true;               // flag holding!!
                    WinI.InsertEvent(eli.current_time, "IN HP", eli.IdEli, eli.NumEli);
                    WinI.InsertSomeText(" ELI " + eli.IdEli + " ENTRA HP: " + eli.current_time.ToString());
                    eli.EliSpeed = 0f;                     // setto la velocità
                    EliM.AddEliHp(EliM.HoldingP, eli);     // aggiungi l'elicottero alla holding lista
                }


                // ELICOTTERI IN HOLDING MANTENGONO UNA ROTTTA CIRCOLARE
                //--------------------------------------------------------------------------------------
                if (eli.IsHolding && eli.isOnDestination)                    // se l'elicottero è in holdign ruota attorno ad un punto fisso
                {
                    eli.rotation = eli.rotation + 0.9F * elaspedT;           // viene impostata la velocità di rotazione
                }


                //------------------------------------------------------------------------------------------------
                // LANDING zone acquisita
                if ((eli.DirToGo == Elicottero.Direction.lz) && (eli.DIstanceToPnT < 25))
                {
                    eli.isApproaching = true;
                    if (eli.EliSpeed > 0)
                    {
                        eli.EliSpeed = eli.EliSpeed - 5f;                         // decremento della velocità
                        eli.quota    = eli.quota - 0.01f;
                    }
                    else                                // se l'elicottero ha raggiungo velcotà 0
                    {
                        if (!eli.isOnDestination)       // se la variabile non è settata a destinazione
                        {
                            eli.isOnDestination = true; // setta la destinazione come raggiunta
                            //	eli.Go_goback = false; // eli assume direzione rientro
                            eli.isLZ = true;            // flag LZ
                            WinI.InsertEvent(eli.current_time, "LAND LZ", eli.IdEli, eli.NumEli);
                            WinI.InsertSomeText(" ELI " + eli.IdEli + " SULLA LZ time: " + eli.current_time.ToString());
                            EliM.AddEliList(EliM.LandingZoneL.LZeliList, eli);                              // aggiungo l'elicottero alla lista

                            // INSERIRE SBARCO TRUPPE E CARGO
                            // QUANDO TERMINATO CAMBIARE DESTINAZIONE TO SHIP
                        }
                    }
                }


                // DIREZIONE NAVE l'elicottero rientra dalla LZ PUO': RIFORNIRE, TERMINARE L'OPERAZIONE, CARICARE CARGO TRUPPE E DECOLALRE
                //----------------------------------------------------------------------------------------------------
                if (!eli.isApproaching && (eli.DirToGo == Elicottero.Direction.ship) &&
                    eli.IsFlying && !eli.Go_goback &&
                    eli.DIstanceToPnT < 25)
                {
                    eli.isApproaching = true;                     // elicottero approaching
                }
                // ship acquisita diminuzione di speed
                if (eli.isApproaching && (eli.DirToGo == Elicottero.Direction.ship) &&
                    eli.IsFlying && !eli.Go_goback &&
                    eli.DIstanceToPnT < 20)
                {
                    if (eli.EliSpeed > 0)
                    {
                        eli.EliSpeed = eli.EliSpeed - 5f;                         // decremento della velocità
                    }
                    else
                    {
                        eli.isOnDestination = true;                                                   // elicottero arrivato a destinazione
                        eli.SpotAssigned    = SpotM.Spotlist.Find(spot => spot.eliWhoReservd == eli); // assegno lo spot
                        // salvo dati
                        WinI.InsertSomeText("ELICOTTERO APPONTA: " + eli.IdEli + " time: " + eli.current_time.ToString());
                        WinI.InsertEvent(eli.current_time, "LAND SHIP", eli.IdEli, eli.NumEli);
                        //--- salvo dati
                        eli.SpotAssigned.SpotOccupied = true;     // lo spot è occupato
                        eli.SpotAssigned.Eli          = eli;      // as segno l'elicottero allo spot
                        eli.PosEli        = true;                 // pos sul ponte
                        eli.Go_goback     = true;
                        eli.IsFlying      = false;                // elicottero a terra non piu' in volo
                        eli.rotation      = 230;                  // riporto l'angolo iniziale
                        eli.isREADYstatus = false;                // deve riacquisire il ready status perridecollare
                        SpotM.CheckState();                       // controllo lo stato del simulatore
                        eli.EliSpeed = 0;                         // resetto la speed a 0
                    }
                }
            }
        }         // temine loop
Ejemplo n.º 3
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