Пример #1
0
    /// <summary>
    /// Détermine si la coordonnée passée en paramètre est déjà occupée par un autre bâtiment, en ne prenant pas en compte certaines autres coordonnées.
    /// </summary>
    /// <returns><c>true</c> si la coordonnée est occupée; sinon, <c>false</c>.</returns>
    /// <param name="location">La coordonnée à vérifier.</param>
    /// <param name="coordsToIgnore">Les coordonnées à ignorer.</param>
    bool IsOccupiedCoord(Coord location, Coord[] coordsToIgnore)
    {
        foreach (var build in builds)
        {
            foreach (Coord item in build.occupiedCoords)
            {
                bool skip = false;

                foreach (Coord coord in coordsToIgnore)
                {
                    if (coord == item)
                    {
                        skip = true;
                    }
                }

                if (skip)
                {
                    continue;
                }

                if (item.x == location.x && item.y == location.y)
                {
                    Debug.Log("Occupied");
                    return(true);
                }
            }
        }

        return(false);
    }
Пример #2
0
    // assigne les valeurs nécessaire lors ce que l'on effectue un déplacement de bâtiment
    /// <summary>
    /// Déplace le bâtiment en actualisant ces données.
    /// </summary>
    /// <param name="location">Coordonnées du bâtiment.</param>
    /// <param name="occupiedCoords">Coordonnées occupées par le batiment.</param>
    /// <param name="origin">Origine.</param>
    /// <param name="newTransformPosition">Nouvelle position du bâtiment.</param>
    public void Move(Coord location, Coord[] occupiedCoords, Vector3 origin, Vector3 newTransformPosition)
    {
        this.locationX      = location.x;
        this.locationY      = location.y;
        this.occupiedCoords = occupiedCoords;
        this.origin         = origin;

        buildTransform.position = newTransformPosition;
    }
Пример #3
0
    /// <summary>
    /// Déplace un bâtiment.
    /// </summary>
    /// <param name="buildPosition">La position du Transform du bâtiment à déplacer.</param>
    /// <param name="newPosition">La nouvelle position du bâtiment.</param>
    public void MoveBuild(Vector3 buildPosition, Vector3 newPosition)
    {
        //Build build = GetBuildFromTransformPosition (buildPosition);

        GetBuildFromTransformPosition(buildPosition, out currentUsedBuild);

        if (currentUsedBuild != null)
        {
            if (currentUsedBuild.buildTransform.position == buildPosition)
            {
                // donne l'origine du batiment
                Vector3 snappedPosition = GetSnappedPosition(newPosition);

                // donne l'origine du bâtiment relative au buildHandler
                Vector3 localSnappedPosition = GetSnappedPosition(newPosition - myTransform.position);

                // la difference qu'il y a entre les origins cad l'ancienne et la nouvelle
                Vector3 deltaOrigins = snappedPosition - currentUsedBuild.Origin + offset;

                // nouvelle position du transform du bâtiment
                Vector3 newTransformPosition = new Vector3(currentUsedBuild.buildTransform.position.x + deltaOrigins.x, currentUsedBuild.buildTransform.position.y, currentUsedBuild.buildTransform.position.z + deltaOrigins.z);

                // index en x du batiment
                int locX = Mathf.RoundToInt(localSnappedPosition.x / snapValues.x) + (spacingCountX / 2);

                // index en y du batiment
                int locZ = Mathf.RoundToInt(localSnappedPosition.z / snapValues.y) + (spacingCountY / 2);

                // le decalage entre le nouveau locationX et l'ancien
                int deltaLocationX = locX - currentUsedBuild.LocationX;

                // le decalage entre le nouveau locationY et l'ancien
                int deltaLocationY = locZ - currentUsedBuild.LocationY;

                // les nouvelles positions occupées par le batiment à deplacer
                Coord[] newOccupiedCoords = new Coord[currentUsedBuild.occupiedCoords.Length];

                for (int j = 0; j < newOccupiedCoords.Length; j++)
                {
                    newOccupiedCoords[j] = new Coord(currentUsedBuild.occupiedCoords[j].x + deltaLocationX, currentUsedBuild.occupiedCoords[j].y + deltaLocationY);
                }

                if (IsInCellule(newOccupiedCoords) && !IsOccupiedCoord(newOccupiedCoords))
                {
                    //Debug.Log (string.Format ("Snapped position = {0}; Last snapped position = {1}; Delta origins = {2};", snappedPosition, builds[i].origin - offset, deltaOrigins));
                    //currentUsedBuild.buildTransform.position = newTransformPosition;
                    currentUsedBuild.Move(locX, locZ, newOccupiedCoords, snappedPosition + offset, newTransformPosition);
                }
            }
        }
    }
Пример #4
0
    /// <summary>
    /// Renvoie les coordonnées passées en paramètre tourné d'un angle quarterCount * 90.
    /// </summary>
    /// <returns>Les coordonnées tournées.</returns>
    /// <param name="coordsToRotate">Les coordonnées à tourner.</param>
    /// <param name="locationX">La coordonnée en X du bâtiment à tourner.</param>
    /// <param name="locationY">La coordonnée en Y du bâtiment à tourner.</param>
    /// <param name="quarterCount">Nombre de quart de tour à appliquer à la rotation actuelle.</param>
    Coord[] GetRotatedCoords(Coord[] coordsToRotate, int locationX, int locationY, int quarterCount)
    {
        int len = coordsToRotate.Length;

        Coord[] res = new Coord[len];

        for (int i = 0; i < len; i++)
        {
            // la coordonné relative à la position d'origine
            int relativeX = coordsToRotate[i].x - locationX;
            int relativeY = coordsToRotate[i].y - locationY;

            // la position relative avec la rotation appliquée
            int x = Mathf.RoundToInt(relativeX * Mathf.Cos(90 * -quarterCount) - relativeY * Mathf.Sin(90 * -quarterCount));
            int y = Mathf.RoundToInt(relativeX * Mathf.Sin(90 * -quarterCount) + relativeY * Mathf.Cos(90 * -quarterCount));

            // assignation a la coordonné tournée, la somme de coordonné tourné et l'origine
            // ce qui fait que la coord est de nouveau relative à la grille.
            res[i] = new Coord(locationX + x, locationY + y);
        }
        return(res);
    }
Пример #5
0
 /// <summary>
 /// Détermine si la coordonnée passée en paramètre est dans le Collider de cette instance.
 /// </summary>
 /// <returns><c>true</c> si la coordonnée est dans le Collider; sinon, <c>false</c>.</returns>
 /// <param name="location">La coordonnée à vérifier.</param>
 bool IsInCellule(Coord location)
 {
     return(IsInCellule(location.x, location.y));
 }
Пример #6
0
 /// <summary>
 /// Détermine si la coordonnée passée en paramètre est déjà occupée par un autre bâtiment.
 /// </summary>
 /// <returns><c>true</c> si la coordonnée est déjà occupée; sinon, <c>false</c>.</returns>
 /// <param name="location">La coordonnée à vérifier.</param>
 bool IsOccupiedCoord(Coord location)
 {
     return(IsOccupiedCoord(location.x, location.y));
 }
Пример #7
0
 // change la position dans le build handler de ce batiment
 /// <summary>
 /// Renseigne la position de ce bâtiment dans sa grille.
 /// </summary>
 /// <param name="location">La coordonnée de ce bâtiment.</param>
 public void SetLocation(Coord location)
 {
     this.locationX = location.x;
     this.locationY = location.y;
 }