コード例 #1
0
        /// <summary>
        /// Wystrzel rakiete
        /// </summary>
        /// <param name="game_map">mapa obiektow</param>
        public void AttackWithRacket(Map.Map game_map)
        {
            Map.MapObject collision_obj = null;
            switch (view_direction)
            {
            case Game.direction.down:
                collision_obj = game_map.getObject(x, y + 1);
                break;

            case Game.direction.up:
                collision_obj = game_map.getObject(x, y - 1);
                break;

            case Game.direction.right:
                collision_obj = game_map.getObject(x + 1, y);
                break;

            case Game.direction.left:
                collision_obj = game_map.getObject(x - 1, y);
                break;
            }


            if (collision_obj != null && (collision_obj.GetType() == typeof(NonDestroyableObjects.Puste) || collision_obj.IsAccesible))
            {
                Map.MapObject racket = new Weapon.Racket(content, collision_obj.rectangle, collision_obj.x, collision_obj.y, view_direction);
                game_map.setObject(collision_obj.x, collision_obj.y, racket);

                SoundEffect fire_racket_effect = content.Load <SoundEffect>("Audio\\fire_racket");
                if (!game_map.player.AudioSettings.IsMuted)
                {
                    SoundEffect.MasterVolume = (float)game_map.player.AudioSettings.SoundVolume;
                    fire_racket_effect.Play();
                }
            }
        }
コード例 #2
0
ファイル: Map.cs プロジェクト: kuzawskak/DungeonVandal-new
        /// <summary>
        /// Konwersja tablicy enum-ów na tablice obiektów MapObject
        /// </summary>
        /// <param name="map_obj">zwracana tablica po konwersji</param>
        /// <param name="objects">pobierana tablica int-ów</param>
        private void CovertIntToObjects(ref MapObject[,] map_obj, ElementType[,] objects)
        {
            for (int x = 0; x < width; x++)
                for (int y = 0; y < height; y++)
                {
                    switch (objects[x, y])
                    {
                        case ElementType.AMEBA:
                            map_obj[x, y] = new DestroyableObjects.Ameba(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                            break;
                        case ElementType.BLOB:
                            map_obj[x, y] = new Characters.Blob(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                            break;
                        case ElementType.CHODZACABOMBA:
                            map_obj[x, y] = new Characters.ChodzacaBomba(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                            break;
                        case ElementType.CIEZKIMUR:
                            map_obj[x, y] = new NonDestroyableObjects.CiezkiMur(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                            break;
                        case ElementType.DYNAMIT:
                            map_obj[x, y] = new Weapon.Dynamit(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                            break;
                        case ElementType.GIGANTYCZNYSZCZUR:
                            map_obj[x, y] = new Characters.GigantycznySzczur(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                            break;

                        case ElementType.GOBLIN:
                            map_obj[x, y] = new Characters.Goblin(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                            break;
                        case ElementType.KAMIEN:
                            map_obj[x, y] = new DestroyableObjects.Kamien(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                            break;
                        case ElementType.LEKKIMUR:
                            map_obj[x, y] = new DestroyableObjects.LekkiMur(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                            break;
                        case ElementType.MAGICZNYMUR:
                            map_obj[x, y] = new NonDestroyableObjects.MagicznyMur(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                            break;
                        case ElementType.MARMUROWYKAMIEN:
                            map_obj[x, y] = new NonDestroyableObjects.MarmurowyKamien(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                            break;
                        case ElementType.PEKDYNAMITOW:
                            map_obj[x, y] = new Weapon.PekDynamitow(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                            break;
                        case ElementType.POLESILOWE:
                            map_obj[x, y] = new Weapon.PoleSilowe(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                            break;
                        case ElementType.PUSTE:
                            map_obj[x, y] = new NonDestroyableObjects.Puste(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size),x,y);
                            break;
                        case ElementType.RACKET:
                            map_obj[x, y] = new Weapon.Racket(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                            break;
                        case ElementType.RADIOAKTYWNYGLAZ:
                            map_obj[x, y] = new NonDestroyableObjects.RadioaktywnyGlaz(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                            break;
                        case ElementType.VANDAL:
                            this.vandal  = new Characters.Vandal(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                            map_obj[x, y] = vandal;
                            break;
                        case ElementType.ZIEMIA:
                            map_obj[x, y] = new DestroyableObjects.Ziemia(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                            break;
                        case ElementType.CELMISJI:
                            map_obj[x, y] = new DestroyableObjects.CelMisji(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y, gameLevel);
                            break;
                        case ElementType.BECZKAZGAZEM:
                            map_obj[x, y] = new DestroyableObjects.BeczkaZGazem(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                            break;
                        case ElementType.NIESTABILNABECZKA:
                            map_obj[x, y] = new DestroyableObjects.NiestabilnaBeczka(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                            break;
                        default:
                            map_obj[x, y] = new DestroyableObjects.Ziemia(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                            break;
                    }
                }
        }
コード例 #3
0
ファイル: Vandal.cs プロジェクト: kuzawskak/DungeonVandal-new
        /// <summary>
        /// Wystrzel rakiete
        /// </summary>
        /// <param name="game_map">mapa obiektow</param>
        public void AttackWithRacket(Map.Map game_map)
        {
            Map.MapObject collision_obj = null;
            switch (view_direction)
            {
                case Game.direction.down:
                    collision_obj = game_map.getObject(x, y + 1);
                    break;
                case Game.direction.up:
                    collision_obj = game_map.getObject(x, y - 1);
                    break;
                case Game.direction.right:
                    collision_obj = game_map.getObject(x + 1, y);
                    break;
                case Game.direction.left:
                    collision_obj = game_map.getObject(x - 1, y);
                    break;
            }

            if (collision_obj != null && (collision_obj.GetType() == typeof(NonDestroyableObjects.Puste) || collision_obj.IsAccesible))
            {

                Map.MapObject racket = new Weapon.Racket(content, collision_obj.rectangle, collision_obj.x, collision_obj.y, view_direction);
                game_map.setObject(collision_obj.x, collision_obj.y, racket);

                SoundEffect fire_racket_effect = content.Load<SoundEffect>("Audio\\fire_racket");
                if (!game_map.player.AudioSettings.IsMuted)
                {
                    SoundEffect.MasterVolume = (float)game_map.player.AudioSettings.SoundVolume;
                    fire_racket_effect.Play();
                }
            }
        }
コード例 #4
0
ファイル: Map.cs プロジェクト: kuzawskak/DungeonVandal-new
        /// <summary>
        /// Konwersja tablicy enum-ów na tablice obiektów MapObject
        /// </summary>
        /// <param name="map_obj">zwracana tablica po konwersji</param>
        /// <param name="objects">pobierana tablica int-ów</param>
        private void CovertIntToObjects(ref MapObject[,] map_obj, ElementType[,] objects)
        {
            for (int x = 0; x < width; x++)
            {
                for (int y = 0; y < height; y++)
                {
                    switch (objects[x, y])
                    {
                    case ElementType.AMEBA:
                        map_obj[x, y] = new DestroyableObjects.Ameba(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;

                    case ElementType.BLOB:
                        map_obj[x, y] = new Characters.Blob(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;

                    case ElementType.CHODZACABOMBA:
                        map_obj[x, y] = new Characters.ChodzacaBomba(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;

                    case ElementType.CIEZKIMUR:
                        map_obj[x, y] = new NonDestroyableObjects.CiezkiMur(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;

                    case ElementType.DYNAMIT:
                        map_obj[x, y] = new Weapon.Dynamit(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;

                    case ElementType.GIGANTYCZNYSZCZUR:
                        map_obj[x, y] = new Characters.GigantycznySzczur(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;

                    case ElementType.GOBLIN:
                        map_obj[x, y] = new Characters.Goblin(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;

                    case ElementType.KAMIEN:
                        map_obj[x, y] = new DestroyableObjects.Kamien(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;

                    case ElementType.LEKKIMUR:
                        map_obj[x, y] = new DestroyableObjects.LekkiMur(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;

                    case ElementType.MAGICZNYMUR:
                        map_obj[x, y] = new NonDestroyableObjects.MagicznyMur(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;

                    case ElementType.MARMUROWYKAMIEN:
                        map_obj[x, y] = new NonDestroyableObjects.MarmurowyKamien(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;

                    case ElementType.PEKDYNAMITOW:
                        map_obj[x, y] = new Weapon.PekDynamitow(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;

                    case ElementType.POLESILOWE:
                        map_obj[x, y] = new Weapon.PoleSilowe(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;

                    case ElementType.PUSTE:
                        map_obj[x, y] = new NonDestroyableObjects.Puste(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;

                    case ElementType.RACKET:
                        map_obj[x, y] = new Weapon.Racket(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;

                    case ElementType.RADIOAKTYWNYGLAZ:
                        map_obj[x, y] = new NonDestroyableObjects.RadioaktywnyGlaz(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;

                    case ElementType.VANDAL:
                        this.vandal   = new Characters.Vandal(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        map_obj[x, y] = vandal;
                        break;

                    case ElementType.ZIEMIA:
                        map_obj[x, y] = new DestroyableObjects.Ziemia(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;

                    case ElementType.CELMISJI:
                        map_obj[x, y] = new DestroyableObjects.CelMisji(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y, gameLevel);
                        break;

                    case ElementType.BECZKAZGAZEM:
                        map_obj[x, y] = new DestroyableObjects.BeczkaZGazem(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;

                    case ElementType.NIESTABILNABECZKA:
                        map_obj[x, y] = new DestroyableObjects.NiestabilnaBeczka(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;

                    default:
                        map_obj[x, y] = new DestroyableObjects.Ziemia(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;
                    }
                }
            }
        }
コード例 #5
0
ファイル: Map.cs プロジェクト: kuzawskak/DungeonVandal
        /// <summary>
        /// Konwersja mapy w postaci tablicy 1-wymairowej (z XML) do tablicy dwywymiarowej obiektów typu MapObject
        /// </summary>
        /// <param name="map_obj">zwracana tablica obiektów</param>
        /// <param name="map">pobierana tablica integerów</param>
        public void CovertSquareIntToObjects(ref MapObject[,] map_obj, int[] map)
        {
            for (int i = 0; i < map.Length; i++)
            {
                int y = i / width;
                int x = i % width;
                switch ((ElementType)map[i])
                {
                    case ElementType.AMEBA:
                        map_obj[x, y] = new DestroyableObjects.Ameba(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;
                    case ElementType.BECZKAZGAZEM:
                        break;
                    case ElementType.BLOB:
                        map_obj[x, y] = new Characters.Blob(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;
                    case ElementType.CHODZACABOMBA:
                        map_obj[x, y] = new Characters.ChodzacaBomba(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;
                    case ElementType.CIEZKIMUR:
                        map_obj[x, y] = new NonDestroyableObjects.CiezkiMur(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;
                    case ElementType.DYNAMIT:
                        map_obj[x, y] = new Weapon.Dynamit(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;
                    case ElementType.GIGANTYCZNYSZCZUR:
                        map_obj[x, y] = new Characters.GigantycznySzczur(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;
                    case ElementType.GOBLIN:
                        map_obj[x, y] = new Characters.Goblin(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;
                    case ElementType.KAMIEN:
                        map_obj[x, y] = new DestroyableObjects.Kamien(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;
                    case ElementType.LEKKIMUR:
                        map_obj[x, y] = new DestroyableObjects.LekkiMur(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;
                    case ElementType.MAGICZNYMUR:
                        map_obj[x, y] = new NonDestroyableObjects.MagicznyMur(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;
                    case ElementType.MARMUROWYKAMIEN:
                        map_obj[x, y] = new NonDestroyableObjects.MarmurowyKamien(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;
                    case ElementType.NIESTABILNABECZKA:
                        break;
                    case ElementType.PEKDYNAMITOW:
                        map_obj[x, y] = new Weapon.PekDynamitow(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;
                    case ElementType.POLESILOWE:
                        map_obj[x, y] = new Weapon.PoleSilowe(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;
                    case ElementType.PUSTE:
                        map_obj[x, y] = new NonDestroyableObjects.Puste(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size),x,y);
                        break;
                    case ElementType.RACKET:
                        map_obj[x, y] = new Weapon.Racket(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;
                    case ElementType.RADIOAKTYWNYGLAZ:
                        map_obj[x, y] = new NonDestroyableObjects.RadioaktywnyGlaz(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        break;
                    case ElementType.VANDAL:
                        this.vandal = new Characters.Vandal(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
                        map_obj[x, y] = vandal;
                        break;
                    case ElementType.ZIEMIA:
                        map_obj[x, y] = new DestroyableObjects.Ziemia(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y, player.IntelligenceLevel);
                        break;
                    case ElementType.CELMISJI:
                        map_obj[x, y] = new DestroyableObjects.CelMisji(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y, gameLevel, player.IntelligenceLevel);
                        break;
                    default:
                        map_obj[x, y] = new DestroyableObjects.Ziemia(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y, player.IntelligenceLevel);
                        break;

                }
            }
        }