Ejemplo n.º 1
0
    public void Setup(DungeonData.DungeonParameters dungeonParameters)
    {
        List <Enemy> temp = enemiesToSpawn;

        enemiesToSpawn = new List <Enemy> ();
        if (dungeonParameters.enemies.minoTaur)
        {
            enemiesToSpawn.Add(temp [0]);
        }
        if (dungeonParameters.enemies.Spider)
        {
            enemiesToSpawn.Add(temp [1]);
        }
        if (dungeonParameters.enemies.Ghost)
        {
            enemiesToSpawn.Add(temp [2]);
        }
        if (dungeonParameters.enemies.Bomber)
        {
            enemiesToSpawn.Add(temp [3]);
        }

        timeBetweenEnemySpawn = dungeonParameters.timeBetweenSpawns;
        timeTillSpawning      = dungeonParameters.timeBeforeSpawning;

        StartCoroutine(WaitSpawning());
    }
Ejemplo n.º 2
0
 public MasterGenerator(GameObject game_manager, DungeonData.DungeonParameters dungeonParameters, int radius, int maxlength,
                        int timeout)
 {
     this.dungeonParameters = dungeonParameters;
     this.game_manager      = game_manager;
     this.width             = dungeonParameters.width;
     this.height            = dungeonParameters.height;
     this.radius            = radius;
     this.maxlength         = maxlength;
     this.timeout           = timeout;
     this.minAmountOfRooms  = dungeonParameters.minAmountOfRooms;
     this.maxAmountOfRooms  = dungeonParameters.maxAmountOfRooms;
     this.chanceOfRoom      = dungeonParameters.chanceOfRoom;
 }
Ejemplo n.º 3
0
    public void FillChest(DungeonData.DungeonParameters dungeonParameters)
    {
        List <GameObject> temp = contents;

        contents = new List <GameObject> ();

        //coins
        for (int i = 0; i < Random.Range(1, 4); i++)
        {
            contents.Add(temp [0]);
        }

        //health pickup
        for (int i = 0; i < Random.Range(1, 3); i++)
        {
            contents.Add(temp [1]);
        }

        //Powerups
        if (dungeonParameters.powerUps.shield.enabled && Random.value < dungeonParameters.powerUps.shield.spawnChance)
        {
            contents.Add(temp [2]);
        }
        if (dungeonParameters.powerUps.sticky.enabled && Random.value < dungeonParameters.powerUps.sticky.spawnChance)
        {
            contents.Add(temp [3]);
        }
        if (dungeonParameters.powerUps.wall.enabled && Random.value < dungeonParameters.powerUps.wall.spawnChance)
        {
            contents.Add(temp [4]);
        }
        if (dungeonParameters.powerUps.bomb.enabled && Random.value < dungeonParameters.powerUps.bomb.spawnChance)
        {
            contents.Add(temp [5]);
        }
        if (dungeonParameters.powerUps.decoy.enabled && Random.value < dungeonParameters.powerUps.decoy.spawnChance)
        {
            contents.Add(temp [6]);
        }

        //Weapons
        if (dungeonParameters.powerUps.iceballWeapon.enabled && Random.value < dungeonParameters.powerUps.iceballWeapon.spawnChance)
        {
            contents.Add(temp [7]);
        }
        if (dungeonParameters.powerUps.piercingWeapon.enabled && Random.value < dungeonParameters.powerUps.piercingWeapon.spawnChance)
        {
            contents.Add(temp [8]);
        }
        if (dungeonParameters.powerUps.laserWeapon.enabled && Random.value < dungeonParameters.powerUps.laserWeapon.spawnChance)
        {
            contents.Add(temp [9]);
        }
        if (dungeonParameters.powerUps.bloodWeapon.enabled && Random.value < dungeonParameters.powerUps.bloodWeapon.spawnChance)
        {
            contents.Add(temp [10]);
        }
        if (dungeonParameters.powerUps.boomerangWeapon.enabled && Random.value < dungeonParameters.powerUps.boomerangWeapon.spawnChance)
        {
            contents.Add(temp [11]);
        }
    }
Ejemplo n.º 4
0
 public void SetUp(DungeonData.DungeonParameters dungeonParameters, Transform parent)
 {
     FillChest(dungeonParameters);
     InstantiateContent(parent);
 }
Ejemplo n.º 5
0
    // Use this for initialization
    public DungeonInstantiate(DungeonData.DungeonParameters dungeonParameters, GameObject floor, GameObject side,
                              GameObject roof, GameObject block, GameObject trap_straight, GameObject trap_crossing,
                              GameObject trap_box, GameObject portal, GameObject end_portal, GameObject player,
                              GameObject game_manager, GameObject spawner, GameObject torch, GameObject cam, GameObject pointer,
                              GameObject chest, GameObject coin, GameObject fireball, GameObject iceball, GameObject health, int[] mazeSize, GameObject laser, GameObject shieldPickUp,
                              GameObject stickyPickUp, GameObject roofGroup, GameObject wallPickUp, GameObject wallTorch, GameObject piercingWeapon,
                              GameObject bombPickUp, GameObject spidernest, GameObject wizardnest, GameObject wallspikes, GameObject spikes, GameObject shuriken, GameObject wallrush,
                              GameObject stardustParticles, GameObject moondustParticles, GameObject decoyPickUp, GameObject dungeonLavaStream, GameObject dungeonSkull)

    {
        this.dungeonParameters = dungeonParameters;
        this.floor             = floor;
        this.side          = side;
        this.roof          = roof;
        this.block         = block;
        this.trap_straight = trap_straight;
        this.trap_crossing = trap_crossing;
        this.trap_box      = trap_box;
        this.portal        = portal;
        this.end_portal    = end_portal;
        this.cam           = cam;
        this.pointer       = pointer;
        this.chest         = chest;
        this.player        = player;
        this.mazeSize      = new int[2] {
            mazeSize[0] - 2, mazeSize[1] - 2
        };
        this.spawner       = spawner;
        this.game_manager  = game_manager;
        this.puzzleCoords  = new List <p2D> ();
        this.puzzleCenters = new List <p2D> ();
        this.puzzleRoomsDG = new List <Room> ();

        this.wizardnest = wizardnest;
        this.spidernest = spidernest;
        this.wallspikes = wallspikes;
        this.spikes     = spikes;
        this.shuriken   = shuriken;
        this.wallrush   = wallrush;

        this.dungeonParticles  = new GameObject[] { stardustParticles, moondustParticles };
        this.dungeonLavaStream = dungeonLavaStream;
        this.dungeonSkull      = dungeonSkull;

        WallsParent     = new GameObject("Walls");
        FloorsParent    = new GameObject("Floors");
        RoofsParent     = new GameObject("Roofs");
        Traps           = new GameObject("Traps");
        PickupsParent   = new GameObject("PickupsParent");
        ChestsParent    = new GameObject("ChestsParent");
        WallTorchParent = new GameObject("WallTorchParent");
        ParticlesParent = new GameObject("ParticlesParent");

        RoofPrefab        = Resources.Load("Prefabs/Blocks/RoofPrefab", typeof(GameObject)) as GameObject;
        WallPrefab        = Resources.Load("Prefabs/Blocks/WallPrefab", typeof(GameObject)) as GameObject;
        DeadEndPrefab     = Resources.Load("Prefabs/Blocks/DeadEndPrefab", typeof(GameObject)) as GameObject;
        CornerInnerPrefab = Resources.Load("Prefabs/Blocks/CornerPrefab Inner", typeof(GameObject)) as GameObject;
        FloorPrefab       = Resources.Load("Prefabs/Blocks/FloorPrefab", typeof(GameObject)) as GameObject;
        PuzzleMist        = Resources.Load("Prefabs/PuzzlesScenes/PuzzleMist", typeof(GameObject)) as GameObject;
        WoodenDoors       = Resources.Load("Prefabs/PuzzlesScenes/WoodenDoor", typeof(GameObject)) as GameObject;
        PuzzleDoors       = Resources.Load("Prefabs/PuzzlesScenes/PuzzleDoors", typeof(GameObject)) as GameObject;

        BeginningRoom = Resources.Load("Prefabs/PuzzlesScenes/BeginningRoom", typeof(GameObject)) as GameObject;
        EndingRoom    = Resources.Load("Prefabs/PuzzlesScenes/EndingRoom", typeof(GameObject)) as GameObject;


        this.starters_pack = new GameObject[] { torch };
        this.roofGroup     = roofGroup;
        this.wallTorch     = wallTorch;

        this.puzzleRooms            = new List <GameObject> ();
        this.puzzleRoomSpawnChances = new List <float> ();
        if (dungeonParameters.puzzleRooms.Blockpuzzleroom.enabled)
        {
            puzzleRooms.Add(dungeonParameters.puzzleRooms.Blockpuzzleroom.puzzleRoom);
            puzzleRoomSpawnChances.Add(dungeonParameters.puzzleRooms.Blockpuzzleroom.spawnChance);
        }
        if (dungeonParameters.puzzleRooms.Fliproom.enabled)
        {
            puzzleRooms.Add(dungeonParameters.puzzleRooms.Fliproom.puzzleRoom);
            puzzleRoomSpawnChances.Add(dungeonParameters.puzzleRooms.Fliproom.spawnChance);
        }
        if (dungeonParameters.puzzleRooms.Bossroom.enabled)
        {
            puzzleRooms.Add(dungeonParameters.puzzleRooms.Bossroom.puzzleRoom);
            puzzleRoomSpawnChances.Add(dungeonParameters.puzzleRooms.Bossroom.spawnChance);
        }
        if (dungeonParameters.puzzleRooms.Laserroom.enabled)
        {
            puzzleRooms.Add(dungeonParameters.puzzleRooms.Laserroom.puzzleRoom);
            puzzleRoomSpawnChances.Add(dungeonParameters.puzzleRooms.Laserroom.spawnChance);
        }
        if (dungeonParameters.puzzleRooms.Fallblockpuzzle.enabled)
        {
            puzzleRooms.Add(dungeonParameters.puzzleRooms.Fallblockpuzzle.puzzleRoom);
            puzzleRoomSpawnChances.Add(dungeonParameters.puzzleRooms.Fallblockpuzzle.spawnChance);
        }
        if (dungeonParameters.puzzleRooms.Movingplatformroom.enabled)
        {
            puzzleRooms.Add(dungeonParameters.puzzleRooms.Movingplatformroom.puzzleRoom);
            puzzleRoomSpawnChances.Add(dungeonParameters.puzzleRooms.Movingplatformroom.spawnChance);
        }
        if (dungeonParameters.puzzleRooms.Treasureroom.enabled)
        {
            puzzleRooms.Add(dungeonParameters.puzzleRooms.Treasureroom.puzzleRoom);
            puzzleRoomSpawnChances.Add(dungeonParameters.puzzleRooms.Treasureroom.spawnChance);
        }

        sbPuzzles = new StringBuilder();
        sbPuzzles.Append("Available puzzles in this dungeon: ");
        for (int i = 0; i < puzzleRooms.Count; i++)
        {
            sbPuzzles.Append("\n" + puzzleRooms[i].name + ", chance: " + puzzleRoomSpawnChances[i].ToString());
        }

        NormalizePuzzleRoomChances();

        this.traps            = new List <GameObject> ();
        this.trapSpawnChances = new List <float> ();
        if (dungeonParameters.Traps.shuriken.enabled)
        {
            traps.Add(shuriken);
            trapSpawnChances.Add(dungeonParameters.Traps.shuriken.spawnChance);
        }
        if (dungeonParameters.Traps.spikes.enabled)
        {
            traps.Add(spikes);
            trapSpawnChances.Add(dungeonParameters.Traps.spikes.spawnChance);
        }
        if (dungeonParameters.Traps.wallrush.enabled)
        {
            traps.Add(wallrush);
            trapSpawnChances.Add(dungeonParameters.Traps.wallrush.spawnChance);
        }
        if (dungeonParameters.Traps.wallspikes.enabled)
        {
            traps.Add(wallspikes);
            trapSpawnChances.Add(dungeonParameters.Traps.wallspikes.spawnChance);
        }
        if (dungeonParameters.Traps.spidernest.enabled)
        {
            traps.Add(spidernest);
            trapSpawnChances.Add(dungeonParameters.Traps.spidernest.spawnChance);
        }
        if (dungeonParameters.Traps.wizardnest.enabled)
        {
            traps.Add(wizardnest);
            trapSpawnChances.Add(dungeonParameters.Traps.wizardnest.spawnChance);
        }

        sbTraps = new StringBuilder();

        /*sbTraps.Append ("Available traps according to dungeonparameters:\n");
         * if(dungeonParameters.Traps
         *
         */


        sbTraps.Append("Available traps in this dungeon: ");
        for (int i = 0; i < traps.Count; i++)
        {
            sbTraps.Append("\n" + traps[i].name + ", chance: " + trapSpawnChances[i].ToString());
        }

        NormalizeTrapChances();
    }