Exemple #1
0
        // Rita ut alla väggar (körs bara en gång så här gör vi annat också)
        public void DrawBoard()
        {
            //starta timer för BR
            TimerClass.AddTimer(0, 10000, 10000, maxIndex, Br);

            int wallsIndex = 1;

            //lägg till AI bland characters
            Characters.Add(ai);


            //se till att inga karaktärer startar inuti en vägg genom att få dem att starta inuti ett +
            for (int i = 0; i < Characters.Count; i++)
            {
                wallsIndex = Collision.GetWallIndex(Characters[i].XPosition, Characters[i].YPosition);
                Walls[wallsIndex].Destroy(wallsIndex, true);
                wallsIndex = Collision.GetWallIndex(Characters[i].XPosition - 2, Characters[i].YPosition);
                Walls[wallsIndex].Destroy(wallsIndex, true);
                wallsIndex = Collision.GetWallIndex(Characters[i].XPosition + 2, Characters[i].YPosition);
                Walls[wallsIndex].Destroy(wallsIndex, true);
                wallsIndex = Collision.GetWallIndex(Characters[i].XPosition, Characters[i].YPosition - 1);
                Walls[wallsIndex].Destroy(wallsIndex, true);
                wallsIndex = Collision.GetWallIndex(Characters[i].XPosition, Characters[i].YPosition + 1);
                Walls[wallsIndex].Destroy(wallsIndex, true);
            }
            //rita ut alla väggar
            foreach (GameObject gameObject in Walls)
            {
                gameObject.Draw(1, 1);
            }
        }
Exemple #2
0
        public override void Update()
        {
            //körs en gång
            if (!temp)
            {
                temp = true;

                //starta en loop av AIs Action2 vilket är movement
                int index = TimerClass.GetCharIndex(XPosition, YPosition);
                TimerClass.AddTimer(index, 500, 500, 10000, Program.mygame.Characters[index].Action2);
            }
        }
Exemple #3
0
        // Skapar en ny bomb och lägger ut den.
        public static void LayBomb(int XPosition, int YPosition)
        {
            Bomb latestBoom = new Bomb(XPosition, YPosition);

            // Lägg till i gameobjects
            Program.mygame.GameObjects.Add(latestBoom);

            // Lägg till timer
            int index = Collision.GetIndex(latestBoom.XPosition, latestBoom.YPosition);

            TimerClass.AddTimer(index, 1000, 500, 20, Program.mygame.GameObjects[index].Action2);
        }
Exemple #4
0
        public override void Action2()
        {
            //om det finns positioner att gå till
            if (posList.Count != 0)
            {
                //spara gamla positionen
                int oldX = XPosition;
                int oldY = YPosition;

                //uppdatera position
                XPosition = posList[0][0];
                YPosition = posList[0][1];

                //rita ut
                Draw(0, 0);

                //ta bort gamla position
                Delete(oldX, oldY);
            }
            //om AI ska bomba
            else if (shouldBomb && layBomb)
            {
                //ropa på "sätt ut bomb action"
                Action3();

                //så att AI inte spammar bomber
                layBomb = false;

                //ropa på Action1 efter 3500 millisekunder för att sätta laybomb till true
                int index = TimerClass.GetCharIndex(XPosition, YPosition);

                TimerClass.AddTimer(index, 6000, 6000, 1, Program.mygame.Characters[index].Action1);
            }
            //hitta bästa rutten
            posList = FindPath(new int[] { Program.mygame.player.XPosition, Program.mygame.player.YPosition });
        }
Exemple #5
0
 public override void Action3()
 {
     TimerClass.AddTimer(0, 5000, 0, 1, Action2);
     Move.LayBomb(XPosition, YPosition);
 }
Exemple #6
0
        public void CrossBomb(int oldX, int oldY)
        {
            //håller position för explosion, börjar med bombens position
            List <int> position = new List <int> {
                XPosition, YPosition
            };

            //mult kollar hur långt bort från bomben explosionen ska hamna
            int Mult = 0;

            //vi jobbar med x/2
            oldX = oldX / 2;

            //bools för alla sidor för att hålla reda på vilka som fortfarande används
            bool right = true;
            bool left  = true;
            bool up    = true;
            bool down  = true;

            //lägg till explosion ovanpå bomben
            upList.Add(position);

            while (true)
            {
                //mult blir en större varje gång

                Mult++;

                //börjar med höger
                if (right)
                {
                    //om vi inte träffar något så lägger vi bara till i listan
                    if (Collision.Wall((oldX + Mult) * 2, oldY))
                    {
                        position = new List <int> {
                            (oldX + Mult) * 2, oldY
                        };
                        rightslist.Add(position);
                    }
                    //om vi träffar en vägg och väggen kan sprängas så sätter vi ut en explosion där och tar bort bomben
                    //sen sätter vi right till false så att bomben slutar spränga i den riktningen
                    else
                    {
                        if (Program.mygame.Walls[Collision.GetWallIndex((oldX + Mult) * 2, oldY)].CanBlow)
                        {
                            position = new List <int> {
                                (oldX + Mult) * 2, oldY
                            };
                            Program.mygame.Walls[0].Destroy(Collision.GetWallIndex((oldX + Mult) * 2, oldY), true);
                            rightslist.Add(position);
                        }
                        right = false;
                    }
                }
                //samma sak fast vänster
                if (left)
                {
                    if (Collision.Wall((oldX - Mult) * 2, oldY))
                    {
                        position = new List <int> {
                            (oldX - Mult) * 2, oldY
                        };
                        leftList.Add(position);
                    }
                    else
                    {
                        if (Program.mygame.Walls[Collision.GetWallIndex((oldX - Mult) * 2, oldY)].CanBlow)
                        {
                            position = new List <int> {
                                (oldX - Mult) * 2, oldY
                            };
                            Program.mygame.Walls[0].Destroy(Collision.GetWallIndex((oldX - Mult) * 2, oldY), true);
                            leftList.Add(position);
                        }
                        left = false;
                    }
                }
                //samma sak fast upp
                if (up)
                {
                    if (Collision.Wall(oldX * 2, oldY + Mult))
                    {
                        position = new List <int> {
                            oldX * 2, oldY + Mult
                        };
                        upList.Add(position);
                    }
                    else
                    {
                        if (Program.mygame.Walls[Collision.GetWallIndex(oldX * 2, oldY + Mult)].CanBlow)
                        {
                            position = new List <int> {
                                oldX * 2, oldY + Mult
                            };
                            Program.mygame.Walls[0].Destroy(Collision.GetWallIndex(oldX * 2, oldY + Mult), true);
                            upList.Add(position);
                        }
                        up = false;
                    }
                }
                //samma sak fast ner
                if (down)
                {
                    if (Collision.Wall(oldX * 2, oldY - Mult))
                    {
                        position = new List <int> {
                            oldX * 2, oldY - Mult
                        };
                        downList.Add(position);
                    }
                    else
                    {
                        if (Program.mygame.Walls[Collision.GetWallIndex(oldX * 2, oldY - Mult)].CanBlow)
                        {
                            position = new List <int> {
                                oldX * 2, oldY - Mult
                            };
                            Program.mygame.Walls[0].Destroy(Collision.GetWallIndex(oldX * 2, oldY - Mult), true);
                            downList.Add(position);
                        }
                        down = false;
                    }
                }
                //om alla riktningar är klara slutar vi skapa explosioner
                if (!down && !up && !left && !right)
                {
                    break;
                }

                //sätt ut timer för att ta bort explosionerna
                index = Collision.GetIndex(XPosition, YPosition);

                TimerClass.AddTimer(index, 500, 500, 1, Program.mygame.GameObjects[index].Action3);
            }
        }
Exemple #7
0
        public override void Update()
        {
            // Återställ oldX +old Y
            int        oldX  = XPosition;
            int        oldY  = YPosition;
            ConsoleKey input = new ConsoleKey();

            //kollar efter spelarens input. OBS måste bytas ut för att inte bli turnbased eftersom readkey väntar på knapptryck.
            if (Console.KeyAvailable)
            {
                input = Console.ReadKey(true).Key;
            }

            //movement beroende på knapptryck, xpos är två steg i taget eftersom den är två pixlar bred
            if (input == ConsoleKey.W)
            {
                Move.Up(this);
                Delete(oldX, oldY);
            }
            if (input == ConsoleKey.S)
            {
                Move.Down(this);
                Delete(oldX, oldY);
            }
            if (input == ConsoleKey.D)
            {
                Move.Right(this);
                Delete(oldX, oldY);
            }
            if (input == ConsoleKey.A)
            {
                Move.Left(this);
                Delete(oldX, oldY);
            }

            //om collisionCheck träffar något så står vi stilla och deletar inte något
            if (!Collision.Wall(XPosition, YPosition))
            {
                XPosition = oldX;
                YPosition = oldY;
            }
            else
            {
                Draw(0, 0);
            }

            // Lägg bomb
            if (input == ConsoleKey.Spacebar && canBomb)
            {
                List <int> position = new List <int> {
                    XPosition, YPosition
                };

                Move.LayBomb(XPosition, YPosition);

                canBomb = false;

                //om sex sekunder kan spelaren bomba igen
                int index = TimerClass.GetCharIndex(XPosition, YPosition);

                TimerClass.AddTimer(index, 6000, 6000, 1, Program.mygame.Characters[index].Action2);
            }
        }