Esempio n. 1
0
    public void Fragmentation()
    {
        List <ICaseBehaviour> adjacents = CasesAdjacentes();

        for (int i = 0; i < 3 && adjacents.Count > 0; i++)
        {
            // Choisit aléatoirement une des cases adjacentes

            ICaseBehaviour randomCase = adjacents[Random.Range(0, adjacents.Count)];
            int            x          = randomCase.PositionX;
            int            y          = randomCase.PositionY;
            // On la supprime de la liste pour ne pas retomber dessus
            adjacents.Remove(randomCase);

            // Fragmentation d'une mine verte ou rouge
            if (Random.value > 0.5f)
            {
                Grid.Instance.grid[y][x] = Grid.Instance.grid[y][x].ChangeBehaviour <RedMinesBehaviour>();
                (Grid.Instance.grid[y][x] as RedMinesBehaviour).setMineVisible(true);
                TilesetGallery.Instance.SetSounds(Grid.Instance.grid[y][x]);
            }
            else
            {
                Grid.Instance.grid[y][x] = Grid.Instance.grid[y][x].ChangeBehaviour <GreenMinesBehaviour>();
                (Grid.Instance.grid[y][x] as GreenMinesBehaviour).setMineVisible(true);
                TilesetGallery.Instance.SetSounds(Grid.Instance.grid[y][x]);
            }
        }
        // Transforme cette case en case vide
        Grid.Instance.grid[PositionY][PositionX] = Grid.Instance.grid[PositionY][PositionX].ChangeBehaviour <EmptyCaseBehaviour>();
        (Grid.Instance.grid [PositionY] [PositionX] as EmptyCaseBehaviour).AddRemanantMine(TilesetGallery.Instance.GreenMine);
    }
Esempio n. 2
0
    //Genère les cases adjacentes à la mine verte
    private List <ICaseBehaviour> CasesAdjacentes()
    {
        List <ICaseBehaviour> adjacents = new List <ICaseBehaviour>();

        for (int i = -1; i < 2; i++)
        {
            for (int j = -1; j < 2; j++)
            {
                // Condition aux bords
                if (PositionY + i < Grid.Instance.Height && PositionX + j < Grid.Instance.Width && PositionY + i >= 0 && PositionX + j >= 0)
                {
                    if (((PositionY + i + 0.5f) != m_player.PositionCase.y) && ((PositionX + j + 0.5f) != m_player.PositionCase.x))
                    {
                        ICaseBehaviour CurrentCase = Grid.Instance.grid[PositionY + i][PositionX + j];
                        // On ne prend pas en compte les mines et obstacles
                        if (CurrentCase is EmptyCaseBehaviour && !CurrentCase.HasStone)
                        {
                            adjacents.Add(CurrentCase);
                        }
                    }
                }
            }
        }
        return(adjacents);
    }
Esempio n. 3
0
    public void PutStone()
    {
        ICaseBehaviour caseBehaviour = Grid.Instance.grid[(int)PositionCase.y][(int)PositionCase.x];

        if (!IsInventoryEmpty() && !caseBehaviour.HasStone)
        {
            Rocks--;
            caseBehaviour.PutStone(this);
        }
    }
 public void SetSounds(ICaseBehaviour caseBehaviour)
 {
     if (caseBehaviour is RedMinesBehaviour)
     {
         (caseBehaviour as RedMinesBehaviour).mineArmed    = redArmed;
         (caseBehaviour as RedMinesBehaviour).mineDisarmed = redDisarmed;
         (caseBehaviour as RedMinesBehaviour).boom         = redBoom;
     }
     if (caseBehaviour is GreenMinesBehaviour)
     {
         (caseBehaviour as GreenMinesBehaviour).mineArmed = greenArmed;
         (caseBehaviour as GreenMinesBehaviour).boom      = greenBoom;
     }
 }
Esempio n. 5
0
    public void ThrowStone(int x, int y)
    {
        ICaseBehaviour caseBehaviour = Grid.Instance.grid[y][x];

        if (IsInventoryEmpty() || caseBehaviour.HasStone)
        {
            return;
        }

        Rocks--;

        //Defining posArrival
        Vector2 posArrival;

        posArrival.x = x;
        posArrival.y = y;

        StoneTrajectory trajectory = Factory <StoneTrajectory> .New("Stone/StoneTrajectory");

        trajectory.player       = this;
        trajectory.posDeparture = this.PositionCase;
        trajectory.posArrival   = posArrival;

        if (Direction == East)
        {
            changeState(STATE_THROW_R);
        }
        else if (Direction == West)
        {
            changeState(STATE_THROW_L);
        }
        else if (Direction == North)
        {
            changeState(STATE_THROW_T);
        }
        else if (Direction == South)
        {
            changeState(STATE_THROW_B);
        }
    }
Esempio n. 6
0
    void Awake()
    {
        grid = new ICaseBehaviour[Height][];
        for (int i = 0; i < grid.Length; i++)
        {
            grid[i] = new ICaseBehaviour[Width];
        }

        CaseData[][] dataGrid = MapGenerator.GenerateMap(Width, Height, (int)DateTime.Now.Ticks);
        //CaseData[][] dataGrid = MapGenerator.EmptyMap(Width, Height);

        for (int y = 0; y < Height; y++)
        {
            for (int x = 0; x < Width; x++)
            {
                CaseData       currentCase = dataGrid[y][x];
                ICaseBehaviour caseBehaviour;

                switch (currentCase)
                {
                case CaseData.RedMines:
                    caseBehaviour = Factory <RedMinesBehaviour> .New("Case/RedMine");

                    (caseBehaviour as RedMinesBehaviour).setMineVisible(false);
                    break;

                case CaseData.GreenMines:
                    caseBehaviour = Factory <GreenMinesBehaviour> .New("Case/GreenMine");

                    (caseBehaviour as GreenMinesBehaviour).setMineVisible(false);
                    break;

                case CaseData.Obstacle:
                    caseBehaviour = Factory <Obstacle> .New("Case/Obstacle");

                    break;

                case CaseData.Stone:
                    caseBehaviour = Factory <EmptyCaseBehaviour> .New("Case/EmptyCase");

                    caseBehaviour.HasStone = true;
                    break;

                case CaseData.Start:
                    caseBehaviour = Factory <StartCaseBehaviour> .New("Case/Start");

                    break;

                case CaseData.Well:
                    caseBehaviour = Factory <WellCaseBehaviour> .New("Case/Well");

                    break;

                case CaseData.BorderLeft:
                    caseBehaviour = Factory <BorderCaseBehaviour> .New("Case/Border");

                    caseBehaviour.Rotation = Quaternion.AngleAxis(90, Vector3.forward);
                    break;

                case CaseData.BorderRight:
                    caseBehaviour = Factory <BorderCaseBehaviour> .New("Case/Border");

                    caseBehaviour.Rotation = Quaternion.AngleAxis(-90, Vector3.forward);
                    break;

                case CaseData.BorderTop:
                    caseBehaviour = Factory <BorderCaseBehaviour> .New("Case/Border");

                    caseBehaviour.Rotation = Quaternion.AngleAxis(0, Vector3.forward);
                    break;

                case CaseData.BorderBottom:
                    caseBehaviour = Factory <BorderCaseBehaviour> .New("Case/Border");

                    caseBehaviour.Rotation = Quaternion.AngleAxis(180, Vector3.forward);
                    break;

                default:
                    caseBehaviour = Factory <EmptyCaseBehaviour> .New("Case/EmptyCase");

                    break;
                }

                caseBehaviour.SetPosition(x, y);
                ((MonoBehaviour)caseBehaviour).transform.parent   = transform;
                ((MonoBehaviour)caseBehaviour).transform.position = new Vector3(x + 0.5f, y + 0.5f, 0);
                grid[y][x] = caseBehaviour;
            }
        }

        StartCase = new Vector2(1, Height / 2);
    }