Esempio n. 1
0
 public virtual void Stop(HexXY p)
 {
 }
Esempio n. 2
0
File: G.cs Progetto: Dzugaru/hexes
    static void PerformInterfaceMove(Interfacing.EntityHandle objHandle, HexXY pos, float timeToGetThere)
    {
        GameObject obj = entities[objHandle];

        obj.GetComponent <EntityGraphics>().Move(pos, timeToGetThere);
    }
Esempio n. 3
0
    public void CreateMapMeshes()
    {
        meshGenerator = new HexMeshGenerator(meshPatchSize, meshSubdivsShift);

        //DEBUG some walls
        foreach (var cell in map.AllCells())
        {
            if (HexXY.Dist(new HexXY(map.size / 2, map.size / 2), cell.Coords) < map.size / 3)
            {
                cell.Cell.state = MapCell.State.Excavated;
            }
        }
        //-------------

        int s = (map.size - 1) / meshPatchSize + 1;

        patchesX0 = -2 * s;
        patchesY0 = -1;
        patchesW  = 3 * s;
        patchesH  = 2 * s + 1;

        mapPatchObjs = new Transform[patchesH * patchesW];

        if (patchesRoot != null)
        {
            DestroyImmediate(patchesRoot.gameObject);
        }


        patchesRoot            = new GameObject(mapPatchesName).transform;
        patchesRoot.localScale = new Vector3(mapScale, mapScale, mapScale);
        patchesRoot.parent     = this.transform;

        for (int i = 0; i < patchesH; i++)
        {
            for (int j = 0; j < patchesW; j++)
            {
                Transform patch = CreatePatch(patchesY0 + i, patchesX0 + j);
                if (patch != null)
                {
                    patch.SetParent(patchesRoot, false);
                    Vector2 pos = ((patchesX0 + j) * HexMeshGenerator.rhex + (patchesY0 + i) * HexMeshGenerator.rhey) * meshPatchSize;
                    patch.localPosition            = new Vector3(pos.x, 0, pos.y);
                    mapPatchObjs[i * patchesW + j] = patch;
                }
            }
        }

        //DEBUG patches bounds checking...
        //List<Vector2Int> patchIdxs = new List<Vector2Int>();
        //int minX = int.MaxValue, minY = int.MaxValue, maxX = int.MinValue, maxY = int.MinValue;
        //foreach(var cell in map.AllCells())
        //{
        //    HexMeshGenerator.ListPatchIndicesForCell(meshPatchSize, cell.Coords, patchIdxs);

        //    foreach(Vector2Int idx in patchIdxs)
        //    {
        //        minX = Mathf.Min(idx.x, minX);
        //        maxX = Mathf.Max(idx.x, maxX);
        //        minY = Mathf.Min(idx.y, minY);
        //        maxY = Mathf.Max(idx.y, maxY);
        //    }
        //    //Debug.Log("Coords: " + cell.Coords.ToString());
        //    //Debug.Log(string.Join(" ", patchIdxs.Select(x => x.ToString()).ToArray()));
        //}

        //Debug.Log(map.size);

        //Debug.Log(string.Format("{0},{1},{2},{3}", minX, minY, maxX, maxY));

        //if (minX < patchesX0 || maxX >= patchesX0 + patchesW || minY < patchesY0 || maxY >= patchesY0 + patchesH)
        //    Debug.Log(string.Format("Wrong! {0} {1} {2} {3}", patchesX0, patchesY0, patchesX0 + patchesW - 1, patchesY0 + patchesH - 1));
    }
Esempio n. 4
0
    void GenetareGrid(WorldBlock wb, float hexInset, List <Vector3> vertices, List <Vector3> normals, List <int> triangles)
    {
        float      gridYPos = 0.02f;
        GameObject obj      = new GameObject("Grid");

        obj.transform.SetParent(transform, false);
        var meshRenderer = obj.AddComponent <MeshRenderer>();
        var meshFilter   = obj.AddComponent <MeshFilter>();
        var mesh         = new Mesh();

        meshRenderer.sharedMaterial = (Material)Resources.Load("Terrain/Grid");

        for (int x = 0; x < WorldBlock.sz; x++)
        {
            for (int y = 0; y < WorldBlock.sz; y++)
            {
                var currType = wb.GetCellType(new HexXY(x, y));
                for (int n = 0; n < 3; n++)
                {
                    HexXY curr = new HexXY(x, y);
                    HexXY ng   = curr + HexXY.neighbours[n];
                    HexXY ngr  = curr + HexXY.neighbours[(n + 1) % 6];
                    if (currType == TerrainCellType.Empty &&
                        (!WorldBlock.IsInRange(ng) || wb.GetCellType(ng) == TerrainCellType.Empty))
                    {
                        continue;
                    }

                    Vector2 currCoord = curr.ToPlaneCoordinates();
                    Vector2 ngCoord   = ng.ToPlaneCoordinates();

                    //Line between two
                    Vector2 vert = cellVertices[n] * hexInset + currCoord;
                    vertices.Add(new Vector3(vert.x, gridYPos, vert.y));

                    vert = cellVertices[(n + 1) % 6] * hexInset + currCoord;
                    vertices.Add(new Vector3(vert.x, gridYPos, vert.y));

                    vert = cellVertices[(n + 3) % 6] * hexInset + ngCoord;
                    vertices.Add(new Vector3(vert.x, gridYPos, vert.y));

                    vert = cellVertices[(n + 4) % 6] * hexInset + ngCoord;
                    vertices.Add(new Vector3(vert.x, gridYPos, vert.y));

                    triangles.Add(vertices.Count - 4 + 1);
                    triangles.Add(vertices.Count - 4);
                    triangles.Add(vertices.Count - 4 + 2);
                    triangles.Add(vertices.Count - 4 + 2);
                    triangles.Add(vertices.Count - 4);
                    triangles.Add(vertices.Count - 4 + 3);

                    //Triangle between three
                    if (currType == TerrainCellType.Empty &&
                        (!WorldBlock.IsInRange(ngr) || wb.GetCellType(ngr) == TerrainCellType.Empty) &&
                        (!WorldBlock.IsInRange(ng) || wb.GetCellType(ng) == TerrainCellType.Empty))
                    {
                        continue;
                    }
                    Vector2 ngrCoord = ngr.ToPlaneCoordinates();

                    vert = cellVertices[(n + 1) % 6] * hexInset + currCoord;
                    vertices.Add(new Vector3(vert.x, gridYPos, vert.y));

                    vert = cellVertices[(n + 3) % 6] * hexInset + ngCoord;
                    vertices.Add(new Vector3(vert.x, gridYPos, vert.y));

                    vert = cellVertices[(n + 5) % 6] * hexInset + ngrCoord;
                    vertices.Add(new Vector3(vert.x, gridYPos, vert.y));

                    triangles.Add(vertices.Count - 3);
                    triangles.Add(vertices.Count - 3 + 1);
                    triangles.Add(vertices.Count - 3 + 2);
                }
            }
        }



        for (int i = 0; i < vertices.Count; i++)
        {
            normals.Add(new Vector3(0, 1, 0));
        }

        mesh.vertices  = vertices.ToArray();
        mesh.normals   = normals.ToArray();
        mesh.triangles = triangles.ToArray();
        mesh.RecalculateBounds();

        meshFilter.mesh = mesh;
    }
Esempio n. 5
0
    void GenerateNewWalls(WorldBlock wb)
    {
        wallsParent = new GameObject("Walls");
        wallsParent.SetActive(enableWalls);
        wallsParent.transform.SetParent(transform, false);
        wallsParent.transform.localPosition = Vector3.zero;

        bool[] emptyNs = new bool[6];

        for (int x = 0; x < WorldBlock.sz; x++)
        {
            for (int y = 0; y < WorldBlock.sz; y++)
            {
                HexXY   p      = new HexXY(x, y);
                Vector2 coords = p.ToPlaneCoordinates();

                if (Level.S.GetCellType(p + wb.Offset) == TerrainCellType.Empty)
                {
                    continue;
                }

                for (int n = 0; n < 6; n++)
                {
                    emptyNs[n] = Level.S.GetCellType(p + wb.Offset + HexXY.neighbours[n]) == TerrainCellType.Empty;
                }

                if (emptyNs.Count(e => e) == 1)
                {
                    int wallDir = -1;
                    for (int n = 0; n < 6; n++)
                    {
                        if (emptyNs[n])
                        {
                            wallDir = n;
                        }
                    }

                    var wall = Instantiate(Resources.Load <GameObject>("Prefabs/OutCorner"));
                    wall.transform.SetParent(wallsParent.transform, false);
                    wall.transform.localPosition = new Vector3(coords.x, 0, coords.y);
                    wall.transform.localRotation = Quaternion.Euler(0, -180 + wallDir * 60, 0);
                    wall.SetActive(true);
                }
                else if (emptyNs.Count(e => e) == 2)
                {
                    int wallDir = -1;
                    for (int n = 0; n < 6; n++)
                    {
                        if (emptyNs[n] && emptyNs[(n + 1) % 6])
                        {
                            wallDir = n;
                        }
                    }
                    if (wallDir == -1)
                    {
                        continue;
                    }
                    var wall = Instantiate(Resources.Load <GameObject>("Prefabs/NewWall"));
                    wall.transform.SetParent(wallsParent.transform, false);
                    wall.transform.localPosition = new Vector3(coords.x, 0, coords.y);
                    wall.transform.localRotation = Quaternion.Euler(0, -60 + wallDir * 60, 0);
                    wall.SetActive(true);
                }
                else if (emptyNs.Count(e => e) == 3)
                {
                    int wallDir = -1;
                    for (int n = 0; n < 6; n++)
                    {
                        if (emptyNs[(n + 5) % 6] && emptyNs[n % 6] && emptyNs[(n + 1) % 6])
                        {
                            wallDir = n;
                        }
                    }
                    if (wallDir == -1)
                    {
                        continue;
                    }
                    var wall = Instantiate(Resources.Load <GameObject>("Prefabs/InCorner"));
                    wall.transform.SetParent(wallsParent.transform, false);
                    wall.transform.localPosition = new Vector3(coords.x, 0, coords.y);
                    wall.transform.localRotation = Quaternion.Euler(0, wallDir * 60, 0);
                    wall.SetActive(true);
                }
            }
        }
    }
Esempio n. 6
0
 public AddEntity(Entity ent, HexXY p)
 {
     this.ent = ent;
     this.p   = p;
 }
Esempio n. 7
0
 public MoveEntity(Entity ent, HexXY from, HexXY to)
 {
     this.ent  = ent;
     this.from = from;
     this.to   = to;
 }
Esempio n. 8
0
 public ChangeTriggerZone(HexXY p, uint zone)
 {
     this.p    = p;
     this.zone = zone;
 }
Esempio n. 9
0
        void PaintOneCell(HexXY p, TerrainCellType type, HashSet <WorldBlock> changedBlocks, TerrainCellType oldCellType, bool writeChanges)
        {
            var changedWb = Level.S.SetCellType(p, type);

            if (Level.S.GetCellType(p) != type)
            {
                return;                                 //Set failure
            }
            if (writeChanges)
            {
                changes.Push(new CellChange()
                {
                    oldCellType = oldCellType, newCellType = type, p = p
                });
            }

            //Changed blocks
            if (!changedBlocks.Contains(changedWb))
            {
                changedBlocks.Add(changedWb);
            }

            HexXY locp = Level.GetLocalCoords(p);

            //Other blocks possible walls fix
            if (locp.x == 0)
            {
                var nbl = Level.S.GetBlock(changedWb.position - new HexXY(1, 0));
                if (nbl != null && !changedBlocks.Contains(nbl))
                {
                    changedBlocks.Add(nbl);
                }
            }

            if (locp.y == 0)
            {
                var nbl = Level.S.GetBlock(changedWb.position - new HexXY(0, 1));
                if (nbl != null && !changedBlocks.Contains(nbl))
                {
                    changedBlocks.Add(nbl);
                }
            }

            if (locp.x == WorldBlock.sz - 1)
            {
                var nbl = Level.S.GetBlock(changedWb.position + new HexXY(1, 0));
                if (nbl != null && !changedBlocks.Contains(nbl))
                {
                    changedBlocks.Add(nbl);
                }
            }

            if (locp.y == WorldBlock.sz - 1)
            {
                var nbl = Level.S.GetBlock(changedWb.position + new HexXY(0, 1));
                if (nbl != null && !changedBlocks.Contains(nbl))
                {
                    changedBlocks.Add(nbl);
                }
            }
        }
Esempio n. 10
0
    void PerformInterfaceTeleport(Interfacing.EntityHandle objHandle, HexXY to)
    {
        GameObject obj = entities[objHandle];

        obj.GetComponent <EntityGraphics>().Teleport(to);
    }
Esempio n. 11
0
    void Update()
    {
        if (UnityEngine.EventSystems.EventSystem.current.IsPointerOverGameObject())
        {
            return;
        }

        HexXY p = getMouseOverTile();

        //Info
        canvas.transform.Find("StatsPanel").Find("CursorCoordsText").GetComponent <Text>().text = p.x + " " + p.y + "\n" + Level.S.GetPFBlockedMap(p).ToString();

        //Drawing terrain
        if (Input.GetMouseButton(0) && brushCellType.HasValue)
        {
            if (p != brushOldMousePos)
            {
                if (currentTerrainPaint == null)
                {
                    currentTerrainPaint = new Undos.TerrainPaint();
                }
                currentTerrainPaint.Paint(p, brushSize, shouldPaintOnEmpty, brushCellType.Value);
            }

            brushOldMousePos = p;
        }
        else
        {
            brushOldMousePos = null;
            if (currentTerrainPaint != null)
            {
                var changedBlocks = Level.S.RecalcPassabilityOnEdges();
                foreach (var wb in changedBlocks)
                {
                    TerrainController.S.RecreateHexTerrain(wb);
                }

                undos.Push(currentTerrainPaint);
                redos.Clear();
                currentTerrainPaint = null;
            }
        }

        //Putting runes
        PutRunes(p);

        //Putting entities
        PutEntities(p);

        //Changing passability
        if (isInPassabilityMode && Input.GetMouseButtonDown(0))
        {
            ChangeStaticPassability(p);
        }

        if (isInTriggerSetMode && Input.GetMouseButtonDown(0))
        {
            ChangeTriggerZone(p);
        }

        //Undo and redo
        if (Input.GetKeyDown(KeyCode.BackQuote) && undos.Count > 0)
        {
            var op = undos.Pop();
            op.Undo();
            redos.Push(op);
        }
        else if (Input.GetKeyDown(KeyCode.Alpha1) && redos.Count > 0)
        {
            var op = redos.Pop();
            op.Redo();
            undos.Push(op);
        }
    }
Esempio n. 12
0
    void PutEntities(HexXY p)
    {
        if (!isInEntitySetMode)
        {
            return;
        }

        //Creating/selecting/rotating
        if (Input.GetMouseButtonDown(0))
        {
            if (Input.GetKey(KeyCode.LeftControl))
            {
                var ent = Level.S.GetEntities(p).FirstOrDefault();
                if (ent != null && ent is IRotatable && !(ent is Rune))
                {
                    var op = new Undos.RotateEntity(ent, p);
                    op.Rotate();
                    undos.Push(op);
                    redos.Clear();
                }
            }
            else
            {
                var existingEntity = Level.S.GetEntities(p).FirstOrDefault();
                if (existingEntity != null)
                {
                    Selection.activeGameObject = entities[existingEntity.graphicsHandle];
                    draggedEntity        = existingEntity;
                    draggedEntityOrigPos = draggedEntityCurrPos = existingEntity.pos;
                }
                else //TODO: make possible stacking entities with Alt or something?
                {
                    var prefab = Selection.activeGameObject;
                    if (prefab == null || PrefabUtility.GetPrefabType(prefab) == PrefabType.None)
                    {
                        return;
                    }
                    var gr = prefab.GetComponent <EntityGraphics>();
                    if (gr == null)
                    {
                        return;
                    }
                    var ent = gr.CreateEntity();
                    var op  = new Undos.AddEntity(ent, p);

                    op.Add();
                    undos.Push(op);
                    redos.Clear();
                }
            }
        }

        //Deleting
        if (Input.GetKeyDown(KeyCode.Space))
        {
            var ent = Level.S.GetEntities(p).FirstOrDefault();
            if (ent != null)
            {
                var op = new Undos.RemoveEntity(ent, p);
                op.Remove();
                undos.Push(op);
                redos.Clear();
            }
        }

        //Dragging
        if (draggedEntity != null)
        {
            if (Input.GetMouseButton(0))
            {
                //Drag
                if (p != draggedEntityCurrPos)
                {
                    var op = new Undos.MoveEntity(draggedEntity, draggedEntityCurrPos, p);
                    op.Move();
                    draggedEntityCurrPos = p;
                }
            }
            else
            {
                //Release
                if (draggedEntityCurrPos != draggedEntityOrigPos)
                {
                    var op = new Undos.MoveEntity(draggedEntity, draggedEntityOrigPos, draggedEntityCurrPos);
                    op.Move();
                    redos.Clear();
                    undos.Push(op);
                }
                draggedEntity = null;
            }
        }
    }
Esempio n. 13
0
 public RotateEntity(Entity ent, HexXY p)
 {
     this.ent = ent;
     this.p   = p;
 }
Esempio n. 14
0
    public void DrawWithBrush()
    {
        if (currentMousePos == null)
        {
            return;
        }

        HexXY coords = currentMousePos.Value.Coords;
        HashSet <Vector2Int> patchesChanged      = new HashSet <Vector2Int>();
        List <Vector2Int>    patchIndicesForCell = new List <Vector2Int>();

        for (int i = -brushSize + 1; i < brushSize; i++)
        {
            for (int j = -brushSize + 1; j < brushSize; j++)
            {
                if (HexXY.Dist(new HexXY(i, j), new HexXY(0, 0)) > brushSize - 1)
                {
                    continue;
                }

                HexXY   c    = coords + new HexXY(i, j);
                MapCell cell = map.GetCell(c);
                if (cell == map.externalCell)
                {
                    continue;
                }

                bool changed = false;
                switch (brushMode)
                {
                case BrushMode.Excavate:
                    if (cell.state != MapCell.State.Excavated)
                    {
                        changed    = true;
                        cell.state = MapCell.State.Excavated;
                    }
                    break;

                case BrushMode.Fill:
                    if (cell.state != MapCell.State.Full)
                    {
                        changed    = true;
                        cell.state = MapCell.State.Full;
                    }
                    break;
                }

                if (changed)
                {
                    HexMeshGenerator.ListPatchIndicesForCell(meshPatchSize, c, patchIndicesForCell);
                    foreach (Vector2Int pi in patchIndicesForCell)
                    {
                        patchesChanged.Add(pi);
                    }
                }
            }
        }

        if (patchesChanged.Count > 0)
        {
            //Fix outermost wall issues (when using ListPatchIndicesForCell it may happen that we don't redraw outermost walls)
            //We do this by adding cells just outside the brush if anything is changed
            for (int i = -brushSize; i < brushSize + 1; i++)
            {
                for (int j = -brushSize; j < brushSize + 1; j++)
                {
                    if (HexXY.Dist(new HexXY(i, j), new HexXY(0, 0)) == brushSize)
                    {
                        HexXY c = coords + new HexXY(i, j);
                        HexMeshGenerator.ListPatchIndicesForCell(meshPatchSize, c, patchIndicesForCell);
                        foreach (Vector2Int pi in patchIndicesForCell)
                        {
                            patchesChanged.Add(pi);
                        }
                    }
                }
            }
        }

        foreach (Vector2Int c in patchesChanged)
        {
            RecreateMapPatchMesh(c);
        }

        if (patchesChanged.Count > 0)
        {
            EditorUtility.SetDirty(map);
        }

        EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene());
    }
Esempio n. 15
0
 public virtual void Attack(HexXY p)
 {
 }
Esempio n. 16
0
 public ChangePassability(HexXY p)
 {
     this.p = p;
 }
Esempio n. 17
0
    public void Teleport(HexXY to)
    {
        Vector2 planeCoord = to.ToPlaneCoordinates();

        transform.position = new Vector3(planeCoord.x, 0, planeCoord.y);
    }
Esempio n. 18
0
 public override void Spawn(HexXY p)
 {
     base.Spawn(p);
     Level.S.SetPFBlockedMap(p, WorldBlock.PFBlockType.DynamicBlocked);
 }
Esempio n. 19
0
 public RemoveEntity(Entity ent, HexXY p)
 {
     this.ent = ent;
     this.p   = p;
 }
Esempio n. 20
0
 void EditorStart()
 {
     sourceSpellPos = ((Statue)entity).sourceSpellPos;
 }
Esempio n. 21
0
    public void GenerateMultiple(WorldBlock wb, float hexInset, float terrainTexScale)
    {
        int cellvcnt = cellVertices.Length;
        int celltcnt = cellTriangles.Length;

        var vertices  = new List <Vector3>();
        var normals   = new List <Vector3>();
        var uvs       = new List <Vector2>();
        var triangles = new List <int>();

        for (int k = 1; k < WorldBlock.terrainTypesCount; k++)
        {
            if (wb.cellTypeCounts[k] == 0)
            {
                continue;
            }

            string     terrainTypeName = ((TerrainCellType)k).ToString();
            GameObject obj             = new GameObject(terrainTypeName);
            obj.transform.SetParent(transform, false);
            var meshRenderer = obj.AddComponent <MeshRenderer>();
            var meshFilter   = obj.AddComponent <MeshFilter>();
            var mesh         = new Mesh();

            meshRenderer.sharedMaterial = (Material)Resources.Load("Terrain/" + terrainTypeName);

            for (int x = 0; x < WorldBlock.sz; x++)
            {
                for (int y = 0; y < WorldBlock.sz; y++)
                {
                    int ctype = (int)wb.GetCellType(new HexXY(x, y));
                    if (ctype != k)
                    {
                        continue;
                    }

                    //Main tile
                    HexXY   curr  = new HexXY(x, y);
                    Vector2 coord = curr.ToPlaneCoordinates();
                    for (int v = 0; v < cellvcnt; v++)
                    {
                        float vx = cellVertices[v].x + coord.x;
                        float vy = cellVertices[v].y + coord.y;

                        vertices.Add(new Vector3(vx, 0, vy));
                        uvs.Add(new Vector2(vx * terrainTexScale, vy * terrainTexScale));
                    }

                    for (int t = 0; t < celltcnt; t++)
                    {
                        triangles.Add(vertices.Count - cellvcnt + cellTriangles[t]);
                    }
                }
            }

            for (int i = 0; i < vertices.Count; i++)
            {
                normals.Add(new Vector3(0, 1, 0));
            }

            mesh.vertices  = vertices.ToArray();
            mesh.normals   = normals.ToArray();
            mesh.uv        = uvs.ToArray();
            mesh.triangles = triangles.ToArray();
            mesh.RecalculateBounds();

            meshFilter.mesh = mesh;

            vertices.Clear();
            normals.Clear();
            uvs.Clear();
            triangles.Clear();
        }

        //Grid
        GenetareNewGrid(wb, hexInset, vertices, normals, triangles);

        GenerateNewWalls(wb);
    }
Esempio n. 22
0
 public NearCells(int x1, int y1)
 {
     this.Count = 1;
     this.C1    = new HexXY(x1, y1);
     this.C2    = this.C3 = new HexXY();
 }
Esempio n. 23
0
    public void GenetareNewGrid(WorldBlock wb, float hexInset, List <Vector3> vertices, List <Vector3> normals, List <int> triangles)
    {
        var oldGrid = transform.Find("Grid");

        if (oldGrid != null)
        {
            Destroy(oldGrid.gameObject);
        }

        GameObject obj = new GameObject("Grid");

        obj.transform.SetParent(transform, false);
        obj.transform.localPosition = new Vector3(0, 0.005f, 0);
        var meshRenderer = obj.AddComponent <MeshRenderer>();
        var meshFilter   = obj.AddComponent <MeshFilter>();
        var mesh         = new Mesh();

        meshRenderer.sharedMaterial = (Material)Resources.Load("Terrain/Grid");

        float gridInsetOut = 1f, gridInsetIn = 0.925f;

        for (int x = 0; x < WorldBlock.sz; x++)
        {
            for (int y = 0; y < WorldBlock.sz; y++)
            {
                var blType = wb.pfBlockedMap[x, y];
                if (blType == WorldBlock.PFBlockType.StaticBlocked ||
                    blType == WorldBlock.PFBlockType.EdgeBlocked)
                {
                    continue;
                }
                Vector2 currCoord = new HexXY(x, y).ToPlaneCoordinates();

                int vertOffset = vertices.Count;
                for (int i = 0; i < 6; i++)
                {
                    Vector2 vertOut = cellVertices[i] * gridInsetOut + currCoord;
                    vertices.Add(new Vector3(vertOut.x, 0, vertOut.y));

                    Vector2 vertIn = cellVertices[i] * gridInsetIn + currCoord;
                    vertices.Add(new Vector3(vertIn.x, 0, vertIn.y));
                }

                for (int i = 0; i < 10; i += 2)
                {
                    triangles.Add(vertOffset + i);
                    triangles.Add(vertOffset + i + 2);
                    triangles.Add(vertOffset + i + 1);
                    triangles.Add(vertOffset + i + 1);
                    triangles.Add(vertOffset + i + 2);
                    triangles.Add(vertOffset + i + 3);
                }

                triangles.Add(vertOffset);
                triangles.Add(vertOffset + 11);
                triangles.Add(vertOffset + 10);

                triangles.Add(vertOffset);
                triangles.Add(vertOffset + 1);
                triangles.Add(vertOffset + 11);
            }
        }



        for (int i = 0; i < vertices.Count; i++)
        {
            normals.Add(new Vector3(0, 1, 0));
        }

        mesh.vertices  = vertices.ToArray();
        mesh.normals   = normals.ToArray();
        mesh.triangles = triangles.ToArray();
        mesh.RecalculateBounds();

        meshFilter.mesh = mesh;
    }
Esempio n. 24
0
 public override void Move(HexXY pos, float timeToGetThere)
 {
     //Debug.Log(entityHandle + " move " + args.pos);
     MovePrecise(pos.ToPlaneCoordinates(), timeToGetThere);
 }
Esempio n. 25
0
File: G.cs Progetto: Dzugaru/hexes
    static void PerformInterfaceSpawn(Interfacing.EntityHandle objHandle, HexXY pos, uint dir)
    {
        GameObject obj = entities[objHandle];

        obj.GetComponent <EntityGraphics>().Spawn(pos, dir);
    }
Esempio n. 26
0
 public virtual void Move(HexXY pos, float timeToGetThere)
 {
 }
Esempio n. 27
0
File: G.cs Progetto: Dzugaru/hexes
    static void PerformInterfaceStop(Interfacing.EntityHandle objHandle, HexXY pos)
    {
        GameObject obj = entities[objHandle];

        obj.GetComponent <EntityGraphics>().Stop(pos);
    }
Esempio n. 28
0
 public MapCellAndCoords(MapCell cell, HexXY coords)
 {
     this.Cell   = cell;
     this.Coords = coords;
 }