Esempio n. 1
0
        //private static List<Waffen> waffenListe = new List<Waffen>();
        public static Objekte createObj(int auswahl, Spieler spieler, float xPos, Vector2 rHv2s)
        {
            idnummer++;
            Vector3 startort = new Vector3(xPos, 2, -5);
            SceneObject newobj;
            Objekte dasobj;

            if (auswahl == 1)//Würfel
            {
                newobj = buildbox(startort, new Vector3(0.4f, 0.4f, 0.4f));
                DrawHelper.setmoney(spieler, -150, rHv2s);
                /*spieler.setMoney(spieler.getMoney() - 150); //Rohkosten abziehen
                Gamestart.setShowGeld(-150, 100);           //Kosten visualisieren
                */
                newobj.Physics.Mass = 1f;
            }
            else if (auswahl == 2)
            {
                ModelObject l = new ModelObject(startort, Quaternion.CreateFromAxisAngle(new Vector3(1,2,0),(float)Math.PI), new Vector3(1, 1, 1), CollisionType.ExactMesh, "", "L", 1f);
                l.SubModels[0].RenderMaterial.Diffuse = new Vector4(1, 1, 1, 1);
                l.SubModels[0].RenderMaterial.Specular = new Vector4(0.1f, 0.1f, 0.1f, 1);
                newobj = l;
                DrawHelper.setmoney(spieler, -200, rHv2s);
            }
            else if (auswahl == 3) // Latte
            {
                newobj = buildbox(startort, new Vector3(1.2f, 0.1f, 0.4f));
                DrawHelper.setmoney(spieler, -200, rHv2s);
                newobj.Physics.Mass = 2f;
            }
            else if (auswahl == 4) // Quader       das kommentierte ist die //Pyramide
            {
                newobj = buildbox(startort, new Vector3(0.8f, 0.4f, 0.4f));
                newobj.Physics.Mass = 2f;
                DrawHelper.setmoney(spieler, -200, rHv2s);
            }
            else
            {
                newobj = buildbox(startort, new Vector3(0.1f, 0.1f, 0.1f));
            }

            //TODO z-Achse sperren
            newobj.Physics.PositionUpdateMode = BEPUphysics.PositionUpdating.PositionUpdateMode.Continuous;
            newobj.Tag = idnummer;
            newobj.PhysicsMaterial.Bounciness = 0.2f;
            scene.Add(newobj);
            dasobj = new Objekte(newobj, 1, "blank");
            objListe.Add(dasobj); //Liste hinzufügen
            return dasobj;
        }
        //private static List<Waffen> waffenListe = new List<Waffen>();

        public static Objekte createObj(int auswahl, Spieler spieler, float xPos)
        {
            idnummer++;
            Vector3 startort = new Vector3(xPos, 2, -5);
            SceneObject newobj;
            Objekte dasobj;

            if (auswahl == 1)//Würfel
            {
                newobj = buildbox(startort, new Vector3(0.4f, 0.4f, 0.4f));
                spieler.setMoney(spieler.getMoney() - 150); //Rohkosten abziehen
                newobj.Physics.Mass = 1f;
            }
            else if (auswahl == 2)
            {
                ModelObject l = new ModelObject(startort, Quaternion.CreateFromAxisAngle(new Vector3(1,2,0),(float)Math.PI), new Vector3(1, 1, 1), CollisionType.ExactMesh, "", "L", 2f);
                newobj = l;
                spieler.setMoney(spieler.getMoney() - 200);
            }
            else if (auswahl == 3) // Latte
            {
                newobj = buildbox(startort, new Vector3(1.2f, 0.1f, 0.4f));
                spieler.setMoney(spieler.getMoney() - 200); //Rohkosten abziehen
                newobj.Physics.Mass = 2f;
            }
            else if (auswahl == 4) // Quader       das kommentierte ist die //Pyramide
            {
                newobj = buildbox(startort, new Vector3(0.8f, 0.4f, 0.4f));
                newobj.Physics.Mass = 2f;
                /*ModelObject p = new ModelObject(startort, Quaternion.CreateFromAxisAngle(new Vector3(1, 2, 0), (float)Math.PI), new Vector3(1, 1, 1), CollisionType.ExactMesh, "", "Pyramide", 1f);
                newobj = p;*/
                spieler.setMoney(spieler.getMoney() - 200);
            }
            else
            {
                newobj = buildbox(startort, new Vector3(0.1f, 0.1f, 0.1f));
            }

            //TODO z-Achse sperren
            newobj.Physics.PositionUpdateMode = BEPUphysics.PositionUpdating.PositionUpdateMode.Continuous;
            newobj.Tag = idnummer;
            newobj.PhysicsMaterial.Bounciness = 0.2f;
            scene.Add(newobj);
            dasobj = new Objekte(newobj, 1, "blank");
            objListe.Add(dasobj); //Liste hinzufügen
            return dasobj;
        }
        public override void Update(GameTime gameTime, bool otherScreenHasFocus, bool coveredByOtherScreen)
        {
            
            
            switch (currentState)
            {
                     
                #region Menu
		 
	            case States.Menu: 

                    //Platz für ein Menu
                    //Menu();
                    prewState = States.Menu;
                    currentState = States.Start;
                    break;

                    #endregion

                #region Start
                //Start: Objekte werden geladen, Kamera wird erstellt, danach Camto1
                case States.Start:

                    startObjects.LoadStartObjects(level.getLevel());

                    //Zeigt das Baumenü mit den Objekten und Texturen die der Spieler wählen kann, benötigt Name des Bildes
                    auswahlanzeige = startObjects.showObjects("Bau");
                    objWafC = startObjects.LoadObjWafC();

                    //setzt die Variable PosX1 auf die Position bevor er in den nächsten State wechselt
                    PosX1 = Scene.Camera.Position.X;
                    Zeit1 = gameTime.TotalGameTime.Milliseconds + gameTime.TotalGameTime.Seconds * 1000 + gameTime.TotalGameTime.Minutes * 60 * 1000; //Zeit zwischenspeichern
                    aktuallisiereZeit(gameTime);

                    //danach Kamera an Spielerposition 1 bewegen
                    prewState = States.Start;
                    currentState = States.Camto1;

                    break;

                #endregion

                #region Camto1
                //Camto1: Kamera wird an die Linke Position bewegt
                case States.Camto1:
                    aktuallisiereZeit(gameTime);
                    weiterSym.Visible = false;
                    detecting = false;  //Kinect deaktiviert

                    //Variable wird für nächste Schussphasen zurückgesetzt
                    firedWaffen = 0;                        
                    
                    //Kamera wird bewegt
                    cameraMovement.move(zeit,3000,PosX1, level.getSpieler1Pos());

                #region Übergangsbedingungen
                    //Wenn die Spielerposition 1 erreicht wurde startet die Bauphase/Schussphase
                    if (Scene.Camera.Position.X == level.getSpieler1Pos())
                    {
                        //setzt die Variable PosX1 auf die Position bevor er in den nächsten State wechselt 
                        PosX1 = Scene.Camera.Position.X;
                        Zeit1 = gameTime.TotalGameTime.Milliseconds + gameTime.TotalGameTime.Seconds * 1000 + gameTime.TotalGameTime.Minutes * 60 * 1000; //Zeit zwischenspeichern
                        aktuallisiereZeit(gameTime);

                        //Wenn wir aus der Startphase kommen, -> Bauphase 1
                        if (prewState == States.Start)
                        {
                            prewState = States.Camto1;
                            currentState = States.Bauphase1O;
                        }

                        //Wenn wir aus der Bauphase von Spieler2 kommen, -> Schussphase 1
                        else if (prewState == States.Bauphase2O)
                        {
                            prewState = States.Camto1;
                            currentState = States.Schussphase1;
                        }

                        //Wenn wir aus der Schussphase von Spieler2 kommen
                        else if (prewState == States.Schussphase2)
                        {
                            //Ist die Schussphase durch -> Bauphase 1
                            if (schussphasenDurch)
                            {
                                prewState = States.Camto1;
                                currentState = States.Schussphase1;
                                /* schussphasenDurch wird auf true gesetzt, damit nach der nächsten Schussphase wieder in die Bauphase gewechselt wird.
                                 * Schussphase2 sagt also schussphaseDurch= true, will aber erst noch Schussphase 1
                                 */

                            }
                            //sonst Schussphase 1
                            else
                            {
                                prewState = States.Camto1;
                                currentState = States.Bauphase1O;
                            }
                        }
                    } 
                #endregion

                    break;

                #endregion

                #region Objektemenüs
                case States.Bauphase2O:

                case States.Bauphase1O:
                    aktuallisiereZeit(gameTime);
                    detecting = true;               //Kinect aktiv
                    if (!weiterSym.Visible)
                    {
                        weiterSym.Visible = true;
                    }
                    float pos;
                    

                    #region Spieler &  Spielerposition
                    if (currentState == States.Bauphase1O)
                    {
                        gamer = spieler1;
                        pos = level.getSpieler1Pos();
                        weiterSym.Position = new Vector3(pos+1.13f, -0.7f, -2f);
                    }
                    else
                    {
                        gamer = spieler2;
                        pos = level.getSpieler2Pos();
                        weiterSym.Position = new Vector3(pos + 1.13f, -0.7f, -2f);
                    }
                    #endregion

                    #region Objekt erzeugen und mit Hand positionieren
                    if (!showWaffe)
                    {
                        if (getObj && objInHand == false && auswahl != 0 && auswahl < 5)    //"klick" und das Objekt wurde noch nicht erstellt und linke hand befindet sich auf auswahlfeld
                        {
                            objInHand = true;                                               //soll jetzt der Hand folgen
                            aktuellesObj = Objektverwaltung.createObj(auswahl, gamer, pos); //aktuelles Objekt wird erzeugt
                        }

                        if (objInHand)//Ausrichten des Obj
                        {
                            Vector3 rH = new Vector3(rightHand.Position.X, rightHand.Position.Y, -5f); //Handvektor ohne Tiefenveränderung
                            aktuellesObj.setPosition(rH);                 //Objektposition wird auf Handgelegt

                            Objektverwaltung.orientObj(aktuellesObj, leftHand.Position.X, leftHand.Position.Y);

                            rightHand.Visible = false;                  //Anzeige der rechten Hand deaktiviert
                        }

                        if (klick && objInHand == true)                //wenn sich ein Objekt in der Hand befindet und erneut geklickt wird
                        {
                            rightHand.Visible = true;                   //Rechte Hand wird wieder angezeigt
                            klick = false;
                            objInHand = false;                          //Bekommt nicht mehr die Posiotion der hand -> fällt

                            if (currentState == States.Bauphase1O)
                            {
                                prewState = States.Bauphase1O;              //Statewechsel
                                currentState = States.Bauphase1T;
                            }
                            else
                            {
                                prewState = States.Bauphase2O;
                                currentState = States.Bauphase2T;
                            }
                        }
                    }
                    #endregion

                    #region Waffe erzeugen und mit Hand positionieren
                    if (showWaffe)
                    {


                        if (getObj && objInHand == false && auswahl != 0 && auswahl < 5)    //"klick" und die Waffe wurde noch nicht erstellt und linke hand befindet sich auf auswahlfeld
                        {
                            objInHand = true;                                                   //soll jetzt der Hand folgen

                            aktuelleWaffe = Objektverwaltung.createWaffe(auswahl, gamer, rightHand.Position);  //aktuelles Objekt wird erzeugt
                            if (spieler1 == gamer)
                            {
                                spieler1.setWaffen(aktuelleWaffe);                                          //Waffe der Waffenliste des Spieler hinzufügen
                            }
                            else
                            {
                                spieler2.setWaffen(aktuelleWaffe);
                            }
                        }

                        
                        if (objInHand && showWaffe == true)                                              //Ausrichten der Waffe
                        {
                            Vector3 rH = new Vector3(rightHand.Position.X, rightHand.Position.Y, -5f);  //Handvektor ohne Tiefenveränderung
                            aktuelleWaffe.setPosition(rH);                                              //Waffenposition wird auf Handgelegt
                            
                            rightHand.Visible = false;                                                  //Anzeige der rechten Hand deaktiviert
                            
                        }

                        if (klick && objInHand)                                                         //wenn sich ein Objekt in der Hand befindet und erneut geklickt wird
                        {
                            rightHand.Visible = true;                                                   //Rechte Hand wird wieder angezeigt
                            klick = false;
                            objInHand = false;
                            
                        }

                    }
                    
                    #endregion

                    #region Wechsel von der Objekt zur Waffenauswahl
                    if (klick&&objInHand == false && auswahl == 5 && showWaffe == false) //"klick" und das Objekt wurde noch nicht erstellt und linke hand befindet sich auf auswahlfeld
                    {
                        showWaffe = true;
                    }
                    else if (klick && objInHand == false &&  auswahl == 5 && showWaffe)
                    {
                        showWaffe = false;
                    }
                    #endregion
                    
                    #region Übergangsbedingungen
                    //Wenn Spieler nicht ausreichend Geld hat (oder auf weiter Klickt => in Kinect realisiert)
                    if (gamer.getMoney() < level.getMinMoney() && objInHand == false)
                    {
                        PosX1 = Scene.Camera.Position.X;
                        Zeit1 = gameTime.TotalGameTime.Milliseconds + gameTime.TotalGameTime.Seconds * 1000 + gameTime.TotalGameTime.Minutes * 60 * 1000; //Zeit zwischenspeichern
                        aktuallisiereZeit(gameTime);

                        if (currentState == States.Bauphase1O)
                        {
                            prewState = States.Bauphase1O;
                            if (spieler2.getMoney() < level.getMinMoney() && spieler2.getMoney() < spieler1.getMoney())
                            {
                                currentState = States.Schussphase1;
                            }
                            else
                            {
                                currentState = States.Camto2;
                            }
                        }
                        else //Bauphase2O
                        {
                            prewState = States.Bauphase2O;
                            if (spieler1.getMoney() < spieler2.getMoney())
                            {
                                currentState = States.Schussphase2;
                            }
                            else
                            {
                                currentState = States.Camto1;
                            }
                        }
                    }
                    #endregion
                    
                    break;

                #endregion

                #region Texturenmenüs
                //Bauphase, Spiele 1, Objekte erstellen
                case States.Bauphase1T:
                case States.Bauphase2T:
                    aktuallisiereZeit(gameTime);
                    Objektverwaltung.firstMaterial(aktuellesObj, auswahl);
                    weiterSym.Visible = false;

                    if (currentState == States.Bauphase1T)
                    {
                        gamer = spieler1;
                    }
                    else 
                    {
                        gamer = spieler2;
                    }

                    if (klick) //Übergang wird mit klick erzeugt
                    {
                        #region Kosten dem Spieler abziehen
                        if (aktuellesObj.getMaterial() == "MHolz")
                        { } //kostenlos
                        else if (aktuellesObj.getMaterial() == "MStein")
                        {
                            gamer.setMoney(spieler1.getMoney() - 50);
                        }
                        else if (auswahl == 3)
                        {
                            gamer.setMoney(spieler1.getMoney() - 100);
                        }
                        else if (auswahl == 4)
                        {
                            gamer.setMoney(spieler1.getMoney() - 200);
                        }
                        #endregion

                        if (currentState == States.Bauphase1T)
                        {
                            prewState = States.Bauphase1T;
                            currentState = States.Bauphase1O;
                        }
                        else
                        {
                            prewState = States.Bauphase2T;
                            currentState = States.Bauphase2O;
                        }
                    }
                    break;

                #endregion

                #region Camto2
                //Kamera wird an die Rechte Positon bewegt
                case States.Camto2:
                    aktuallisiereZeit(gameTime);
                    detecting = false;               //Kinect deaktiviert
                    weiterSym.Visible = false;

                    //Variable wird für nächste Schussphasen zurückgesetzt
                    firedWaffen = 0; 

                    //Kamera wird bewegt
                    cameraMovement.move(zeit, 3000, PosX1, level.getSpieler2Pos());

                #region Übergangsbedingungen
                    //Wenn die Spielerposition 2 erreicht wurde startet die Bauphase/Schussphase
                    if (Scene.Camera.Position.X == level.getSpieler2Pos())
                    {
                        //setzt die Variable PosX1 auf die Position bevor er in den nächsten State wechselt 
                        PosX1 = Scene.Camera.Position.X;
                        Zeit1 = gameTime.TotalGameTime.Milliseconds + gameTime.TotalGameTime.Seconds * 1000 + gameTime.TotalGameTime.Minutes * 60 * 1000; //Zeit zwischenspeichern
                        aktuallisiereZeit(gameTime);

                        //Wenn wir aus der Bauphase1 kommen -> Bauphase 2 (ohne Geld, aber mehr Geld als Sp1 Schussphase2)
                        if (prewState == States.Bauphase1O)
                        {
                            //Spieler2 hat genug Geld zum Bauen
                            if (spieler2.getMoney() >= level.getMinMoney())
                            {
                                prewState = States.Camto2;
                                currentState = States.Bauphase2O;
                            }
                            //Spieler zwei hat nicht genug Geld aber mehr als Spieler1 -> Schussphase 2
                            else if (spieler2.getMoney() > spieler1.getMoney())
                            {
                                prewState = States.Camto2;
                                currentState = States.Schussphase2;
                            }
                        }
                        //Wenn wir aus der Schussphase1 kommen, muss Schussphase 2 starten 
                        else if (prewState == States.Schussphase1)
                        {
                            prewState = States.Camto2;
                            currentState = States.Schussphase2;
                        }

                    }
                #endregion

                    break;

                #endregion

                #region Schussphasen
                //Schussphasen
                case States.Schussphase2:
                case States.Schussphase1:

                    
                    aktuallisiereZeit(gameTime);
                    detecting = true;               //Kinect aktiv
                    weiterSym.Visible = false;
                    int xR;

                    if (currentState == States.Schussphase1)
                    {
                        gamer = spieler1;
                        xR = 1;
                    }
                    else
                    {
                        gamer = spieler2;
                        xR = -1;
                    }
                    #region Schussfunktion //shoot Funktion TODO: "auslagern"
                    if (gamer.getWaffen() != 0)
                    {   
                        aktuelleWaffe = Objektverwaltung.getWaffe(gamer, firedWaffen);
                        aktuelleWaffe.setWinkel(rightHand.Position.Y);//Setzt Winkel der Kanone in Waffen

                        if (klick==true)
                        {
                           float schusswinkel,x,y,velocity;
                           Vector3 spawnpoint = new Vector3 ( rightHand.Position.X+1,rightHand.Position.Y-1, rightHand.Position.Z); //Spawnposition nur Vorübergehend sollte am Objekt sein!
                           bullet = new SphereObject(new Vector3(aktuelleWaffe.getPosition().X, aktuelleWaffe.getPosition().Y,rightHand.Position.Z), 0.1f, 10, 10, 0.05f);
                           Vector3 shootdirection = new Vector3();
                           Scene.Add(bullet);
                            
                           schusswinkel = aktuelleWaffe.getWinkel();
                           x=(float)Math.Cos(schusswinkel);
                           y=(float)Math.Sin(schusswinkel);
                           shootdirection = new Vector3(x,y,0);
                           if (gamer == spieler1)
                           {
                               velocity = leftHand.Position.Y * 10f;
                               bullet.Physics.LinearVelocity = shootdirection * velocity;


                           }
                           else
                           {
                               velocity = leftHand.Position.Y * 10f;
                               shootdirection.X = shootdirection.X * (-1f);
                               bullet.Physics.LinearVelocity = shootdirection * velocity;
                           }


                           firedWaffen++;
                           bulletInAir = true;
                           
                           
                        }
        
                        
                        
                    }
                    
                    
                    if (bulletInAir)
                    {
                       
                        cameraMovement.chaseBullet(bullet.Position, cam.Position);
                        
                        bullet.Collided +=new EventHandler<CollisionArgs>(bulletCollidedHandler);

                        //Partikel Effekte FUNKTIONIERT NOCH NICHT
                        ParticleEffect effect = new ParticleEffect()
                        {
                            Emitters = new EmitterCollection()
                                {   
                                    new SphereEmitter
                                    {
                                        Name="Flame",
                                        Budget = 100,
                                        Term = 0.5f,
                                        ReleaseQuantity = 8,
                                        Enabled = true,
                                        ReleaseSpeed = new Range(5f,5f),
                                        ReleaseColour = new ColourRange
                                        {
                                            Red = new Range(0.9f,1f),
                                            Green = new Range(0.5f,0.5f),
                                            Blue = new Range(0f,0f),
                                        },
                                        ReleaseOpacity = new Range(1f,1f),
                                        ReleaseScale = new Range(2f,2f),
                                        ReleaseRotation = new RotationRange
                                        {
                                            Pitch = new Range(0f,0f),
                                            Yaw = new Range(0f,0f),
                                            Roll = new Range(-3.14f,3.14f),
                                        },
                                        ParticleTexture = Core.Content.Load<Texture2D>("Flames"),
                                        BlendMode = EmitterBlendMode.Add,
                                        Radius = 3f,
                                        Shell = true,
                                        Radiate = true,                        
                                        BillboardStyle = ProjectMercury.BillboardStyle.Spherical,
                                        Modifiers = new ModifierCollection
                                        {
                                            new OpacityInterpolator2
                                            {
                                                InitialOpacity = 0.5f,                                
                                                FinalOpacity = 0f,
                                            },
                                            new RotationModifier
                                            {
                                                RotationRate = new Vector3(0,0,1)
                                            }
                                        },
                                        Controllers = new ControllerPipeline
                                        {
                                            new CooldownController
                                            {
                                                CooldownPeriod = 0.02f,
                                            },
                                        }
                                    }
                                }
                        };

                        ParticleObject particle = new ParticleObject(bullet.Position, effect);
                        
                       


                    }
                    
                    #endregion

                    #region Übergangsbedingungen
                    //Wenn alle Waffen abgefeuert wurden...
                    if (firedWaffen == gamer.getWaffen())
                    {
                        //setzt die Variable PosX1 auf die Position bevor er in den nächsten State wechselt 
                        PosX1 = Scene.Camera.Position.X;
                        Zeit1 = gameTime.TotalGameTime.Milliseconds + gameTime.TotalGameTime.Seconds * 1000 + gameTime.TotalGameTime.Minutes * 60 * 1000; //Zeit zwischenspeichern
                        aktuallisiereZeit(gameTime);

                        //Wenn die Schussphase durch ist, beginnt die Bauphase
                        if (schussphasenDurch)
                        {
                            if (currentState == States.Schussphase1)
                            {
                                prewState = States.Schussphase1;
                                schussphasenDurch = false;
                                currentState = States.Bauphase1O;
                            }
                            else
                            {
                                prewState = States.Schussphase2;
                                schussphasenDurch = false;
                                currentState = States.Camto1;
                            }
                        }

                        //Sonst in die andere Schussphase wechseln
                        else
                        {
                            if (currentState == States.Schussphase1)
                            {
                                prewState = States.Schussphase1;
                                schussphasenDurch = true;           //nach der Schussphase2 ist die Schussphase beendet
                                currentState = States.Camto2;
                            }
                            else
                            {
                                prewState = States.Schussphase2;
                                schussphasenDurch = true;           //nach der Schussphase1 ist die Schussphase beendet
                                currentState = States.Camto1;
                            }
                        }
                    }

                    #endregion


                    break;

                #endregion

                #region End
                //Ende des Spiels
                case States.End:
                    //noch leer



                    //neues Spiel, alle vorherigen Objekte werden gelöscht
                    Scene.RemoveAllSceneObjects();  
                    break;

                #endregion

                
            }




            #region Objekt-/ Texturauswahl ein-/ausblenden
            if (currentState != States.Menu && currentState != States.Start && currentState != States.End)
            {
                if (currentState == States.Bauphase1O)
                {
                    if (showWaffe)
                    {
                        startObjects.einausblender(auswahlanzeige, objWafC, 11, zeit);
                    }
                    else
                    {
                        startObjects.einausblender(auswahlanzeige, objWafC, 1, zeit);
                    }
                }
                else if (currentState == States.Bauphase1T)
                {
                    showWaffe = false;
                    startObjects.einausblender(auswahlanzeige, objWafC, 12, zeit);
                }
                else if (currentState == States.Bauphase2O)
                {
                    if (showWaffe)
                    {
                        startObjects.einausblender(auswahlanzeige, objWafC, 21, zeit);
                    }
                    else
                    {
                        startObjects.einausblender(auswahlanzeige, objWafC, 2, zeit);
                    }
                }
                else if (currentState == States.Bauphase2T)
                {
                    showWaffe = false;
                    startObjects.einausblender(auswahlanzeige, objWafC, 22, zeit);
                }
                else
                {
                    startObjects.einausblender(auswahlanzeige, objWafC, 0, zeit);
                }
            }



            #endregion

            #region Kinect
            if (detecting)
            {
                if (Scene.Kinect.SkeletonDataReady)
                {
                    List<NOVA.Components.Kinect.Skeleton> skeletons = new List<NOVA.Components.Kinect.Skeleton>(Scene.Kinect.Skeletons);

                    //Aktives Skelett finden
                    foreach (NOVA.Components.Kinect.Skeleton skeleton in skeletons)
                    {
                        if (skeleton.TrackingState == SkeletonTrackingState.Tracked && skeleton.Joints.Count != 0)
                        {
                            //Box auf Hand, Klick auf Weiter
                           #region Detektion der rechten Hand

                            if (skeleton.Joints[JointType.HandRight].TrackingState == JointTrackingState.Tracked)
                            {
                                //Position der rechten Hand des Spielers in Bildschirmkoodinaten
                                Vector2 screenPos = skeleton.Joints[JointType.HandRight].ScreenPosition;
                                Vector2 normScreenPos = new Vector2(screenPos.X, screenPos.Y);
                                screenPos.X = screenPos.X * Scene.Game.Window.ClientBounds.Width;
                                screenPos.Y *= Scene.Game.Window.ClientBounds.Height;

                                //parallele Ebene zum Bildschirm erzeugen in der die Kugel transformiert wird
                                Plane plane2 = new Plane(Vector3.Forward, -4f);

                                //Weltkoordinatenpunk finden
                                Vector3 worldPos2 = Helpers.Unproject(screenPos, plane2);

                                #region Box auf Hand
                                //Position der Kugel setzen
                                rightHand.Position = worldPos2;
                                #endregion

                                #region getObj
                                if (normScreenPos.X >= 0.2f && normScreenPos.X <= 0.8f && normScreenPos.Y <= 0.1f)
                                {
                                    getObj = true;
                                }
                                else {getObj = false; }
                                #endregion

                                #region WEITER klick
                                //Wenn sich die rechte Hand in der oberen, rechten Ecke befindet & KLICK -> Klick auf WEITER
                                if (normScreenPos.X >= 0.9f && normScreenPos.Y >= 0.9f)
                                {
                                    //setzt die Variable PosX1 auf die Position bevor er in den nächsten State wechselt 
                                    PosX1 = Scene.Camera.Position.X;
                                    Zeit1 = gameTime.TotalGameTime.Milliseconds + gameTime.TotalGameTime.Seconds * 1000 + gameTime.TotalGameTime.Minutes * 60 * 1000; //Zeit zwischenspeichern
                                    aktuallisiereZeit(gameTime);

                                    if (currentState == States.Bauphase1O)
                                    {
                                        prewState = States.Bauphase1O;

                                        //wenn Spieler2 über genügend Geld zum bauen verfügt, Bauphase Spieler 2
                                        //Wenn Spieler2 mehr Geld besitzt fängt er die Schussphase2 an
                                        if (spieler2.getMoney() >= level.getMinMoney() || spieler2.getMoney() > spieler1.getMoney())
                                        {
                                            currentState = States.Camto2;
                                        }
                                        //wenn Spieler2 nicht über genügend Geld zum bauen verfügt, und Spieler1 mehr Geld hat beginnt Schussphase1
                                        else
                                        {
                                            currentState = States.Schussphase1;
                                        }

                                    }
                                    else if (currentState == States.Bauphase2O)
                                    {
                                        prewState = States.Bauphase2O;

                                        //Wenn Spieler2 mehr Geld besitzt fängt er die Schussphase2 an
                                        if (spieler2.getMoney() > spieler1.getMoney())
                                        {
                                            currentState = States.Schussphase2;
                                        }
                                        //sonst Spieler 1
                                        else
                                        {
                                            currentState = States.Camto1;
                                        }

                                    }
                                    else
                                    {
                                        return;
                                    }
                                }
                                #endregion

                                

                            }
                            #endregion

                            //Box auf Hand, Auswahl Textur/ Objekt
                            #region Detektion der linken Hand
                            if (skeleton.Joints[JointType.HandLeft].TrackingState == JointTrackingState.Tracked)
                            {
                                //Position der linken Hand des Spielers in Bildschirmkoodinaten
                                screenPos = skeleton.Joints[JointType.HandLeft].ScreenPosition;
                                Vector2 normScreenPos = new Vector2(screenPos.X, screenPos.Y);
                                screenPos.X = screenPos.X * Scene.Game.Window.ClientBounds.Width;
                                screenPos.Y *= Scene.Game.Window.ClientBounds.Height;

                                //parallele Ebene zum Bildschirm erzeugen in der die Kugel transformiert wird
                                Plane plane2 = new Plane(Vector3.Forward, -1f);

                                //Weltkoordinatenpunk finden
                                Vector3 worldPos2 = Helpers.Unproject(screenPos, plane2);

                                #region Box auf Hand
                                //Position der Kugel setzen
                                leftHand.Position = worldPos2;
                                #endregion

                                #region Auswahl Textur/ Objekt
                                auswahl = Auswahl.auswahl(normScreenPos);

                                #endregion
                            }
                           
                            #endregion

                            //Hintergrundsbild verschieben
                            #region Detektion des Kopfes
                            if (skeleton.Joints[JointType.Head].TrackingState == JointTrackingState.Tracked)
                            {
                                //Position des Kopfes des Spielers in Bildschirmkoodinaten
                                Vector2 screenPos = skeleton.Joints[JointType.Head].ScreenPosition;
                                Vector2 normScreenPos = new Vector2(screenPos.X / Scene.Game.Window.ClientBounds.Width, screenPos.Y / Scene.Game.Window.ClientBounds.Height);

                                //Hintergrund bewegen
                                startObjects.MoveBackground(normScreenPos.X - 0.5f, normScreenPos.Y - 0.5f);
                                


                            }
                            
                            #endregion

                        }
                    }

                }
            }
            else
            {
                
            }
            #endregion

            

            objState = currentState; //Am Ende jenden Updates wird der State angeglichen

            Objektverwaltung.refreshObj(spieler1,spieler2); //Entfernt Objekte ohne LP
         
            base.Update(gameTime, otherScreenHasFocus, coveredByOtherScreen);
      
        }
Esempio n. 4
0
        public Gamestart.States uebergang(Gamestart.States actuellState, Spieler spieler1, Spieler spieler2, Levels level)
        {
            #region Bauphase 1
            if (actuellState == Gamestart.States.Bauphase1O)
            {
                if (spieler2.getMoney() < level.getMinMoney())                  //Spieler2 hat nicht genug Geld
                {
                    if (spieler1.getMoney() > spieler2.getMoney())                      //Spieler1 ist reicher
                    {
                        if (spieler1.getList().Count > 0)                                       //Spieler1 hat Waffen
                        {
                            schussphase1done = true;
                            return Gamestart.States.Schussphase1;
                        }
                        else if (spieler2.getList().Count > 0)                                  //nein, aber Spieler2 hat Waffen
                        {
                            schussphase1done = true; /*Da Spieler 1 eh nicht Schießen kann*/
                            zielstate = Gamestart.States.Schussphase2;
                            return Gamestart.States.Camto2;
                        }
                        else                                                                    //beide haben keine Waffen
                        {
                            newround(spieler1, spieler2, level);
                            return Gamestart.States.Bauphase1O;
                        }
                    }
                    else                                                                //Spieler2 ist reicher
                    {
                        if (spieler2.getList().Count > 0)                                       //Spieler2 hat Waffen
                        {
                            zielstate = Gamestart.States.Schussphase2;
                            return Gamestart.States.Camto2;
                        }
                        else if (spieler1.getList().Count > 0)                                  //nein, aber Spieler1 hat Waffen
                        {
                            schussphase2done = true; /*Da Spieler 2 eh nicht Schießen kann*/
                            schussphase1done = true;
                            return Gamestart.States.Schussphase1;
                        }
                        else                                                                    //beide haben keine Waffen
                        {
                            newround(spieler1, spieler2, level);
                            return Gamestart.States.Bauphase1O;
                        }
                    }
                }
                else                                                            //Spieler2 hat genug Geld
                {
                    zielstate = Gamestart.States.Bauphase2O;
                    return Gamestart.States.Camto2;
                }
            }
            #endregion
            #region Bauphase 2
            else if(actuellState == Gamestart.States.Bauphase2O)
            {
                if (spieler1.getMoney() > spieler2.getMoney())                  //Spieler1 hat mehr Geld als Spieler2
                {
                    if (spieler1.getList().Count > 0)                                       //Spieler1 hat Waffen
                    {
                        zielstate = Gamestart.States.Schussphase1;
                        return Gamestart.States.Camto1;
                    }
                    else if (spieler2.getList().Count > 0)                                  //nein, aber Spieler2 hat Waffen
                    {
                        schussphase1done = true; /*Da Spieler 1 eh nicht Schießen kann*/
                        schussphase2done = true;
                        return Gamestart.States.Schussphase2;
                    }
                    else                                                                    //beide haben keine Waffen
                    {
                        newround(spieler1, spieler2, level);
                        zielstate = Gamestart.States.Bauphase1O;
                        return Gamestart.States.Camto1;
                    }
                }
                else                                                           //Spieler2 ist reicher
                {
                    if (spieler2.getList().Count > 0)                                       //Spieler2 hat Waffen
                    {
                        schussphase2done = true;
                        return Gamestart.States.Schussphase2;
                    }
                    else if (spieler1.getList().Count > 0)                                  //nein, aber Spieler1 hat Waffen
                    {
                        schussphase2done = true; /*Da Spieler 2 eh nicht Schießen kann*/
                        zielstate = Gamestart.States.Schussphase1;
                        return Gamestart.States.Camto1;
                    }
                    else                                                                    //beide haben keine Waffen
                    {
                        newround(spieler1, spieler2, level);
                        zielstate = Gamestart.States.Bauphase1O;
                        return Gamestart.States.Camto1;
                    }
                }
            }
            #endregion
            #region Schussphase 1
            else if (actuellState == Gamestart.States.Schussphase1)
            {
                if (schussphase2done)                                           //War schon in Schussphase2
                {
                    newround(spieler1, spieler2, level);
                    return Gamestart.States.Bauphase1O;
                }
                else                                                            //War noch nicht in Schussphase2
                {
                    if (spieler2.getList().Count > 0)                                    //Spieler2 hat Waffen
                    {
                        zielstate = Gamestart.States.Schussphase2;
                        return Gamestart.States.Camto2;
                    }
                    else                                                                 //Spieler2 hat keine Waffe
                    {
                        newround(spieler1, spieler2, level);
                        return Gamestart.States.Bauphase1O;
                    }
                }
            }
            #endregion
            #region Schussphase 2
            else if (actuellState == Gamestart.States.Schussphase2)
            {
                if (schussphase1done)                                           //War schon in Schussphase1
                {
                    newround(spieler1, spieler2, level);
                    zielstate = Gamestart.States.Bauphase1O;
                    return Gamestart.States.Camto1;
                }
                else                                                            //War noch nicht in Schussphase1
                {
                    if (spieler1.getList().Count > 0)                                    //Spieler1 hat Waffen
                    {
                        zielstate = Gamestart.States.Schussphase1;
                        return Gamestart.States.Camto1;
                    }
                    else                                                                 //Spieler1 hat keine Waffe
                    {
                        newround(spieler1, spieler2, level);
                        zielstate = Gamestart.States.Bauphase1O;
                        return Gamestart.States.Camto1;
                    }
                }
            }
            #endregion
            #region Cam -> 1
            else if (actuellState == Gamestart.States.Camto1)
            {
                if (zielstate == Gamestart.States.Bauphase1O)
                {
                    return Gamestart.States.Bauphase1O;
                }
                else //(zielstate == Gamestart.States.Schussphase1)
                {
                    schussphase1done = true;
                    return Gamestart.States.Schussphase1;
                }
            }
            #endregion
            #region Cam -> 2
            else if (actuellState == Gamestart.States.Camto2)
            {
                if (zielstate == Gamestart.States.Bauphase2O)
                {
                    return Gamestart.States.Bauphase2O;
                }
                else //(zielstate == Gamestart.States.Schussphase2)
                {
                    schussphase2done = true;
                    return Gamestart.States.Schussphase2;
                }
            }
            #endregion

            return Gamestart.States.End;
        }
Esempio n. 5
0
 private void newround(Spieler spieler1, Spieler spieler2, Levels level)
 {
     spieler1.setMoney(spieler1.getMoney() + level.getRoundMoney());
     spieler2.setMoney(spieler2.getMoney() + level.getRoundMoney());
     schussphase1done = schussphase2done = false;
 }
Esempio n. 6
0
        public override void Update(GameTime gameTime, bool otherScreenHasFocus, bool coveredByOtherScreen)
        {
            #region Kinect

            if (Scene.Kinect.SkeletonDataReady)
            {
                List<NOVA.Components.Kinect.Skeleton> skeletons = new List<NOVA.Components.Kinect.Skeleton>(Scene.Kinect.Skeletons);

                //Aktives Skelett finden
                foreach (NOVA.Components.Kinect.Skeleton skeleton in skeletons)
                {
                    if (skeleton.TrackingState == SkeletonTrackingState.Tracked && skeleton.Joints.Count != 0)
                    {
                        //Box auf Hand, Klick auf Weiter
                        #region Detektion der rechten Hand

                        if (skeleton.Joints[JointType.HandRight].TrackingState == JointTrackingState.Tracked)
                        {
                            //Position der rechten Hand des Spielers in Bildschirmkoodinaten
                            rHv2s = skeleton.Joints[JointType.HandRight].ScreenPosition;
                            rHv2s -= new Vector2(0, 10);
                            rHv2n.X = rHv2s.X / screenDim.X;
                            rHv2n.Y = rHv2s.Y / screenDim.Y;

                            Plane plane2 = new Plane(Vector3.Forward, -4f);

                            //Weltkoordinatenpunk finden
                            Vector3 worldPos2R = Helpers.Unproject(rHv2s, plane2, false);
                            rHv2w = new Vector2(worldPos2R.X, worldPos2R.Y);

                            #region Auswahl Textur/ Objekt
                            auswahl = Auswahl.auswahl(rHv2n);

                            #endregion

                            if (klickCounter<100)
                            {
                                klickCounter++;
                            }

                            try
                            {

                                if (skeleton.HandPointers[1].IsTracked == true)
                                {
                                    if (skeleton.HandPointers[1].HandEventType == InteractionHandEventType.GripRelease && klickCounter >= 100)
                                    {
                                        klickRH = true;
                                        klickCounter = 0;
                                    }
                                    else
                                    {
                                        klickRH = false;
                                    }

                                }
                            }
                            catch { };

                        }
                        #endregion

                        //Box auf Hand, Auswahl Textur/ Objekt
                        #region Detektion der linken Hand
                        if (skeleton.Joints[JointType.HandLeft].TrackingState == JointTrackingState.Tracked)
                        {
                            //Position der linken Hand des Spielers in Bildschirmkoodinaten
                            lHv2s = skeleton.Joints[JointType.HandLeft].ScreenPosition;
                            lHv2n.X = lHv2s.X / screenDim.X;
                            lHv2n.Y = lHv2s.Y / screenDim.Y;

                            //parallele Ebene zum Bildschirm erzeugen in der die Kugel transformiert wird
                            Plane plane2 = new Plane(Vector3.Forward, -4f);

                            //Weltkoordinatenpunk finden
                            Vector3 worldPos2L = Helpers.Unproject(lHv2s, plane2, false);
                            lHv2w = new Vector2(worldPos2L.X, worldPos2L.Y);
                          /*  try
                            {
                               // klickLH = (skeleton.HandPointers[1].HandEventType == InteractionHandEventType.Grip);
                            }
                            catch { };*/
                        }

                        #endregion

                        //Hintergrundsbild verschieben
                        if (bulletInAir == false)
                        {
                            #region Detektion des Kopfes
                            if (skeleton.Joints[JointType.Head].TrackingState == JointTrackingState.Tracked)
                            {
                                //Position des Kopfes des Spielers in Bildschirmkoodinaten
                                Vector2 screenPos = skeleton.Joints[JointType.Head].ScreenPosition;
                                Vector2 normScreenPos = new Vector2(screenPos.X / screenDim.X, screenPos.Y / screenDim.Y);

                                Vector3 realPos = skeleton.Joints[JointType.Head].WorldPosition;
                                //Hintergrund bewegen
                                startObjects.MoveBackground(normScreenPos.X - 0.5f, normScreenPos.Y - 0.5f);

                                //Kamera auf z-Achse bewegen
                                realPos = skeleton.Joints[JointType.Head].WorldPosition;

                                #region Zoom Funktionen
                                //ZOOM Funktionen
                                if (currentState == States.Schussphase1 || currentState == States.Schussphase2)
                                {
                                    if (gamer == spieler1)
                                    {
                                        cameraMovement.zoom(realPos.Z, 1, new Vector3(10f, 2f, 15f));
                                    }
                                    if (gamer == spieler2)
                                    {
                                        cameraMovement.zoom(realPos.Z, -1, new Vector3(10f, 2f, 15f));
                                    }
                                }
                                if (currentState == States.Bauphase1O || currentState == States.Bauphase1T || currentState == States.Bauphase2O || currentState == States.Bauphase2T)
                                {
                                    if (gamer == spieler1)
                                    {
                                        cameraMovement.zoom(realPos.Z, 1, new Vector3(1.5f, 0f, 4f));
                                    }
                                    if (gamer == spieler2)
                                    {
                                        cameraMovement.zoom(realPos.Z, -1, new Vector3(1.5f, 0f, 4f));
                                    }
                                }

                                #endregion

                            }
                            #endregion
                        }

                    }
                }

            }
            #endregion

            switch (currentState)
            {
                #region Start
                //Start: Objekte werden geladen, Kamera wird erstellt, danach Camto1
                case States.Start:

                    startObjects.LoadStartObjects(level.getLevel());

                    //setzt die Variable PosX1 auf die Position bevor er in den nächsten State wechselt
                    PosX1 = Scene.Camera.Position.X;
                    Zeit1 = gameTime.TotalGameTime.Milliseconds + gameTime.TotalGameTime.Seconds * 1000 + gameTime.TotalGameTime.Minutes * 60 * 1000; //Zeit zwischenspeichern
                    aktuallisiereZeit(gameTime);

                    //danach Kamera an Spielerposition 1 bewegen
                    currentState = States.Camto1;

                    break;

                #endregion

                #region Camto1
                //Camto1: Kamera wird an die Linke Position bewegt
                case States.Camto1:
                    aktuallisiereZeit(gameTime);

                    //Variable wird für nächste Schussphasen zurückgesetzt
                    firedWaffen = 0;

                    //Kamera wird bewegt
                    cameraMovement.move(zeit,3000,PosX1, level.getSpieler1Pos());

                #region Übergangsbedingungen
                    //Wenn die Spielerposition 1 erreicht wurde startet die Bauphase/Schussphase
                    if (Scene.Camera.Position.X == level.getSpieler1Pos())
                    {
                        //setzt die Variable PosX1 auf die Position bevor er in den nächsten State wechselt
                        PosX1 = Scene.Camera.Position.X;
                        Zeit1 = gameTime.TotalGameTime.Milliseconds + gameTime.TotalGameTime.Seconds * 1000 + gameTime.TotalGameTime.Minutes * 60 * 1000; //Zeit zwischenspeichern
                        aktuallisiereZeit(gameTime);

                        currentState = logik.uebergang(currentState, spieler1, spieler2, level);
                    }
                #endregion

                    break;

                #endregion

                #region Objektemenüs
                case States.Bauphase2O:

                case States.Bauphase1O:
                    aktuallisiereZeit(gameTime);
                    float pos;

                    #region Spieler &  Spielerposition
                    if (currentState == States.Bauphase1O)
                    {
                        gamer = spieler1;
                        pos = level.getSpieler1Pos();
                    }
                    else
                    {
                        gamer = spieler2;
                        pos = level.getSpieler2Pos();
                    }
                    #endregion

                    #region Objekt erzeugen und mit Hand positionieren
                    if (!showWaffe)
                    {
                        if (klickRH && !objInHand && auswahl != 0 &&auswahl < 5)    //"klick" und das Objekt wurde noch nicht erstellt und linke hand befindet sich auf auswahlfeld
                        {
                            klickRH = false;
                            objInHand = true;                                               //soll jetzt der Hand folgen
                            aktuellesObj = Objektverwaltung.createObj(auswahl, gamer, pos, rHv2s); //aktuelles Objekt wird erzeugt
                        }

                        if (objInHand)//Ausrichten des Obj
                        {
                            Vector3 rH = new Vector3(rHv2w.X, rHv2w.Y, -5f); //Handvektor ohne Tiefenveränderung
                            aktuellesObj.setPosition(rH);                 //Objektposition wird auf Handgelegt

                            Objektverwaltung.orientObj(aktuellesObj, lHv2w.X, lHv2w.Y);
                        }

                        if (klickRH && objInHand)                //wenn sich ein Objekt in der Hand befindet und erneut geklickt wird
                        {
                            klickRH = false;
                            objInHand = false;                          //Bekommt nicht mehr die Posiotion der hand -> fällt

                            if (currentState == States.Bauphase1O)
                            {
                                currentState = States.Bauphase1T;
                            }
                            else
                            {
                                currentState = States.Bauphase2T;
                            }
                        }
                    }
                    #endregion

                    #region Waffe erzeugen und mit Hand positionieren
                    if (showWaffe)
                    {
                        if (klickRH && !objInHand && auswahl != 0 && auswahl < 5)    //"klick" und die Waffe wurde noch nicht erstellt und linke hand befindet sich auf auswahlfeld
                        {
                            klickRH = false;
                            objInHand = true;                                                   //soll jetzt der Hand folgen

                            aktuelleWaffe = Objektverwaltung.createWaffe(auswahl, gamer, rHv2w);  //aktuelles Objekt wird erzeugt
                            if (spieler1 == gamer)
                            {
                                spieler1.setWaffen(aktuelleWaffe);                                          //Waffe der Waffenliste des Spieler hinzufügen
                            }
                            else
                            {
                                spieler2.setWaffen(aktuelleWaffe);
                            }
                        }

                        if (objInHand && showWaffe == true)                                              //Ausrichten der Waffe
                        {
                            Vector3 rH = new Vector3(rHv2w, -5f);                                       //Handvektor ohne Tiefenveränderung
                            aktuelleWaffe.getModelObject().Position = rH;                               //Waffenposition wird auf Handgelegt
                        }

                        if (klickRH && objInHand)                                                         //wenn sich ein Objekt in der Hand befindet und erneut geklickt wird
                        {
                            klickRH = false;
                            objInHand = false;
                        }
                    }

                    #endregion

                    #region Wechsel von der Objekt zur Waffenauswahl
                    if (klickRH && objInHand == false && auswahl == 5 && showWaffe == false) //"klick" und das Objekt wurde noch nicht erstellt und linke hand befindet sich auf auswahlfeld
                    {
                        klickRH = false;
                        showWaffe = true;
                    }
                    else if (klickRH && objInHand == false &&  auswahl == 5 && showWaffe)
                    {
                        klickRH = false;
                        showWaffe = false;
                    }
                    #endregion

                    #region Übergangsbedingungen
                    //Wenn Spieler nicht ausreichend Geld hat (oder auf weiter Klickt => in Kinect realisiert)
                    if (gamer.getMoney() < level.getMinMoney() && objInHand == false && (currentState == States.Bauphase1O ||currentState == States.Bauphase2O))
                    {
                        PosX1 = Scene.Camera.Position.X;
                        Zeit1 = gameTime.TotalGameTime.Milliseconds + gameTime.TotalGameTime.Seconds * 1000 + gameTime.TotalGameTime.Minutes * 60 * 1000; //Zeit zwischenspeichern
                        aktuallisiereZeit(gameTime);
                        showWaffe = false;

                        currentState = logik.uebergang(currentState, spieler1, spieler2, level);
                            }
                    #endregion

                    break;

                #endregion

                #region Texturenmenüs
                //Bauphase, Spiele 1, Objekte erstellen
                case States.Bauphase1T:
                case States.Bauphase2T:
                    aktuallisiereZeit(gameTime);
                    Objektverwaltung.firstMaterial(aktuellesObj, auswahl);

                    if (currentState == States.Bauphase1T)
                    {
                        gamer = spieler1;
                    }
                    else
                    {
                        gamer = spieler2;
                    }

                    if (klickRH) //Übergang wird mit klick erzeugt
                    {
                        klickRH = false;
                        #region Kosten dem Spieler abziehen
                        if (aktuellesObj.getMaterial() == "MHolz")
                        { } //kostenlos
                        else if (aktuellesObj.getMaterial() == "MStein")
                        {
                            DrawHelper.setmoney(gamer, -50, rHv2s);
                        }
                        else if (auswahl == 3)
                        {
                            DrawHelper.setmoney(gamer, -100, rHv2s);
                        }
                        else if (auswahl == 4)
                        {
                            DrawHelper.setmoney(gamer, -200, rHv2s);
                        }
                        #endregion

                        if (currentState == States.Bauphase1T)
                        {
                            currentState = States.Bauphase1O;
                        }
                        else
                        {
                            currentState = States.Bauphase2O;
                        }
                    }
                    break;

                #endregion

                #region Camto2
                //Kamera wird an die Rechte Positon bewegt
                case States.Camto2:
                    aktuallisiereZeit(gameTime);

                    //Variable wird für nächste Schussphasen zurückgesetzt
                    firedWaffen = 0;

                    //Kamera wird bewegt
                    cameraMovement.move(zeit, 3000, PosX1, level.getSpieler2Pos());

                #region Übergangsbedingungen
                    //Wenn die Spielerposition 2 erreicht wurde startet die Bauphase/Schussphase
                    if (Scene.Camera.Position.X == level.getSpieler2Pos())
                    {
                        //setzt die Variable PosX1 auf die Position bevor er in den nächsten State wechselt
                        PosX1 = Scene.Camera.Position.X;
                        Zeit1 = gameTime.TotalGameTime.Milliseconds + gameTime.TotalGameTime.Seconds * 1000 + gameTime.TotalGameTime.Minutes * 60 * 1000; //Zeit zwischenspeichern
                        aktuallisiereZeit(gameTime);

                        currentState = logik.uebergang(currentState, spieler1, spieler2, level);
                            }
                #endregion

                    break;

                #endregion

                #region Schussphasen
                //Schussphasen
                case States.Schussphase2:
                case States.Schussphase1:

                    aktuallisiereZeit(gameTime);
                    int xR;

                    if (currentState == States.Schussphase1)
                    {
                        gamer = spieler1;
                        xR = 1;
                    }
                    else
                    {
                        gamer = spieler2;
                        xR = -1;
                    }
                    #region Schussfunktion //shoot Funktion TODO: "auslagern"
                    if (gamer.getWaffen() != 0 && !bulletInAir)//Wenn der Spieler Waffen hat
                    {
                        aktuelleWaffe = Objektverwaltung.getWaffe(gamer, firedWaffen);
                        aktuelleWaffe.setWinkel(rHv2n.Y);//Setzt Winkel der Kanone in Waffen

                        if (klickRH)
                        {
                            klickRH = false;
                            float schusswinkel;
                            float x;
                            float y;
                            float velocity;

                            if (aktuelleWaffe.getType()=="Balliste")
                            {
                                Munition="Bolzen";
                            }
                            else if (aktuelleWaffe.getType() == "Kanone")
                            {
                                Munition = "Kugel";
                            }
                            else {
                                Munition = "Crap";
                            }
                            if (Munition =="Kugel")
                            { bullet = new SphereObject(new Vector3(aktuelleWaffe.getPosition().X, aktuelleWaffe.getPosition().Y+2.5f,aktuelleWaffe.getPosition().Z), 0.1f, 10, 10, 0.05f);
                              Scene.Add(bullet);
                            }
                            else if (Munition == "Bolzen")
                            {
                                bolzen = new ModelObject(new Vector3(aktuelleWaffe.getPosition().X, aktuelleWaffe.getPosition().Y + 0.5f, aktuelleWaffe.getPosition().Z), Quaternion.Identity, new Vector3(1, 1, 1), CollisionType.ExactMesh, "", "Bolzen", 0.05f);
                                Scene.Add(bolzen);
                            }

                            schusswinkel = aktuelleWaffe.getWinkel();
                            x=(float)Math.Cos(schusswinkel);
                            y=(float)Math.Sin(schusswinkel);
                            Vector3 shootdirection = new Vector3(x,y,0);

                            velocity = (1-lHv2n.Y) * 10f;
                            if (Munition == "Kugel")
                            {
                                bullet.Physics.LinearVelocity = shootdirection * velocity * xR;
                            }
                            else if (Munition == "Bolzen")
                            {
                                bolzen.Physics.LinearVelocity = shootdirection * velocity * xR;
                            }

                            firedWaffen++;
                            bulletInAir = true;
                        }
                    }

                    if (bulletInAir)
                    {
                        if (Munition == "Kugel")
                        {
                            cameraMovement.chaseBullet(bullet.Position, cam.Position);
                            bullet.Collided += new EventHandler<CollisionArgs>(bulletCollidedHandler);
                        }
                        else if (Munition == "Bolzen")
                        {
                            cameraMovement.chaseBullet(bolzen.Position, cam.Position);
                            bolzen.Collided += new EventHandler<CollisionArgs>(bulletCollidedHandler);
                        }

                        //Partikel Effekte FUNKTIONIERT NOCH NICHT
                        ParticleEffect effect = new ParticleEffect()
                        {
                            Emitters = new EmitterCollection()
                                {
                                    new SphereEmitter
                                    {
                                        Name="Flame",
                                        Budget = 100,
                                        Term = 0.5f,
                                        ReleaseQuantity = 8,
                                        Enabled = true,
                                        ReleaseSpeed = new Range(5f,5f),
                                        ReleaseColour = new ColourRange
                                        {
                                            Red = new Range(0.9f,1f),
                                            Green = new Range(0.5f,0.5f),
                                            Blue = new Range(0f,0f),
                                        },
                                        ReleaseOpacity = new Range(1f,1f),
                                        ReleaseScale = new Range(2f,2f),
                                        ReleaseRotation = new RotationRange
                                        {
                                            Pitch = new Range(0f,0f),
                                            Yaw = new Range(0f,0f),
                                            Roll = new Range(-3.14f,3.14f),
                                        },
                                        ParticleTexture = Core.Content.Load<Texture2D>("Flames"),
                                        BlendMode = EmitterBlendMode.Add,
                                        Radius = 3f,
                                        Shell = true,
                                        Radiate = true,
                                        BillboardStyle = ProjectMercury.BillboardStyle.Spherical,
                                        Modifiers = new ModifierCollection
                                        {
                                            new OpacityInterpolator2
                                            {
                                                InitialOpacity = 0.5f,
                                                FinalOpacity = 0f,
                                            },
                                            new RotationModifier
                                            {
                                                RotationRate = new Vector3(0,0,1)
                                            }
                                        },
                                        Controllers = new ControllerPipeline
                                        {
                                            new CooldownController
                                            {
                                                CooldownPeriod = 0.02f,
                                            },
                                        }
                                    }
                                }
                        };

                        ParticleObject particle = new ParticleObject(bullet.Position, effect);

                    }

                    #endregion

                    #region Übergangsbedingungen
                    //Wenn alle Waffen abgefeuert wurden...
                    if (firedWaffen == gamer.getWaffen())
                    {
                        //setzt die Variable PosX1 auf die Position bevor er in den nächsten State wechselt
                        PosX1 = Scene.Camera.Position.X;
                        Zeit1 = gameTime.TotalGameTime.Milliseconds + gameTime.TotalGameTime.Seconds * 1000 + gameTime.TotalGameTime.Minutes * 60 * 1000; //Zeit zwischenspeichern
                        aktuallisiereZeit(gameTime);

                        currentState = logik.uebergang(currentState, spieler1, spieler2, level);
                            }

                    #endregion

                    break;

                #endregion

                #region End
                //Ende des Spiels
                case States.End:
                    //noch leer

                    //neues Spiel, alle vorherigen Objekte werden gelöscht
                    Scene.RemoveAllSceneObjects();
                    break;

                #endregion

            }

            #region WEITER
            //Wenn sich die rechte Hand in der oberen, rechten Ecke befindet & KLICK -> Klick auf WEITER
            if (rHv2n.X >= 0.9f && rHv2n.Y >= 0.4f && rHv2n.Y <= 0.6f && klickRH)
            {
                klickRH = false;
                showWaffe = false;
                //setzt die Variable PosX1 auf die Position bevor er in den nächsten State wechselt
                PosX1 = Scene.Camera.Position.X;
                Zeit1 = gameTime.TotalGameTime.Milliseconds + gameTime.TotalGameTime.Seconds * 1000 + gameTime.TotalGameTime.Minutes * 60 * 1000; //Zeit zwischenspeichern
                aktuallisiereZeit(gameTime);

                currentState = logik.uebergang(currentState, spieler1, spieler2, level);
                    }
            #endregion

            #region Update Ende

            objState = currentState; //Am Ende jenden Updates wird der State angeglichen

            screenDim = new Vector2(Scene.Game.Window.ClientBounds.Width, Scene.Game.Window.ClientBounds.Height);

            Objektverwaltung.refreshObj(spieler1,spieler2); //Entfernt Objekte ohne LP

            base.Update(gameTime, otherScreenHasFocus, coveredByOtherScreen);

            #endregion
        }
Esempio n. 7
0
 private void Geldanzeige(Spieler spieler)
 {
     string aktuellerText = "$" + spieler.getMoney() ;
     UI2DRenderer.WriteText(new Vector2(Scene.Camera.Position.X+2, Scene.Camera.Position.Y),            //Position
                 aktuellerText,                    //Anzuzeigender Text
                 Color.Red,                   //Textfarbe
                 null,                    //Interne Schriftart verwenden
                 Vector2.One,             //Textskallierung
                 UI2DRenderer.HorizontalAlignment.Left, //Horizontal zentriert
                 UI2DRenderer.VerticalAlignment.Top);  //am unteren Bildschirmrand ausrichten
 }
Esempio n. 8
0
        public static void run(Gamestart.States state, Vector2 rHv2s, Vector2 lHv2s, Vector2 screenDim, bool showWaffe, Spieler spieler1, Spieler spieler2, bool bulletInAir)
        {
            #region Bau/Tex/Waf - Auswahl
            if (state == Gamestart.States.Bauphase1O || state == Gamestart.States.Bauphase1T || state == Gamestart.States.Bauphase2O || state == Gamestart.States.Bauphase2T)
            {
                String bild;
                if (state == Gamestart.States.Bauphase1T || state == Gamestart.States.Bauphase2T)
                {
                    bild = "Material";
                }
                else
                {
                    if (showWaffe)
                    {
                        bild = "Waffenauswahl_transparent";
                    }
                    else
                    {
                        bild = "Bau";
                    }
                }

                Vector2 dim = new Vector2(screenDim.X * 0.5f, screenDim.Y * 0.15f);
                Vector2 pos = new Vector2(dim.X * 0.5f, 5);
                drawBox(pos, dim, bild);

            }
            #endregion

            #region Geldanzeige
            if (state == Gamestart.States.Bauphase1O || state == Gamestart.States.Bauphase1T || state == Gamestart.States.Schussphase1)
            {
                Vector2 pos = new Vector2(1, 1);
                Vector2 dim = screenDim / 800;
                string aktuellerText = "$" + spieler1.getMoney();
                drawText(aktuellerText, Color.Gold, pos, dim);
            }
            if (state == Gamestart.States.Bauphase2O || state == Gamestart.States.Bauphase2T || state == Gamestart.States.Schussphase2)
            {
                Vector2 pos = new Vector2(1, 1);
                Vector2 dim = screenDim / 800;
                string aktuellerText = "$" + spieler2.getMoney();
                drawText(aktuellerText, Color.Gold, pos, dim);
            }
            #endregion

            #region Obj-Waffen Switch
            if (state == Gamestart.States.Bauphase1O || state == Gamestart.States.Bauphase2O)
            {
                String bild;
                if (showWaffe)
                {
                    bild = "Bau";
                }
                else
                {
                    bild = "Waffenauswahl_transparent";
                }

                Vector2 dim = new Vector2(screenDim.X * 0.125f, screenDim.Y * 0.15f);
                Vector2 pos = new Vector2((screenDim.X * 0.875f) - 5, 5);
                drawBox(pos, dim, bild);
            }
            #endregion

            #region Weiterbutton
            if (state == Gamestart.States.Bauphase1O || state == Gamestart.States.Bauphase2O)
            {
                Vector2 dim = new Vector2((screenDim.X * 0.09f), (screenDim.Y * 0.09f));
                Vector2 pos = new Vector2(screenDim.X - dim.X - screenDim.X * 0.01f, screenDim.Y * 0.45f);
                drawBox(pos, dim, "weiter2");
            }
            #endregion

            #region Poweranzeige
            if (state == Gamestart.States.Schussphase1 || state == Gamestart.States.Schussphase2 /* && !bulletInAir*/ || state == Gamestart.States.Bauphase1O)
            {
                float pro;
                if (lHv2s.Y < 0.15f * screenDim.Y)
                {
                    pro = 0.15f * screenDim.Y;
                }
                else if (lHv2s.Y > 0.95f * screenDim.Y)
                {
                    pro = 0.95f * screenDim.Y;
                }
                else
                {
                    pro = lHv2s.Y;
                }

                Vector2 pos1 = new Vector2(screenDim.X * 0.01f, screenDim.Y * 0.15f);
                Vector2 pos2 = new Vector2(screenDim.X * 0.01f, pro);
                Vector2 dim1 = new Vector2(screenDim.X * 0.05f, pro);
                Vector2 dim2 = new Vector2(screenDim.X * 0.05f, screenDim.Y * 0.95f - pro);

                drawBox(pos1, dim1, Color.Green);
                drawBox(pos2, dim2, Color.Red);
            }
            #endregion

            #region Geldfliegen
            if (prozent > 0)
            {
                Color farbe = (change > 0) ? Color.Green : Color.Red;
                String text = (change > 0) ? "+" + change.ToString() : change.ToString();
                Vector2 pos = from * prozent / 100;
                Vector2 dim = new Vector2(0.05f * prozent, 0.05f * prozent);
                drawText(text, farbe, pos, dim);
                prozent--;
            }
            #endregion

            #region Handpos
            if (state == Gamestart.States.Bauphase1O || state == Gamestart.States.Bauphase1T || state == Gamestart.States.Bauphase2O || state == Gamestart.States.Bauphase2T)
            {
                Handkreise(rHv2s, lHv2s);
            }
            #endregion
        }
Esempio n. 9
0
 public static void setmoney(Spieler spieler, int money, Vector2 pos)
 {
     spieler.setMoney(spieler.getMoney() + money);
     change = money;
     from = pos;
     prozent = 100;
 }
        public static Waffen createWaffe(int auswahl, Spieler spieler, Vector3 posi)//TODO
        {
            Controller newcon;
            RevoluteJoint revolute;
            Waffen dasobj;
            Vector3 startort = new Vector3(posi.X,posi.Y, -5f);

            if (auswahl == 1)//Kanone
            {
                Vector3 diff = new Vector3(0.095f, 0.1828f, 0);
                ModelObject Kanonenrohr = new ModelObject(startort + diff, Quaternion.Identity, new Vector3(0.1f, 0.1f, 0.1f), CollisionType.ExactMesh, " ", "Kanonenrohr", 0.001f);
                Kanonenrohr.RenderMaterial.Diffuse = new Vector4(1, 1, 1, 1);
                scene.Add(Kanonenrohr);

                ModelObject Kanonenhalterung = new ModelObject(startort, Quaternion.Identity, new Vector3(0.1f, 0.1f, 0.1f), CollisionType.ExactMesh, " ", "Kanonenhalterung", 1f);
                Kanonenhalterung.RenderMaterial.Diffuse = new Vector4(1, 1, 1, 1);
                scene.Add(Kanonenhalterung);

                newcon = new Controller(new Vector3(0, 0, 0));// Neuer Controller an der Position 0/0/0
                newcon.Add(Kanonenrohr);
                newcon.Add(Kanonenhalterung);

                revolute = new RevoluteJoint(Kanonenhalterung.Physics, Kanonenrohr.Physics, Kanonenhalterung.Position + new Vector3(0, 1, 0), Vector3.Backward);
                /*revolute.Limit.IsActive = true;
                revolute.Limit.MinimumAngle = -MathHelper.Pi;
                revolute.Limit.MaximumAngle = 0;*/
                scene.Physics.Add(revolute);

                revolute.Motor.IsActive = true;
                revolute.Motor.Settings.Mode = BEPUphysics.Constraints.TwoEntity.Motors.MotorMode.Servomechanism;
                revolute.Motor.Settings.Servo.Goal = -MathHelper.Pi / 4;
            }
            else //TEMPORÄR
            {
                BoxObject Box = new BoxObject(startort, new Vector3(0.4f, 0.25f, 0.3f), 0.001f);
                scene.Add(Box);//Standbox

                BoxObject Lat = new BoxObject(startort + new Vector3(0 , 0.35f , 0), new Vector3(0.35f, 0.1f, 0.1f), 0.00001f);
                scene.Add(Lat);//KanonenRohr

                newcon = new Controller(startort);
                newcon.Add(Box);
                newcon.Add(Lat);
                scene.Add(newcon);

                revolute = new RevoluteJoint(Box.Physics, Lat.Physics, Box.Position + new Vector3(0, 0.32f, 0), Vector3.Backward);
                /*revolute.Limit.IsActive = true;
                revolute.Limit.MinimumAngle = -MathHelper.Pi;
                revolute.Limit.MaximumAngle = 0;*/
                scene.Physics.Add(revolute);

                revolute.Motor.IsActive = true;
                revolute.Motor.Settings.Mode = BEPUphysics.Constraints.TwoEntity.Motors.MotorMode.Servomechanism;
                revolute.Motor.Settings.Servo.Goal = MathHelper.Pi / 6;
                
            }

            //TODO z-Achse sperren

            
            //scene.Add(newcon);
            dasobj = new Waffen( newcon, revolute, 1, (float)Math.PI / 4, 5f);
            spieler.setWaffen(dasobj);
            return dasobj;

        }
        public static void refreshObj(Spieler spieler1, Spieler spieler2)
        {
            foreach (Objekte temp in objListe)
            {
                if (temp.getLP() <= 0)
                {
                    scene.Remove(temp.getSceneObject()); //Löscht Objekte aus Scene
                }
            }

            objListe.RemoveAll(x => x.getLP() <= 0); //Löscht Objekte aus Liste

            foreach (Waffen temp in spieler1.getList())
            {
                if (temp.getLP() <= 0)
                {
                    scene.Remove(temp.getController());
                    spieler1.resetWaffen(temp);
                }
            }

            foreach (Waffen temp in spieler2.getList())
            {
                if (temp.getLP() <= 0)
                {
                    scene.Remove(temp.getController());
                    spieler2.resetWaffen(temp);
                }
            }
           
        }
 public static Waffen getWaffe(Spieler spieler, int firedwappons)
 {
     //firedwappons = 0 ==> erste Waffe
    
      return spieler.getList()[firedwappons]; 
     // TODO darf nur zurück geben wenn es noch unabgefeuerte Waffen gibt sonst -> exception!    
     
     // TODO darf nur zurück geben wenn es noch unabgefeuerte Waffen gibt sonst -> exception!           
 }
Esempio n. 13
0
        //TODO
        public static Waffen createWaffe(int auswahl, Spieler spieler, Vector2 posi)
        {
            Waffen dasobj;
            Vector3 startort = new Vector3(posi, -5f);
            Matrix rotationKanone;
            rotationKanone= Matrix.CreateRotationY( (float) Math.PI);
            Quaternion AP;
            if (posi.X > 0) //-->Spieler 2
            {
                AP = Quaternion.CreateFromRotationMatrix(rotationKanone);
            }
            else
            {
                AP = Quaternion.Identity;
            }

            if (auswahl == 1)
            {

                ModelObject Kanone = new ModelObject(startort, AP, new Vector3(1f, 1f, 1f), CollisionType.ExactMesh, " ", "Kanone_ganz", 0.1f);
                Kanone.SubModels[0].RenderMaterial.Diffuse = new Vector4(1, 1, 1, 1);
                Kanone.SubModels[1].RenderMaterial.Diffuse = new Vector4(1, 1, 1, 1);
                Kanone.SubModels[0].RenderMaterial.Specular = new Vector4(0.1f, 0.1f, 0.1f, 1);
                Kanone.SubModels[1].RenderMaterial.Specular = new Vector4(0.1f, 0.1f, 0.1f, 1);

                Kanone.SubModels[0].Physics.Mass = 1f;
                Kanone.SubModels[1].Physics.Mass = 1f;

                Kanone.Physics.Material.Bounciness = 0;
                scene.Add(Kanone);
                //TODO Kosten?

                dasobj = new Waffen(Kanone, 1, (float)Math.PI / 4, 5f,"Kanone");
                spieler.setWaffen(dasobj);
                return dasobj;
            }
            if (auswahl == 2||auswahl==3)
            {

                ModelObject Balliste = new ModelObject(startort, AP, new Vector3(1f, 1f, 1f), CollisionType.ConvexHull, " ", "Balliste", 0.1f);
                Balliste.SubModels[0].RenderMaterial.Diffuse = new Vector4(1, 1, 1, 1);
                Balliste.SubModels[1].RenderMaterial.Diffuse = new Vector4(1, 1, 1, 1);
                Balliste.SubModels[0].RenderMaterial.Specular = new Vector4(0.1f, 0.1f, 0.1f, 1);
                Balliste.SubModels[1].RenderMaterial.Specular = new Vector4(0.1f, 0.1f, 0.1f, 1);

                Balliste.SubModels[0].Physics.Mass = 1f;
                Balliste.SubModels[1].Physics.Mass = 1f;

                Balliste.Physics.Material.Bounciness = 0;
                scene.Add(Balliste);

                //TODO Kosten?

                dasobj = new Waffen(Balliste, 1, (float)Math.PI / 4, 5f,"Balliste");
                spieler.setWaffen(dasobj);
                return dasobj;
            }
            if (auswahl == 4)
            {

                ModelObject Rakete = new ModelObject(startort, AP, new Vector3(1f, 1f, 1f), CollisionType.ConvexHull, " ", "Rakete", 0.1f);
                Rakete.SubModels[0].RenderMaterial.Diffuse = new Vector4(1, 1, 1, 1);

                Rakete.SubModels[0].RenderMaterial.Specular = new Vector4(0.1f, 0.1f, 0.1f, 1);

                Rakete.SubModels[0].Physics.Mass = 1f;

                Rakete.Physics.Material.Bounciness = 0;
                scene.Add(Rakete);

                //TODO Kosten?

                dasobj = new Waffen(Rakete, 1, (float)Math.PI / 4, 5f, "Rakete");
                spieler.setWaffen(dasobj);
                return dasobj;
            }
            else
            {
                ModelObject König = new ModelObject(startort, AP, new Vector3(1f, 1f, 1f), CollisionType.BoundingSphere, " ", "König_Subdivision", 0.1f);
                König.SubModels[0].RenderMaterial.Diffuse = new Vector4(1, 1, 1, 1);
                König.SubModels[0].RenderMaterial.Specular = new Vector4(0.1f, 0.1f, 0.1f, 1);

                König.SubModels[0].Physics.Mass = 0.001f;
                König.SubModels[1].Physics.Mass = 0.001f;

                scene.Add(König);
                dasobj = new Waffen(König, 1, (float)Math.PI / 4, 5f,"König");
                spieler.setWaffen(dasobj);
                return dasobj;
            }
        }