Ejemplo n.º 1
0
        public void Update(GameTime gameTime, ref Character player, ref LoadSave saveAndLoadGame, ref int floor, ref  List<Enemy> enemies, ref PositionManager[, ,] positionManager, ref float hpBarBredd
            , ref bool playmenumusic, ref bool playingamemusic, Cue IngameTGU, ref LevelManager levelManager, ref bool attackDone, ref bool attackDone2
            , ref bool attackDoneMiss, SoundBank soundBank, Cue attackHit, Cue attackMiss, ref Attack attack2, ref int playerDamgeDelt
            , ref Rectangle hpBarPos, List<GameObj> objects, Texture2D tileset)
        {
            KeyboardState ks = Keyboard.GetState();

            //Hp och hpbar uträkningar test
            Random tal = new Random();

            //När en attack är klar sätts dessa till true
            if (attackDone == true)    //Gör så att man enbart kan genomföra en atack åt gången
            {
                attackDone2 = true;
                attackDoneMiss = true;
            }

            //Rörelse via tangentbordskontroller
            if (ks.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.D)) //Knapptryckning för att röra sig till höger
            {
                if (player.moveCharRight == false && player.allowButtonPress == true)  //Gör så att man enbart kan genomföra en ny rörelse om karaktären för tillfället inte rör sig åt något håll
                {
                    player.Frame = 6;   //sätter framen till det håll man försöker gå åt, ifall det är en vägg ivägen körs inte animationen men karaktären vänder sig mot väggen

                    if (positionManager[player.playerPosY, player.playerPosX + 1, floor].type == "enemy")
                    {
                        if (attackDone == true)    //Gör så att man enbart kan genomföra en atack åt gången
                        {
                            for (int i = 0; i < enemies.Count; i++)   //Kollar igenom alla fiender
                            {
                                if (enemies[i].xCoord == player.playerPosX + 1 && enemies[i].yCoord == player.playerPosY)
                                {

                                    attackDone = false;
                                    player.allowButtonPress = false; //Gör så man ej kan göra någon annan rörelse eller attack medans man genomför nuvarande attack

                                    attack2.attackPos = new Vector2(player.playerPosX + 1, player.playerPosY);
                                    attack2.Position = new Vector2(attack2.attackPos.X * 64, attack2.attackPos.Y * 64);   //Ritar ut attackanimationen i rätt ruta

                                    int hpBefore = enemies[i].hp;   //Fiendens hp innan utförd attack
                                    enemies[i].hp -= attack2.CharAttackCalc(player.Totstr, enemies[i].dex);   //Kör spelarens attackuträkning på fienden
                                    int hpAfter = enemies[i].hp;   //Fiendens hp efter attack

                                    playerDamgeDelt = hpBefore - hpAfter;   //Skadan som fienden tog

                                    player.allowButtonPress = true;   //Gör att man får trycka på en knapp igen
                                    if (hpBefore == hpAfter)   //Då har attacken missat
                                    {
                                        attackDoneMiss = false;   //Gör att texten för miss ritas ut
                                        attackDone2 = true;
                                        soundBank.PlayCue("AttackMiss");   //Spelar upp ljud för miss
                                    }
                                    else if (hpBefore != hpAfter)   //Ifall attacken träffar
                                    {
                                        attackDoneMiss = true;
                                        attackDone2 = false;   //gör så att attackanimationen får ritas ut
                                        soundBank.PlayCue("AttackSound");   //Spelar upp ljud för träff
                                    }

                                    if (enemies[i].hp <= 0)   //Ifall fienden dör
                                    {

                                        positionManager[player.playerPosY, player.playerPosX + 1, floor].type = "empty";   //Sätter positionen den var på till empty

                                        player.Xp += enemies[i].ReturnExp();
                                        enemies.RemoveAt(i);  //Tar bort fienden

                                        if (player.Xp >= player.XpToLevel)   //Gör så att man går upp i level
                                        {
                                            player.LevelUp(ref hpBarPos.Width);   //Återställer spelarens hpbar

                                        }
                                    }
                                }
                                else if (enemies[i].xCoord != player.playerPosX + 1 || enemies[i].yCoord != player.playerPosY)
                                {

                                }
                            }
                        }
                    }

                    else if (positionManager[player.playerPosY, player.playerPosX + 1, floor].type != "wall")   //Kollar om det är en vägg framför karaktären, om detta är fallet utförs ingen rörelse
                    {
                        player.moveCharRight = true;    //Gör så att man rör sig åt höger
                        player.allowButtonPress = false;    //Gör så att man inte kan trycka på någon annan knapp medans en rörelse genomförs
                        player.playerPosX += 1;

                    }

                }
            }
            if (ks.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.A)) //Knapptryckning för att röra sig till vänster
            {
                if (player.moveCharLeft == false && player.allowButtonPress == true)  //Gör så att man enbart kan genomföra en ny rörelse om karaktären för tillfället inte rör sig åt något håll
                {
                    player.Frame = 3;  //sätter framen till det håll man försöker gå åt, ifall det är en vägg ivägen körs inte animationen men karaktären vänder sig mot väggen
                    if (positionManager[player.playerPosY, player.playerPosX - 1, floor].type == "enemy")
                    {
                        if (attackDone == true)    //Gör så att man enbart kan genomföra en atack åt gången
                        {
                            for (int i = 0; i < enemies.Count; i++)   //Kollar igenom alla fiender
                            {
                                if (enemies[i].xCoord == player.playerPosX - 1 && enemies[i].yCoord == player.playerPosY)
                                {

                                    attackDone = false;
                                    player.allowButtonPress = false; //Gör så man ej kan göra någon annan rörelse eller attack medans man genomför nuvarande attack
                                    attack2.attackPos = new Vector2(player.playerPosX - 1, player.playerPosY);
                                    attack2.Position = new Vector2(attack2.attackPos.X * 64, attack2.attackPos.Y * 64);   //Ritar ut attackanimationen i rätt ruta

                                    int hpBefore = enemies[i].hp;   //Fiendens hp innan utförd attack
                                    enemies[i].hp -= attack2.CharAttackCalc(player.Totstr, enemies[i].dex);   //Kör spelarens attackuträkning på fienden
                                    int hpAfter = enemies[i].hp;   //Fiendens hp efter attack

                                    playerDamgeDelt = hpBefore - hpAfter;   //Skadan som fienden tog

                                    player.allowButtonPress = true;   //Gör att man får trycka på en knapp igen
                                    if (hpBefore == hpAfter)   //Då har attacken missat
                                    {
                                        attackDoneMiss = false;   //Gör att texten för miss ritas ut
                                        attackDone2 = true;
                                        soundBank.PlayCue("AttackMiss");   //Spelar upp ljud för miss
                                    }
                                    else if (hpBefore != hpAfter)   //Ifall attacken träffar
                                    {
                                        attackDoneMiss = true;
                                        attackDone2 = false;   //gör så att attackanimationen får ritas ut
                                        soundBank.PlayCue("AttackSound");   //Spelar upp ljud för träff
                                    }

                                    if (enemies[i].hp <= 0)   //Ifall fienden dör
                                    {

                                        positionManager[player.playerPosY, player.playerPosX - 1, floor].type = "empty";
                                        player.Xp += enemies[i].ReturnExp();
                                        enemies.RemoveAt(i);  //Tar bort fienden
                                        if (player.Xp >= player.XpToLevel)   //Gör så att man går upp i level
                                        {
                                            player.LevelUp(ref hpBarPos.Width);   //Återställer spelarens hpbar
                                        }
                                    }
                                }
                                else if (enemies[i].xCoord != player.playerPosX + 1 || enemies[i].yCoord != player.playerPosY)
                                {

                                }
                            }
                        }
                    }

                    else if (positionManager[player.playerPosY, player.playerPosX - 1, floor].type != "wall")   //Kollar om det är en vägg framför karaktären, om detta är fallet utförs ingen rörelse
                    {
                        player.moveCharLeft = true;    //Gör så att man rör sig åt vänster

                        player.allowButtonPress = false;   //Gör så att man inte kan trycka på någon annan knapp medans en rörelse genomförs
                        player.playerPosX -= 1;
                    }
                }
            }
            if (ks.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.W)) //Knapptryckning för att röra sig upp
            {
                if (player.moveCharUp == false && player.allowButtonPress == true)    //Gör så att man enbart kan genomföra en ny rörelse om karaktären för tillfället inte rör sig åt något håll
                {
                    player.Frame = 9;  //sätter framen till det håll man försöker gå åt, ifall det är en vägg ivägen körs inte animationen men karaktären vänder sig mot väggen
                    if (positionManager[player.playerPosY - 1, player.playerPosX, floor].type == "enemy")
                    {
                        if (attackDone == true)    //Gör så att man enbart kan genomföra en atack åt gången
                        {
                            for (int i = 0; i < enemies.Count; i++)   //Kollar igenom alla fiender
                            {
                                if (enemies[i].xCoord == player.playerPosX && enemies[i].yCoord == player.playerPosY - 1)
                                {

                                    attackDone = false;
                                    player.allowButtonPress = false; //Gör så man ej kan göra någon annan rörelse eller attack medans man genomför nuvarande attack
                                    attack2.attackPos = new Vector2(player.playerPosX, player.playerPosY - 1);
                                    attack2.Position = new Vector2(attack2.attackPos.X * 64, attack2.attackPos.Y * 64);   //Ritar ut attackanimationen i rätt ruta

                                    int hpBefore = enemies[i].hp;   //Fiendens hp innan utförd attack
                                    enemies[i].hp -= attack2.CharAttackCalc(player.Totstr, enemies[i].dex);   //Kör spelarens attackuträkning på fienden
                                    int hpAfter = enemies[i].hp;   //Fiendens hp efter attack

                                    playerDamgeDelt = hpBefore - hpAfter;   //Skadan som fienden tog

                                    player.allowButtonPress = true;   //Gör att man får trycka på en knapp igen
                                    if (hpBefore == hpAfter)   //Då har attacken missat
                                    {
                                        attackDoneMiss = false;   //Gör att texten för miss ritas ut
                                        attackDone2 = true;
                                        soundBank.PlayCue("AttackMiss");   //Spelar upp ljud för miss
                                    }
                                    else if (hpBefore != hpAfter)   //Ifall attacken träffar
                                    {
                                        attackDoneMiss = true;
                                        attackDone2 = false;   //gör så att attackanimationen får ritas ut
                                        soundBank.PlayCue("AttackSound");   //Spelar upp ljud för träff
                                    }

                                    if (enemies[i].hp <= 0)   //Ifall fienden dör
                                    {
                                        positionManager[player.playerPosY - 1, player.playerPosX, floor].type = "empty";
                                        player.Xp += enemies[i].ReturnExp();
                                        enemies.RemoveAt(i);  //Tar bort fienden
                                        if (player.Xp >= player.XpToLevel)   //Gör så att man går upp i level
                                        {
                                            player.LevelUp(ref hpBarPos.Width);   //Återställer spelarens hpbar
                                        }
                                    }
                                }
                                else if (enemies[i].xCoord != player.playerPosX + 1 || enemies[i].yCoord != player.playerPosY)
                                {

                                }
                            }
                        }
                    }

                    else if (positionManager[player.playerPosY - 1, player.playerPosX, floor].type != "wall")   //Kollar om det är en vägg framför karaktären, om detta är fallet utförs ingen rörelse
                    {
                        player.moveCharUp = true;  //Gör så att man rör sig upp

                        player.allowButtonPress = false;   //Gör så att man inte kan trycka på någon annan knapp medans en rörelse genomförs
                        player.playerPosY -= 1;
                    }
                }
            }
            if (ks.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.S))  //Knapptryckning för att röra sig ner
            {
                if (player.moveCharDown == false && player.allowButtonPress == true)  //Gör så att man enbart kan genomföra en ny rörelse om karaktären för tillfället inte rör sig åt något håll
                {
                    player.Frame = 0; //sätter framen till det håll man försöker gå åt, ifall det är en vägg ivägen körs inte animationen men karaktären vänder sig mot väggen

                    if (positionManager[player.playerPosY + 1, player.playerPosX, floor].type == "enemy")
                    {
                        if (attackDone == true)    //Gör så att man enbart kan genomföra en atack åt gången
                        {
                            for (int i = 0; i < enemies.Count; i++)   //Kollar igenom alla fiender
                            {
                                if (enemies[i].xCoord == player.playerPosX && enemies[i].yCoord == player.playerPosY + 1)
                                {

                                    attackDone = false;
                                    player.allowButtonPress = false; //Gör så man ej kan göra någon annan rörelse eller attack medans man genomför nuvarande attack
                                    attack2.attackPos = new Vector2(player.playerPosX, player.playerPosY + 1);
                                    attack2.Position = new Vector2(attack2.attackPos.X * 64, attack2.attackPos.Y * 64);   //Ritar ut attackanimationen i rätt ruta

                                    int hpBefore = enemies[i].hp;   //Fiendens hp innan utförd attack
                                    enemies[i].hp -= attack2.CharAttackCalc(player.Totstr, enemies[i].dex);   //Kör spelarens attackuträkning på fienden
                                    int hpAfter = enemies[i].hp;   //Fiendens hp efter attack

                                    playerDamgeDelt = hpBefore - hpAfter;   //Skadan som fienden tog

                                    player.allowButtonPress = true;   //Gör att man får trycka på en knapp igen
                                    if (hpBefore == hpAfter)   //Då har attacken missat
                                    {
                                        attackDoneMiss = false;   //Gör att texten för miss ritas ut
                                        attackDone2 = true;
                                        soundBank.PlayCue("AttackMiss");   //Spelar upp ljud för miss
                                    }
                                    else if (hpBefore != hpAfter)   //Ifall attacken träffar
                                    {
                                        attackDoneMiss = true;
                                        attackDone2 = false;   //gör så att attackanimationen får ritas ut
                                        soundBank.PlayCue("AttackSound");   //Spelar upp ljud för träff
                                    }

                                    if (enemies[i].hp <= 0)   //Ifall fienden dör
                                    {

                                        positionManager[player.playerPosY + 1, player.playerPosX, floor].type = "empty";
                                        player.Xp += enemies[i].ReturnExp();
                                        enemies.RemoveAt(i);  //Tar bort fienden
                                        if (player.Xp >= player.XpToLevel)   //Gör så att man går upp i level
                                        {
                                            player.LevelUp(ref hpBarPos.Width);   //Återställer spelarens hpbar
                                        }
                                    }
                                }
                                else if (enemies[i].xCoord != player.playerPosX + 1 || enemies[i].yCoord != player.playerPosY)
                                {

                                }
                            }
                        }
                    }

                    else if (positionManager[player.playerPosY + 1, player.playerPosX, floor].type != "wall")   //Kollar om det är en vägg framför karaktären, om detta är fallet utförs ingen rörelse
                    {
                        player.moveCharDown = true;    //Gör så att man rör sig ner

                        player.allowButtonPress = false;   //Gör så att man inte kan trycka på någon annan knapp medans en rörelse genomförs
                        player.playerPosY += 1;
                    }

                }
            }
            prevKs = ks;

            //Rörelse via musklick
            MouseState mousestate1 = Mouse.GetState();
            var mouseposition = new Point(mousestate1.X, mousestate1.Y);
            Rectangle moveUpBox = new Rectangle(400 - 28, 294 - 28, 56, 56);
            Rectangle moveDownBox = new Rectangle(400 - 28, 406 - 28, 56, 56);
            Rectangle moveLeftBox = new Rectangle(344 - 28, 350 - 28, 56, 56);
            Rectangle moveRightBox = new Rectangle(456 - 28, 350 - 28, 56, 56);

            if (mousestate1.RightButton == (Microsoft.Xna.Framework.Input.ButtonState.Released) && prevMs1.RightButton == (Microsoft.Xna.Framework.Input.ButtonState.Pressed))
            {
                if (moveUpBox.Contains(mouseposition))
                {
                    if (player.moveCharUp == false && player.allowButtonPress == true)    //Gör så att man enbart kan genomföra en ny rörelse om karaktären för tillfället inte rör sig åt något håll
                    {
                        player.Frame = 9;  //sätter framen till det håll man försöker gå åt, ifall det är en vägg ivägen körs inte animationen men karaktären vänder sig mot väggen
                        if (positionManager[player.playerPosY - 1, player.playerPosX, floor].type == "enemy")
                        {
                            if (attackDone == true)    //Gör så att man enbart kan genomföra en atack åt gången
                            {
                                for (int i = 0; i < enemies.Count; i++)   //Kollar igenom alla fiender
                                {
                                    if (enemies[i].xCoord == player.playerPosX && enemies[i].yCoord == player.playerPosY - 1)
                                    {

                                        attackDone = false;
                                        player.allowButtonPress = false; //Gör så man ej kan göra någon annan rörelse eller attack medans man genomför nuvarande attack
                                        attack2.attackPos = new Vector2(player.playerPosX, player.playerPosY - 1);
                                        attack2.Position = new Vector2(attack2.attackPos.X * 64, attack2.attackPos.Y * 64);   //Ritar ut attackanimationen i rätt ruta

                                        int hpBefore = enemies[i].hp;   //Fiendens hp innan utförd attack
                                        enemies[i].hp -= attack2.CharAttackCalc(player.Totstr, enemies[i].dex);   //Kör spelarens attackuträkning på fienden
                                        int hpAfter = enemies[i].hp;   //Fiendens hp efter attack

                                        playerDamgeDelt = hpBefore - hpAfter;   //Skadan som fienden tog

                                        player.allowButtonPress = true;   //Gör att man får trycka på en knapp igen
                                        if (hpBefore == hpAfter)   //Då har attacken missat
                                        {
                                            attackDoneMiss = false;   //Gör att texten för miss ritas ut
                                            attackDone2 = true;
                                            soundBank.PlayCue("AttackMiss");   //Spelar upp ljud för miss
                                        }
                                        else if (hpBefore != hpAfter)   //Ifall attacken träffar
                                        {
                                            attackDoneMiss = true;
                                            attackDone2 = false;   //gör så att attackanimationen får ritas ut
                                            soundBank.PlayCue("AttackSound");   //Spelar upp ljud för träff
                                        }

                                        if (enemies[i].hp <= 0)   //Ifall fienden dör
                                        {

                                            positionManager[player.playerPosY - 1, player.playerPosX, floor].type = "empty";
                                            player.Xp += enemies[i].ReturnExp();
                                            enemies.RemoveAt(i);  //Tar bort fienden
                                            if (player.Xp >= player.XpToLevel)   //Gör så att man går upp i level
                                            {
                                                player.LevelUp(ref hpBarPos.Width);   //Återställer spelarens hpbar
                                            }
                                        }
                                    }
                                    else if (enemies[i].xCoord != player.playerPosX + 1 || enemies[i].yCoord != player.playerPosY)
                                    {

                                    }
                                }
                            }
                        }

                        else if (positionManager[player.playerPosY - 1, player.playerPosX, floor].type != "wall")   //Kollar om det är en vägg framför karaktären, om detta är fallet utförs ingen rörelse
                        {
                            player.moveCharUp = true;  //Gör så att man rör sig upp

                            player.allowButtonPress = false;   //Gör så att man inte kan trycka på någon annan knapp medans en rörelse genomförs
                            player.playerPosY -= 1;
                        }
                    }
                }
            }

            if (mousestate1.RightButton == (Microsoft.Xna.Framework.Input.ButtonState.Released) && prevMs1.RightButton == (Microsoft.Xna.Framework.Input.ButtonState.Pressed))
            {
                if (moveDownBox.Contains(mouseposition))
                {
                    if (player.moveCharDown == false && player.allowButtonPress == true)  //Gör så att man enbart kan genomföra en ny rörelse om karaktären för tillfället inte rör sig åt något håll
                    {
                        player.Frame = 0; //sätter framen till det håll man försöker gå åt, ifall det är en vägg ivägen körs inte animationen men karaktären vänder sig mot väggen

                        if (positionManager[player.playerPosY + 1, player.playerPosX, floor].type == "enemy")
                        {
                            if (attackDone == true)    //Gör så att man enbart kan genomföra en atack åt gången
                            {
                                for (int i = 0; i < enemies.Count; i++)   //Kollar igenom alla fiender
                                {
                                    if (enemies[i].xCoord == player.playerPosX && enemies[i].yCoord == player.playerPosY + 1)
                                    {

                                        attackDone = false;
                                        player.allowButtonPress = false; //Gör så man ej kan göra någon annan rörelse eller attack medans man genomför nuvarande attack
                                        attack2.attackPos = new Vector2(player.playerPosX, player.playerPosY + 1);
                                        attack2.Position = new Vector2(attack2.attackPos.X * 64, attack2.attackPos.Y * 64);   //Ritar ut attackanimationen i rätt ruta

                                        int hpBefore = enemies[i].hp;   //Fiendens hp innan utförd attack
                                        enemies[i].hp -= attack2.CharAttackCalc(player.Totstr, enemies[i].dex);   //Kör spelarens attackuträkning på fienden
                                        int hpAfter = enemies[i].hp;   //Fiendens hp efter attack

                                        playerDamgeDelt = hpBefore - hpAfter;   //Skadan som fienden tog

                                        player.allowButtonPress = true;   //Gör att man får trycka på en knapp igen
                                        if (hpBefore == hpAfter)   //Då har attacken missat
                                        {
                                            attackDoneMiss = false;   //Gör att texten för miss ritas ut
                                            attackDone2 = true;
                                            soundBank.PlayCue("AttackMiss");   //Spelar upp ljud för miss
                                        }
                                        else if (hpBefore != hpAfter)   //Ifall attacken träffar
                                        {
                                            attackDoneMiss = true;
                                            attackDone2 = false;   //gör så att attackanimationen får ritas ut
                                            soundBank.PlayCue("AttackSound");   //Spelar upp ljud för träff
                                        }

                                        if (enemies[i].hp <= 0)   //Ifall fienden dör
                                        {

                                            positionManager[player.playerPosY + 1, player.playerPosX, floor].type = "empty";
                                            player.Xp += enemies[i].ReturnExp();
                                            enemies.RemoveAt(i);  //Tar bort fienden
                                            if (player.Xp >= player.XpToLevel)   //Gör så att man går upp i level
                                            {
                                                player.LevelUp(ref hpBarPos.Width);   //Återställer spelarens hpbar
                                            }
                                        }
                                    }
                                    else if (enemies[i].xCoord != player.playerPosX + 1 || enemies[i].yCoord != player.playerPosY)
                                    {

                                    }
                                }
                            }
                        }

                        else if (positionManager[player.playerPosY + 1, player.playerPosX, floor].type != "wall")   //Kollar om det är en vägg framför karaktären, om detta är fallet utförs ingen rörelse
                        {
                            player.moveCharDown = true;    //Gör så att man rör sig ner

                            player.allowButtonPress = false;   //Gör så att man inte kan trycka på någon annan knapp medans en rörelse genomförs
                            player.playerPosY += 1;
                        }

                    }
                }
            }

            if (mousestate1.RightButton == (Microsoft.Xna.Framework.Input.ButtonState.Released) && prevMs1.RightButton == (Microsoft.Xna.Framework.Input.ButtonState.Pressed))
            {
                if (moveLeftBox.Contains(mouseposition))
                {
                    if (player.moveCharLeft == false && player.allowButtonPress == true)  //Gör så att man enbart kan genomföra en ny rörelse om karaktären för tillfället inte rör sig åt något håll
                    {
                        player.Frame = 3;  //sätter framen till det håll man försöker gå åt, ifall det är en vägg ivägen körs inte animationen men karaktären vänder sig mot väggen
                        if (positionManager[player.playerPosY, player.playerPosX + 1, floor].type == "enemy")
                        {
                            if (attackDone == true)    //Gör så att man enbart kan genomföra en atack åt gången
                            {
                                for (int i = 0; i < enemies.Count; i++)   //Kollar igenom alla fiender
                                {
                                    if (enemies[i].xCoord == player.playerPosX + 1 && enemies[i].yCoord == player.playerPosY)
                                    {

                                        attackDone = false;
                                        player.allowButtonPress = false; //Gör så man ej kan göra någon annan rörelse eller attack medans man genomför nuvarande attack

                                        int hpBefore = enemies[i].hp;   //Fiendens hp innan utförd attack
                                        enemies[i].hp -= attack2.CharAttackCalc(player.Totstr, enemies[i].dex);   //Kör spelarens attackuträkning på fienden
                                        int hpAfter = enemies[i].hp;   //Fiendens hp efter attack

                                        playerDamgeDelt = hpBefore - hpAfter;   //Skadan som fienden tog

                                        player.allowButtonPress = true;   //Gör att man får trycka på en knapp igen
                                        if (hpBefore == hpAfter)   //Då har attacken missat
                                        {
                                            attackDoneMiss = false;   //Gör att texten för miss ritas ut
                                            attackDone2 = true;
                                            soundBank.PlayCue("AttackMiss");   //Spelar upp ljud för miss
                                        }
                                        else if (hpBefore != hpAfter)   //Ifall attacken träffar
                                        {
                                            attackDoneMiss = true;
                                            attackDone2 = false;   //gör så att attackanimationen får ritas ut
                                            soundBank.PlayCue("AttackSound");   //Spelar upp ljud för träff
                                        }
                                        if (enemies[i].hp <= 0)   //Ifall fienden dör
                                        {

                                            positionManager[player.playerPosY, player.playerPosX + 1, floor].type = "empty";   //Sätter positionen den var på till empty

                                            player.Xp += enemies[i].ReturnExp();
                                            enemies.RemoveAt(i);  //Tar bort fienden
                                            if (player.Xp >= player.XpToLevel)   //Gör så att man går upp i level
                                            {
                                                player.LevelUp(ref hpBarPos.Width);   //Återställer spelarens hpbar
                                            }
                                        }
                                    }
                                    else if (enemies[i].xCoord != player.playerPosX + 1 || enemies[i].yCoord != player.playerPosY)
                                    {

                                    }
                                }
                            }
                        }
                        else if (positionManager[player.playerPosY, player.playerPosX - 1, floor].type != "wall")   //Kollar om det är en vägg framför karaktären, om detta är fallet utförs ingen rörelse
                        {
                            player.moveCharLeft = true;    //Gör så att man rör sig åt vänster

                            player.playerPosX -= 1;
                            player.allowButtonPress = false;   //Gör så att man inte kan trycka på någon annan knapp medans en rörelse genomförs
                        }
                    }
                }
            }

            if (mousestate1.RightButton == (Microsoft.Xna.Framework.Input.ButtonState.Released) && prevMs1.RightButton == (Microsoft.Xna.Framework.Input.ButtonState.Pressed))
            {
                if (moveRightBox.Contains(mouseposition))
                {
                    if (player.moveCharRight == false && player.allowButtonPress == true)  //Gör så att man enbart kan genomföra en ny rörelse om karaktären för tillfället inte rör sig åt något håll
                    {
                        player.Frame = 6;   //sätter framen till det håll man försöker gå åt, ifall det är en vägg ivägen körs inte animationen men karaktären vänder sig mot väggen

                        if (positionManager[player.playerPosY, player.playerPosX + 1, floor].type == "enemy")
                        {
                            if (attackDone == true)    //Gör så att man enbart kan genomföra en atack åt gången
                            {
                                for (int i = 0; i < enemies.Count; i++)   //Kollar igenom alla fiender
                                {
                                    if (enemies[i].xCoord == player.playerPosX + 1 && enemies[i].yCoord == player.playerPosY)
                                    {

                                        attackDone = false;
                                        player.allowButtonPress = false; //Gör så man ej kan göra någon annan rörelse eller attack medans man genomför nuvarande attack

                                        attack2.attackPos = new Vector2(player.playerPosX + 1, player.playerPosY);
                                        attack2.Position = new Vector2(attack2.attackPos.X * 64, attack2.attackPos.Y * 64);   //Ritar ut attackanimationen i rätt ruta

                                        int hpBefore = enemies[i].hp;   //Fiendens hp innan utförd attack
                                        enemies[i].hp -= attack2.CharAttackCalc(player.Totstr, enemies[i].dex);   //Kör spelarens attackuträkning på fienden
                                        int hpAfter = enemies[i].hp;   //Fiendens hp efter attack

                                        playerDamgeDelt = hpBefore - hpAfter;   //Skadan som fienden tog

                                        player.allowButtonPress = true;   //Gör att man får trycka på en knapp igen
                                        if (hpBefore == hpAfter)   //Då har attacken missat
                                        {
                                            attackDoneMiss = false;   //Gör att texten för miss ritas ut
                                            attackDone2 = true;
                                            soundBank.PlayCue("AttackMiss");   //Spelar upp ljud för miss
                                        }
                                        else if (hpBefore != hpAfter)   //Ifall attacken träffar
                                        {
                                            attackDoneMiss = true;
                                            attackDone2 = false;   //gör så att attackanimationen får ritas ut
                                            soundBank.PlayCue("AttackSound");   //Spelar upp ljud för träff
                                        }

                                        if (enemies[i].hp <= 0)   //Ifall fienden dör
                                        {

                                            positionManager[player.playerPosY, player.playerPosX + 1, floor].type = "empty";   //Sätter positionen den var på till empty

                                            player.Xp += enemies[i].ReturnExp();
                                            enemies.RemoveAt(i);  //Tar bort fienden
                                            if (player.Xp >= player.XpToLevel)   //Gör så att man går upp i level
                                            {
                                                player.LevelUp(ref hpBarPos.Width);   //Återställer spelarens hpbar

                                            }
                                        }
                                    }
                                    else if (enemies[i].xCoord != player.playerPosX + 1 || enemies[i].yCoord != player.playerPosY)
                                    {

                                    }
                                }
                            }
                        }

                        else if (positionManager[player.playerPosY, player.playerPosX + 1, floor].type != "wall")   //Kollar om det är en vägg framför karaktären, om detta är fallet utförs ingen rörelse
                        {
                            player.moveCharRight = true;    //Gör så att man rör sig åt höger
                            player.allowButtonPress = false;    //Gör så att man inte kan trycka på någon annan knapp medans en rörelse genomförs
                            player.playerPosX += 1;

                        }

                    }
                }
            }

            prevMs1 = mousestate1;

            base.Update(gameTime);
        }
Ejemplo n.º 2
0
        public void Update(GameTime gameTime,  ref PositionManager[,,]  positionManager, int floor, int playerdex, ref int skada, SoundBank soundBank, Cue attackHit, Cue attackMiss, int level, ref Character player1)
        {
            if (resetAttack == false)
            {
                moved2 += 1;
                if (moved2 > 1 && moved2 < 16)
                { Frame = 0; }
                else if (moved2 > 16 && moved2 < 32)
                { Frame = 1; }
                else if (moved2 > 32 && moved2 < 48)
                { Frame = 2; }
                else if (moved2 > 48 && moved2 < 64)
                { Frame = 3; }

                if (moved2 == 64)
                { moved2 = 0; Frame = 0; resetAttack = true; attackMissed = true; attackDidDmg = true; }   //olika variabler ändras så att man nu kan genomföra en ny rörelse
            }

            //attack animation
            if (attackAnimationDone == true)
            {
                movedattack += 4;
                if (movedattack > 1 && movedattack < 16)
                { attackFrame = 0; }
                else if (movedattack > 16 && movedattack < 32)
                { attackFrame = 1; }
                else if (movedattack > 32 && movedattack < 48)
                { attackFrame = 2; }
                else if (movedattack > 48 && movedattack < 64)
                { attackFrame = 3; }

                if (movedattack == 64)    // när man rört sig 64 pixlar så stannar gubben
                { movedattack = 0; attackFrame = 0; attackAnimationDone = false; }   //olika variabler ändras så att man nu kan genomföra en ny rörelse
            }

            CheckActive();  //Kör metoden för att kolla när fienden skall aktiveras

            //Detta ai fungerar så att fienden kollar var spelaren befinner sig i rutnätet. Först kollar den vart den är på X-leden, sedan rör den sig mot fienden tills den är
            //under den på y-leden. Efter det rör sig fienden mot spelaren på y. Om fienden befinner sig bredvid spelaren kommer den att försöka utföra en attack.
            //Skulle en vägg komma ivägen om fienden exempelvis gick in i en vägg på x-leden kommer den i detta läge undersöka om fienden befinner sig längre upp eller ner
            //på y och sedan röra sig mot spelaren på de viset. Samma sak om den går in i en vägg på y-leden, men då kommer den gå åt något håll på x-leden.

            if (allowMove)  //Om den frå röras startar ai
            {
                if (ActiveMove) // Fienden är aktiv och går mot spelaren samt attackerar om den kan.
                {   // Enemy går mot spelaren om den är tillräckligt när för att attackera så gör den det istället.
                    //if ()//ska kolla om det är kortast till spelaren från Enemy på x kordinaten eller om avståndet är lika.
                    //{
                    if (PlayerPos.X > xCoord) // kollar om spelaren är till höger om enemy.
                    {

                        if (xCoord + 1 == PlayerPos.X && yCoord == PlayerPos.Y) //kollar om spelaren är på rutan till höger om enemy.
                        {
                            if (resetAttack == true)
                            {
                                skada = EnemyAttackCalc(playerdex);
                                if (skada != 0)
                                { soundBank.PlayCue("AttackSound"); }
                                else if (skada == 0)
                                { soundBank.PlayCue("AttackMiss");  }

                                player1.TotalHp = player1.TotalHp - skada;

                            }
                        }
                        // kod för att gå till höger.
                        else if (positionManager[yCoord, xCoord + 1, floor].type != "wall" &&
                            positionManager[yCoord, xCoord + 1, floor].type != "enemy" &&
                            positionManager[yCoord, xCoord + 1, floor].type != "upstairs" &&
                            positionManager[yCoord, xCoord + 1, floor].type != "downstairs" &&
                            positionManager[yCoord, xCoord + 1, floor].type != "chest" &&
                            positionManager[yCoord, xCoord + 1, floor].type != "door")
                        {

                            moveEnemyrRight = true;
                            allowMove = false;
                            positionManager[yCoord, xCoord + 1, floor] = positionManager[yCoord, xCoord, floor]; //Sätter rutan man rörde sig mot till player
                            positionManager[yCoord, xCoord, floor] = new PositionManager { type = "empty", floor = true };    //Sätter sin förra position i 2d-arrayen till "null"
                            xCoord++;
                        }
                        //Alternativ när fienden går in i en vägg
                        else if (positionManager[yCoord, xCoord + 1, floor].type == "wall" ||
                           positionManager[yCoord, xCoord + 1, floor].type == "enemy" ||
                           positionManager[yCoord, xCoord + 1, floor].type == "upstairs" ||
                           positionManager[yCoord, xCoord + 1, floor].type == "downstairs" ||
                           positionManager[yCoord, xCoord + 1, floor].type == "chest" ||
                           positionManager[yCoord, xCoord + 1, floor].type != "door")
                        {
                            if (PlayerPos.Y < yCoord) // Kollar om spelaren är ovanför enemy.
                            {
                                if (yCoord - 1 == PlayerPos.Y && xCoord == PlayerPos.X) //kollar om spelaren är på rutan ovnaför enemy.
                                {
                                    if (resetAttack == true)
                                    {
                                        skada = EnemyAttackCalc(playerdex);
                                        if (skada != 0)
                                        { soundBank.PlayCue("AttackSound"); }
                                        else if (skada == 0)
                                        { soundBank.PlayCue("AttackMiss"); }
                                        player1.TotalHp = player1.TotalHp - skada;

                                    }
                                }
                                // kod för att gå up.
                                else if (positionManager[yCoord - 1, xCoord, floor].type != "wall" &&
                                    positionManager[yCoord - 1, xCoord, floor].type != "enemy" &&
                                    positionManager[yCoord - 1, xCoord, floor].type != "upstairs" &&
                                    positionManager[yCoord - 1, xCoord, floor].type != "downstairs" &&
                                    positionManager[yCoord - 1, xCoord, floor].type != "chest" &&
                                    positionManager[yCoord - 1, xCoord, floor].type != "door")
                                {

                                    moveEnemyUp = true;
                                    allowMove = false;
                                    positionManager[yCoord - 1, xCoord, floor] = positionManager[yCoord, xCoord, floor]; //Sätter rutan man rörde sig mot till player
                                    positionManager[yCoord, xCoord, floor] = new PositionManager { type = "empty", floor = true };    //Sätter sin förra position i 2d-arrayen till "null"
                                    yCoord--;
                                }
                            }
                            else if (PlayerPos.Y > yCoord) // annars gå uppåt.
                            {
                                if (yCoord + 1 == PlayerPos.Y && xCoord == PlayerPos.X) //kollar om spelaren är på rutan ovnaför enemy.
                                {
                                    if (resetAttack == true)
                                    {
                                        skada = EnemyAttackCalc(playerdex);
                                        if (skada != 0)
                                        { soundBank.PlayCue("AttackSound"); }
                                        else if (skada == 0)
                                        { soundBank.PlayCue("AttackMiss"); }
                                        player1.TotalHp = player1.TotalHp - skada;

                                    }

                                }
                                //  kod för att gå ner.
                                else if (positionManager[yCoord + 1, xCoord, floor].type != "wall" &&
                                    positionManager[yCoord + 1, xCoord, floor].type != "enemy" &&
                                    positionManager[yCoord + 1, xCoord, floor].type != "upstairs" &&
                                    positionManager[yCoord + 1, xCoord, floor].type != "downstairs" &&
                                    positionManager[yCoord + 1, xCoord, floor].type != "chest" &&
                                    positionManager[yCoord + 1, xCoord, floor].type != "door")
                                {
                                    moveEnemyDown = true;
                                    allowMove = false;
                                    positionManager[yCoord + 1, xCoord, floor] = positionManager[yCoord, xCoord, floor]; //Sätter rutan man rörde sig mot till player
                                    positionManager[yCoord, xCoord, floor] = new PositionManager { type = "empty", floor = true };    //Sätter sin förra position i 2d-arrayen till "null"
                                    yCoord++;
                                }
                            }

                        }

                    }
                    else if (PlayerPos.X < xCoord)  // Annars gå till vänster.
                    {
                        if (xCoord - 1 == PlayerPos.X && yCoord == PlayerPos.Y) //kollar om spelaren är på rutan till vänster om enemy.
                        {
                            if (resetAttack == true)
                            {
                                skada = EnemyAttackCalc(playerdex);
                                if (skada != 0)
                                { soundBank.PlayCue("AttackSound"); }
                                else if (skada == 0)
                                { soundBank.PlayCue("AttackMiss"); }
                                player1.TotalHp = player1.TotalHp - skada;

                            }
                        }
                        // Kod för att gå till vänster

                        else if (positionManager[yCoord, xCoord - 1, floor].type != "wall" &&
                            positionManager[yCoord, xCoord - 1, floor].type != "enemy" &&
                            positionManager[yCoord, xCoord - 1, floor].type != "upstairs" &&
                            positionManager[yCoord, xCoord - 1, floor].type != "downstairs" &&
                            positionManager[yCoord, xCoord - 1, floor].type != "chest" &&
                            positionManager[yCoord, xCoord - 1, floor].type != "door")
                        {
                            moveEnemyLeft = true;
                            allowMove = false;
                            positionManager[yCoord, xCoord - 1, floor] = positionManager[yCoord, xCoord, floor]; //Sätter rutan man rörde sig mot till player
                            positionManager[yCoord, xCoord, floor] = new PositionManager { type = "empty", floor = true };    //Sätter sin förra position i 2d-arrayen till "null"
                            xCoord--;
                        }

                        else if (positionManager[yCoord, xCoord - 1, floor].type == "wall" ||
                           positionManager[yCoord, xCoord - 1, floor].type == "enemy" ||
                           positionManager[yCoord, xCoord - 1, floor].type == "upstairs" ||
                           positionManager[yCoord, xCoord - 1, floor].type == "downstairs" ||
                           positionManager[yCoord, xCoord - 1, floor].type == "chest" ||
                           positionManager[yCoord, xCoord - 1, floor].type != "door")
                        {
                            if (PlayerPos.Y < yCoord) // Kollar om spelaren är ovanför enemy.
                            {
                                if (yCoord - 1 == PlayerPos.Y && xCoord == PlayerPos.X) //kollar om spelaren är på rutan ovnaför enemy.
                                {
                                    if (resetAttack == true)
                                    {
                                        skada = EnemyAttackCalc(playerdex);
                                        if (skada != 0)
                                        { soundBank.PlayCue("AttackSound"); }
                                        else if (skada == 0)
                                        { soundBank.PlayCue("AttackMiss"); }
                                        player1.TotalHp = player1.TotalHp - skada;

                                    }
                                }
                                // kod för att gå up.
                                else if (positionManager[yCoord - 1, xCoord, floor].type != "wall" &&
                                    positionManager[yCoord - 1, xCoord, floor].type != "enemy" &&
                                    positionManager[yCoord - 1, xCoord, floor].type != "upstairs" &&
                                    positionManager[yCoord - 1, xCoord, floor].type != "downstairs" &&
                                    positionManager[yCoord - 1, xCoord, floor].type != "chest" &&
                                    positionManager[yCoord - 1, xCoord, floor].type != "door")
                                {

                                    moveEnemyUp = true;
                                    allowMove = false;
                                    positionManager[yCoord - 1, xCoord, floor] = positionManager[yCoord, xCoord, floor]; //Sätter rutan man rörde sig mot till player
                                    positionManager[yCoord, xCoord, floor] = new PositionManager { type = "empty", floor = true };    //Sätter sin förra position i 2d-arrayen till "null"
                                    yCoord--;
                                }

                            }
                            else if (PlayerPos.Y > yCoord) // annars gå uppåt.
                            {
                                if (yCoord + 1 == PlayerPos.Y && xCoord == PlayerPos.X) //kollar om spelaren är på rutan ovnaför enemy.
                                {
                                    if (resetAttack == true)
                                    {
                                        skada = EnemyAttackCalc(playerdex);
                                        if (skada != 0)
                                        { soundBank.PlayCue("AttackSound"); }
                                        else if (skada == 0)
                                        { soundBank.PlayCue("AttackMiss"); }
                                        player1.TotalHp = player1.TotalHp - skada;

                                    }

                                }
                                //  kod för att gå ner.
                                else if (positionManager[yCoord + 1, xCoord, floor].type != "wall" &&
                                    positionManager[yCoord + 1, xCoord, floor].type != "enemy" &&
                                    positionManager[yCoord + 1, xCoord, floor].type != "upstairs" &&
                                    positionManager[yCoord + 1, xCoord, floor].type != "downstairs" &&
                                    positionManager[yCoord + 1, xCoord, floor].type != "chest" &&
                                    positionManager[yCoord + 1, xCoord, floor].type != "door")
                                {
                                    moveEnemyDown = true;
                                    allowMove = false;
                                    positionManager[yCoord + 1, xCoord, floor] = positionManager[yCoord, xCoord, floor]; //Sätter rutan man rörde sig mot till player
                                    positionManager[yCoord, xCoord, floor] = new PositionManager { type = "empty", floor = true };    //Sätter sin förra position i 2d-arrayen till "null"
                                    yCoord++;
                                }
                            }
                            ///////////////////////
                        ///////////////////////
                        }

                    }
                    //}

                    else if (PlayerPos.Y < yCoord) // Kollar om spelaren är ovanför enemy.
                    {
                        if (yCoord - 1 == PlayerPos.Y && xCoord == PlayerPos.X) //kollar om spelaren är på rutan ovnaför enemy.
                        {
                            if (resetAttack == true)
                            {
                                skada = EnemyAttackCalc(playerdex);
                                if (skada != 0)
                                { soundBank.PlayCue("AttackSound"); }
                                else if (skada == 0)
                                { soundBank.PlayCue("AttackMiss"); }
                                player1.TotalHp = player1.TotalHp - skada;

                            }
                        }
                        // kod för att gå up.
                        else if (positionManager[yCoord - 1, xCoord, floor].type != "wall" &&
                            positionManager[yCoord - 1, xCoord, floor].type != "enemy" &&
                            positionManager[yCoord - 1, xCoord, floor].type != "upstairs" &&
                            positionManager[yCoord - 1, xCoord, floor].type != "downstairs" &&
                            positionManager[yCoord - 1, xCoord, floor].type != "chest" &&
                            positionManager[yCoord - 1, xCoord, floor].type != "door")
                        {

                            moveEnemyUp = true;
                            allowMove = false;
                            positionManager[yCoord - 1, xCoord, floor] = positionManager[yCoord, xCoord, floor]; //Sätter rutan man rörde sig mot till player
                            positionManager[yCoord, xCoord, floor] = new PositionManager { type = "empty", floor = true };    //Sätter sin förra position i 2d-arrayen till "null"
                            yCoord--;
                        }
                        else if (positionManager[yCoord - 1, xCoord, floor].type == "wall" ||
                            positionManager[yCoord - 1, xCoord, floor].type == "enemy" ||
                            positionManager[yCoord - 1, xCoord, floor].type == "upstairs" ||
                            positionManager[yCoord - 1, xCoord, floor].type == "downstairs" ||
                            positionManager[yCoord - 1, xCoord, floor].type == "chest" ||
                            positionManager[yCoord - 1, xCoord, floor].type == "door")
                        {
                            if (PlayerPos.X > xCoord) // kollar om spelaren är till höger om enemy.
                            {

                                if (xCoord + 1 == PlayerPos.X && yCoord == PlayerPos.Y) //kollar om spelaren är på rutan till höger om enemy.
                                {
                                    if (resetAttack == true)
                                    {
                                        skada = EnemyAttackCalc(playerdex);
                                        if (skada != 0)
                                        { soundBank.PlayCue("AttackSound"); }
                                        else if (skada == 0)
                                        { soundBank.PlayCue("AttackMiss"); }
                                        player1.TotalHp = player1.TotalHp - skada;

                                    }
                                }
                                // kod för att gå till höger.
                                else if (positionManager[yCoord, xCoord + 1, floor].type != "wall" &&
                                    positionManager[yCoord, xCoord + 1, floor].type != "enemy" &&
                                    positionManager[yCoord, xCoord + 1, floor].type != "upstairs" &&
                                    positionManager[yCoord, xCoord + 1, floor].type != "downstairs" &&
                                    positionManager[yCoord, xCoord + 1, floor].type != "chest" &&
                                    positionManager[yCoord, xCoord + 1, floor].type != "door")
                                {

                                    moveEnemyrRight = true;
                                    allowMove = false;
                                    positionManager[yCoord, xCoord + 1, floor] = positionManager[yCoord, xCoord, floor]; //Sätter rutan man rörde sig mot till player
                                    positionManager[yCoord, xCoord, floor] = new PositionManager { type = "empty", floor = true};    //Sätter sin förra position i 2d-arrayen till "null"
                                    xCoord++;
                                }

                            }
                            else if (PlayerPos.X < xCoord)  // Annars gå till vänster.
                            {
                                if (xCoord - 1 == PlayerPos.X && yCoord == PlayerPos.Y) //kollar om spelaren är på rutan till vänster om enemy.
                                {
                                    if (resetAttack == true)
                                    {
                                        skada = EnemyAttackCalc(playerdex);
                                        if (skada != 0)
                                        { soundBank.PlayCue("AttackSound"); }
                                        else if (skada == 0)
                                        { soundBank.PlayCue("AttackMiss"); }
                                        player1.TotalHp = player1.TotalHp - skada;

                                    }
                                }
                                // Kod för att gå till vänster

                                else if (positionManager[yCoord, xCoord - 1, floor].type != "wall" &&
                                    positionManager[yCoord, xCoord - 1, floor].type != "enemy" &&
                                    positionManager[yCoord, xCoord - 1, floor].type != "upstairs" &&
                                    positionManager[yCoord, xCoord - 1, floor].type != "downstairs" &&
                                    positionManager[yCoord, xCoord - 1, floor].type != "chest" &&
                                    positionManager[yCoord, xCoord - 1, floor].type != "door")
                                {
                                    moveEnemyLeft = true;
                                    allowMove = false;
                                    positionManager[yCoord, xCoord - 1, floor] = positionManager[yCoord, xCoord, floor]; //Sätter rutan man rörde sig mot till player
                                    positionManager[yCoord, xCoord, floor] = new PositionManager { type = "empty", floor = true };    //Sätter sin förra position i 2d-arrayen till "null"
                                    xCoord--;
                                }
                            }
                            //////////////////////////////////
                        //////////////////////////////////
                        }

                    }
                    else if (PlayerPos.Y > yCoord) // annars gå uppåt.
                    {
                        if (yCoord + 1 == PlayerPos.Y && xCoord == PlayerPos.X) //kollar om spelaren är på rutan ovnaför enemy.
                        {
                            if (resetAttack == true)
                            {
                                skada = EnemyAttackCalc(playerdex);
                                if (skada != 0)
                                { soundBank.PlayCue("AttackSound"); }
                                else if (skada == 0)
                                { soundBank.PlayCue("AttackMiss"); }
                                player1.TotalHp = player1.TotalHp - skada;

                            }

                        }
                        //  kod för att gå ner.
                        else if (positionManager[yCoord + 1, xCoord, floor].type != "wall" &&
                            positionManager[yCoord + 1, xCoord, floor].type != "enemy" &&
                            positionManager[yCoord + 1, xCoord, floor].type != "upstairs" &&
                            positionManager[yCoord + 1, xCoord, floor].type != "downstairs" &&
                            positionManager[yCoord + 1, xCoord, floor].type != "chest" &&
                            positionManager[yCoord + 1, xCoord, floor].type != "door")
                        {
                            moveEnemyDown = true;
                            allowMove = false;
                            positionManager[yCoord + 1, xCoord, floor] = positionManager[yCoord, xCoord, floor]; //Sätter rutan man rörde sig mot till player
                            positionManager[yCoord, xCoord, floor] = new PositionManager { type = "empty", floor = true };    //Sätter sin förra position i 2d-arrayen till "null"
                            yCoord++;
                        }
                        else if (positionManager[yCoord + 1, xCoord, floor].type == "wall" ||
                           positionManager[yCoord + 1, xCoord, floor].type == "enemy" ||
                           positionManager[yCoord + 1, xCoord, floor].type == "upstairs" ||
                           positionManager[yCoord + 1, xCoord, floor].type == "downstairs" ||
                           positionManager[yCoord + 1, xCoord, floor].type == "chest" ||
                           positionManager[yCoord + 1, xCoord, floor].type == "door")
                        {

                            if (PlayerPos.X > xCoord) // kollar om spelaren är till höger om enemy.
                            {

                                if (xCoord + 1 == PlayerPos.X && yCoord == PlayerPos.Y) //kollar om spelaren är på rutan till höger om enemy.
                                {
                                    if (resetAttack == true)
                                    {
                                        skada = EnemyAttackCalc(playerdex);
                                        if (skada != 0)
                                        { soundBank.PlayCue("AttackSound"); }
                                        else if (skada == 0)
                                        { soundBank.PlayCue("AttackMiss"); }
                                        player1.TotalHp = player1.TotalHp - skada;

                                    }
                                }
                                // kod för att gå till höger.
                                else if (positionManager[yCoord, xCoord + 1, floor].type != "wall" &&
                                    positionManager[yCoord, xCoord + 1, floor].type != "enemy" &&
                                    positionManager[yCoord, xCoord + 1, floor].type != "upstairs" &&
                                    positionManager[yCoord, xCoord + 1, floor].type != "downstairs" &&
                                    positionManager[yCoord, xCoord + 1, floor].type != "chest" &&
                                    positionManager[yCoord, xCoord + 1, floor].type != "door")
                                {

                                    moveEnemyrRight = true;
                                    allowMove = false;
                                    positionManager[yCoord, xCoord + 1, floor] = positionManager[yCoord, xCoord, floor]; //Sätter rutan man rörde sig mot till player
                                    positionManager[yCoord, xCoord, floor] = new PositionManager { type = "empty", floor = true };    //Sätter sin förra position i 2d-arrayen till "null"
                                    xCoord++;
                                }

                            }
                            else if (PlayerPos.X < xCoord)  // Annars gå till vänster.
                            {
                                if (xCoord - 1 == PlayerPos.X && yCoord == PlayerPos.Y) //kollar om spelaren är på rutan till vänster om enemy.
                                {
                                    if (resetAttack == true)
                                    {
                                        skada = EnemyAttackCalc(playerdex);
                                        if (skada != 0)
                                        { soundBank.PlayCue("AttackSound"); }
                                        else if (skada == 0)
                                        { soundBank.PlayCue("AttackMiss"); }
                                        player1.TotalHp = player1.TotalHp - skada;
                                        //attackAnimationDone = true; //Gör så att fiendens attackanimation

                                    }
                                }
                                // Kod för att gå till vänster

                                else if (positionManager[yCoord, xCoord - 1, floor].type != "wall" &&
                                    positionManager[yCoord, xCoord - 1, floor].type != "enemy" &&
                                    positionManager[yCoord, xCoord - 1, floor].type != "upstairs" &&
                                    positionManager[yCoord, xCoord - 1, floor].type != "downstairs" &&
                                    positionManager[yCoord, xCoord - 1, floor].type != "chest" &&
                                    positionManager[yCoord, xCoord - 1, floor].type != "door")
                                {
                                    moveEnemyLeft = true;
                                    allowMove = false;
                                    positionManager[yCoord, xCoord - 1, floor] = positionManager[yCoord, xCoord, floor]; //Sätter rutan man rörde sig mot till player
                                    positionManager[yCoord, xCoord, floor] = new PositionManager { type = "empty", floor = true };    //Sätter sin förra position i 2d-arrayen till "null"
                                    xCoord--;
                                }
                            }

                        }

                    }
                }

            }

            //Kallar på metod för att röra sig, beroende på vilket håll den valt i ai-uträkningarna
            if (moveEnemyrRight == true)
            {
                MoveRight2();
            }
            if (moveEnemyLeft == true)
            {
                MoveLeft2();
            }
            if (moveEnemyUp == true)
            {
                MoveUp2();
            }
            if (moveEnemyDown == true)
            {
                MoveDown2();
            }

            base.Update(gameTime);
        }
Ejemplo n.º 3
0
        //Metod för att ladda spelet
        public void LoadTheGame(ref Character PlayerLoad, ref int floor, ref List<Enemy> enemis, ref PositionManager[,,] positionmanger, ref int bredd)
        {
            StreamReader loadGame = new StreamReader("save");
            //Spelar värden
            PlayerLoad.playerPosX = int.Parse(loadGame.ReadLine());
            PlayerLoad.playerPosY = int.Parse(loadGame.ReadLine());
            floor = int.Parse(loadGame.ReadLine());
            PlayerLoad.Totstr = int.Parse(loadGame.ReadLine());
            PlayerLoad.Totdex = int.Parse(loadGame.ReadLine());
            PlayerLoad.TotalHp = int.Parse(loadGame.ReadLine());
            PlayerLoad.maximumHp = int.Parse(loadGame.ReadLine());
            PlayerLoad.Level = int.Parse(loadGame.ReadLine());
            PlayerLoad.Xp = int.Parse(loadGame.ReadLine());
            PlayerLoad.XpToLevel = int.Parse(loadGame.ReadLine());
            PlayerLoad.victoryConition = bool.Parse(loadGame.ReadLine());
            PlayerLoad.PlayerRace = (loadGame.ReadLine());
            PlayerLoad.playerClass = (loadGame.ReadLine());

            //Finde värden
            int numberOfEnemis = int.Parse(loadGame.ReadLine());
            for (int i = 0; i < numberOfEnemis; i++)
            {
                int enemyhp = int.Parse(loadGame.ReadLine());
                int enemyXP = int.Parse(loadGame.ReadLine());
                int enemySpeed = int.Parse(loadGame.ReadLine());

                int enemystr = 0;
                int enemydex = 0;

                switch (enemyXP)
                {
                    case 30:
                        enemystr = 3;
                        enemydex = 12;
                        break;
                    case 60:
                        enemystr = 8;
                        enemydex = 12;
                        break;
                    case 80:
                        enemystr = 8;
                        enemydex = 18;
                        break;
                    case 200:
                        enemystr = 14;
                        enemydex = 4;
                        break;
                }

                enemis.Add(new Enemy(enemyhp, enemystr, enemydex, enemySpeed, enemyXP));

                enemis[i].xCoord = int.Parse(loadGame.ReadLine());
                enemis[i].yCoord = int.Parse(loadGame.ReadLine());

                positionmanger[enemis[i].yCoord, enemis[i].xCoord, floor].type = "enemy";
                switch (enemyXP)
                {
                    case 30:
                        positionmanger[enemis[i].yCoord, enemis[i].xCoord, floor].monster = "g_goblin";
                        break;
                    case 60:
                        positionmanger[enemis[i].yCoord, enemis[i].xCoord, floor].monster = "goblin";
                        break;
                    case 80:
                        positionmanger[enemis[i].yCoord, enemis[i].xCoord, floor].monster = "dark_elf";
                        break;
                    case 200:
                        positionmanger[enemis[i].yCoord, enemis[i].xCoord, floor].monster = "fel_orc";
                        break;
                }

            }

            //överiga värden
            bredd = int.Parse(loadGame.ReadLine());

            int numberOfOpenChest = int.Parse(loadGame.ReadLine());

            if (numberOfOpenChest != 0)
            {
                for (int i = 0; i < numberOfOpenChest; i++)
                {

                    int ypos = int.Parse(loadGame.ReadLine());
                    int xpos = int.Parse(loadGame.ReadLine());
                    int våning = int.Parse(loadGame.ReadLine());

                    positionmanger[ypos, xpos, våning].type = "emptychest";

                }
            }

            loadGame.Close();
        }
Ejemplo n.º 4
0
        //Metod för att spara spelet
        public void SaveTheGame(Character Player, int floor, List<Enemy> enemis, float bredd, PositionManager[,,]positionManager)
        {
            //alla värden måste sparas och laddas i exakt samma ordning. Annars kaos

            StreamWriter saveGame = new StreamWriter("save");
            //Spelarvärden
            saveGame.WriteLine(Player.playerPosX);
            saveGame.WriteLine(Player.playerPosY);
            saveGame.WriteLine(floor);
            saveGame.WriteLine(Player.Totstr);
            saveGame.WriteLine(Player.Totdex);
            saveGame.WriteLine(Player.TotalHp);
            saveGame.WriteLine(Player.maximumHp);
            saveGame.WriteLine(Player.Level);
            saveGame.WriteLine(Player.Xp);
            saveGame.WriteLine(Player.XpToLevel);
            saveGame.WriteLine(Player.victoryConition);
            saveGame.WriteLine(Player.PlayerRace);
            saveGame.WriteLine(Player.playerClass);

            //Fiende värden
            saveGame.WriteLine(enemis.Count );
            for (int i = 0; i < enemis.Count; i++) //sparar data för varje fiende
            {
                saveGame.WriteLine(enemis[i].hp);
                saveGame.WriteLine(enemis[i].ReturnExp());
                saveGame.WriteLine(enemis[i].ReturnSpeed());
                saveGame.WriteLine(enemis[i].xCoord);
                saveGame.WriteLine(enemis[i].yCoord);
            }

            //överiga saker
            saveGame.WriteLine(bredd);

            int antalÖppnadeKistor = 0;

            for (int våning = 0; våning < 3; våning++)
            {
                for (int y = 0; y < 34; y++)
                {
                    for (int x = 0; x < 52; x++)
                    {
                        if (positionManager[y, x, våning].type == "emptychest")
                        {
                            antalÖppnadeKistor += 1;
                        }
                    }
                }
            }
            saveGame.WriteLine(antalÖppnadeKistor);

            for (int våning = 0; våning < 3; våning++)
            {
                for (int y = 0; y < 34; y++)
                {
                    for (int x = 0; x < 52; x++)
                    {
                        if (positionManager[y, x, våning].type == "emptychest")
                        {
                            saveGame.WriteLine(y);
                            saveGame.WriteLine(x);
                            saveGame.WriteLine(våning);
                        }
                    }
                }
            }

            saveGame.Close();
        }
Ejemplo n.º 5
0
        //Metod som återställer viktiga variabler
        //Ordningen som allt måste laddas in i
        //1: Player.playerPosX
        //2: Player.playerPosY
        //3: Floor
        //4: Player str
        //5: Player Dex
        //6: Player Hp
        //7: Player Max Hp
        //8: Player level
        //9: Player Xp
        //10: Player XpToLevel
        //11: Player Victorycondition
        //12: Player Race
        //13: Player Class
        //Fiende värden
        //14: Antalet Fiender
        //15: Fienders xCord
        //16: Fienders yCord
        //17: Fienders Hp
        //Övrigasaker
        //18: hpbar bredd
        //19: Antal öppnade kistor
        //20: Öppnadekistor Y position
        //21: Öppnadekistor X position
        //22: Öppnadekistor Våning
        public void resetGameStats(ref Character Player, ref int floor, ref List<Enemy> enemis, ref int bredd)
        {
            Player.playerPosX = 8;
            Player.playerPosY = 2;
            floor = 0;

            Player.Level = 1;
            Player.Xp = 0;
            Player.XpToLevel = 100;

            Player.victoryConition = false;
            Player.PlayerRace = "Orc";
            Player.playerClass = "Fighter";

            bredd = 412;

            enemis.Clear();

            //Fiende värden
            //14: Antalet Fiender
            //15: Fienders xCord
            //16: Fienders yCord
            //17: Fienders Hp
        }
Ejemplo n.º 6
0
        //Ansvarig: Jonas Holmberg
        //Denna klass enda uppgift är att rita ut spelets "Fog of war" eller med andra ord begränsa spelarens synfält. Vad klassen gör enkelt är att den
        //kollar om spelaren befinner sig nära eller mot en vägg, den ritar sedan ut 64x64 svarta rutor där spelaren inte skall kunna se, ex över en vägg.
        public void Draw(SpriteBatch spriteBatch, Vector2 DrawOffset, float layer, Texture2D visionTileGfx, Character player, PositionManager[, ,] positionManager, int floor)
        {
            //Fog of war
            for (int i = -6; i < 7; i++)//Ritar ut det maximala synfältet
            {

                for (int j = -7; j < 8; j++)
                {
                    if (new Vector2(j, i) == new Vector2(-4, 0))//mitten
                    { j += 9; }
                    else if (new Vector2(j, i) == new Vector2(-3, -1))//mitten -1
                    { j += 7; }
                    else if (new Vector2(j, i) == new Vector2(-3, 1))//mitten +1
                    { j += 7; }
                    else if (new Vector2(j, i) == new Vector2(-2, 2))//mitten +2
                    { j += 5; }
                    else if (new Vector2(j, i) == new Vector2(-2, -2))//mitten -2
                    { j += 5; }
                    else if (new Vector2(j, i) == new Vector2(-1, -3))//mitten -3
                    { j += 3; }
                    else if (new Vector2(j, i) == new Vector2(-1, 3))//mitten +3
                    { j += 3; }
                    else if (new Vector2(j, i) == new Vector2(0, 4))//mitten +4
                    { j += 1; }
                    else if (new Vector2(j, i) == new Vector2(0, -4))//mitten -4
                    { j += 1; }

                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + i) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }

            }

            //Ritar ut fog of war om det är väggar över spelaren
            if (positionManager[player.playerPosY - 1, player.playerPosX, floor].type == "wall")
            {
                for (int j = -7; j < 8; j++)
                {
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 2) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 3) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 4) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 5) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }
            }
            else if (positionManager[player.playerPosY - 2, player.playerPosX, floor].type == "wall")
            {
                for (int j = -7; j < 8; j++)
                {
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 3) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 4) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 5) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }
            }
            else if (positionManager[player.playerPosY - 3, player.playerPosX, floor].type == "wall")
            {
                for (int j = -7; j < 8; j++)
                {
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 4) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 5) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }
            }
            //S**t på utritning av fog of war över spelaren

            //Ritar ut fog of war om det är väggar under spelaren
            if (positionManager[player.playerPosY + 1, player.playerPosX, floor].type == "wall")
            {
                for (int j = -7; j < 8; j++)
                {
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 1) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 2) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 3) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 4) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 5) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }
            }
            else if (positionManager[player.playerPosY + 2, player.playerPosX, floor].type == "wall")
            {
                for (int j = -7; j < 8; j++)
                {
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 2) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 3) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 4) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 5) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }
            }
            else if (positionManager[player.playerPosY + 3, player.playerPosX, floor].type == "wall")
            {
                for (int j = -7; j < 8; j++)
                {
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 3) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 4) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 5) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }
            }
            //S**t på utritning av fog of war under spelaren

            //Kollar fog of war till vänster om spelaren om det är en vägg där

            if (positionManager[player.playerPosY, player.playerPosX - 1, floor].type == "wall")
            {
                for (int i = -6; i < 7; i++)
                {
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX - 2) * 64, (player.playerPosY + i) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX - 3) * 64, (player.playerPosY + i) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX - 4) * 64, (player.playerPosY + i) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX - 5) * 64, (player.playerPosY + i) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }
            }
            else if (positionManager[player.playerPosY, player.playerPosX - 2, floor].type == "wall")
            {
                for (int i = -6; i < 7; i++)
                {
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX - 3) * 64, (player.playerPosY + i) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX - 4) * 64, (player.playerPosY + i) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX - 5) * 64, (player.playerPosY + i) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }
            }
            else if (positionManager[player.playerPosY, player.playerPosX - 3, floor].type == "wall")
            {
                for (int i = -6; i < 7; i++)
                {
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX - 4) * 64, (player.playerPosY + i) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX - 5) * 64, (player.playerPosY + i) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }
            }
            //S**t på koll till vänster

            //Kollar fog of war till höger om spelaren om det är en vägg där

            if (positionManager[player.playerPosY, player.playerPosX + 1, floor].type == "wall")
            {
                for (int i = -6; i < 7; i++)
                {
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + 1) * 64, (player.playerPosY + i) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + 2) * 64, (player.playerPosY + i) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + 3) * 64, (player.playerPosY + i) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + 4) * 64, (player.playerPosY + i) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + 5) * 64, (player.playerPosY + i) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }
            }
            else if (positionManager[player.playerPosY, player.playerPosX + 2, floor].type == "wall")
            {
                for (int i = -6; i < 7; i++)
                {
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + 2) * 64, (player.playerPosY + i) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + 3) * 64, (player.playerPosY + i) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + 4) * 64, (player.playerPosY + i) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + 5) * 64, (player.playerPosY + i) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }
            }
            else if (positionManager[player.playerPosY, player.playerPosX + 3, floor].type == "wall")
            {
                for (int i = -6; i < 7; i++)
                {
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + 3) * 64, (player.playerPosY + i) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + 4) * 64, (player.playerPosY + i) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + 5) * 64, (player.playerPosY + i) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }
            }
            //S**t på koll till höger

            //Kollar fog of war till vänster om spelaren och UPP en bit om det är en vägg där

            if (positionManager[player.playerPosY - 1, player.playerPosX - 1, floor].type == "wall")
            {
                for (int j = -7; j < -1; j++)
                {
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 2) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 3) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 4) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 5) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }
            }
            else if (positionManager[player.playerPosY - 2, player.playerPosX - 1, floor].type == "wall")
            {
                for (int j = -7; j < -1; j++)
                {
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 3) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 4) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 5) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }
            }
            else if (positionManager[player.playerPosY - 3, player.playerPosX - 1, floor].type == "wall")
            {
                for (int j = -7; j < -1; j++)
                {
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 4) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 5) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }
            }

            //S**t på koll till vänster

            //Kollar fog of war till höger om spelaren och UPP en bit om det är en vägg där

            if (positionManager[player.playerPosY - 1, player.playerPosX + 1, floor].type == "wall")
            {
                for (int j = 1; j < 8; j++)
                {
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 2) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 3) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 4) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 5) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }
            }
            else if (positionManager[player.playerPosY - 2, player.playerPosX + 1, floor].type == "wall")
            {
                for (int j = 1; j < 8; j++)
                {
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 3) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 4) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 5) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }
            }
            else if (positionManager[player.playerPosY - 3, player.playerPosX + 1, floor].type == "wall")
            {
                for (int j = 1; j < 8; j++)
                {
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 4) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY - 5) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }
            }

            //S**t på koll till

            //kollar vänster ner
            if (positionManager[player.playerPosY + 1, player.playerPosX - 1, floor].type == "wall")
            {
                for (int j = -7; j < -1; j++)
                {
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 1) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 2) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 3) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 4) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 5) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }
            }
            else if (positionManager[player.playerPosY + 2, player.playerPosX - 1, floor].type == "wall")
            {
                for (int j = -7; j < -1; j++)
                {
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 2) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 3) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 4) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 5) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }
            }
            else if (positionManager[player.playerPosY + 3, player.playerPosX - 1, floor].type == "wall")
            {
                for (int j = -7; j < -1; j++)
                {
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 3) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 4) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 5) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }
            }
            //s**t koll

            //kollar höger ner
            if (positionManager[player.playerPosY + 1, player.playerPosX + 1, floor].type == "wall")
            {
                for (int j = 1; j < 8; j++)
                {
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 1) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 2) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 3) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 4) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 5) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }
            }
            else if (positionManager[player.playerPosY + 2, player.playerPosX + 1, floor].type == "wall")
            {
                for (int j = 1; j < 8; j++)
                {
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 2) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 3) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 4) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 5) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }
            }
            else if (positionManager[player.playerPosY + 3, player.playerPosX + 1, floor].type == "wall")
            {
                for (int j = 1; j < 8; j++)
                {
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 3) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 4) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                    spriteBatch.Draw(visionTileGfx, new Vector2((player.playerPosX + j) * 64, (player.playerPosY + 5) * 64) - player.Position + new Vector2(400, 350), null, Color.White, 0, new Vector2(32, 32), 1.0f, SpriteEffects.None, 0.89f);
                }
            }
            //s**t koll
        }