private void LateUpdate()
        {
            var ortho = mainCamera.orthographicSize;
            var cameraWorldHalfSize = new Vector3(mainCamera.aspect * ortho, ortho, 0);
            var minVector           =
                HexGridUtils.ConvertOffsetToWorldCoordinates(new Vector2Int(mapService.CurrentPlayerMap.visibleMinX - 1,
                                                                            mapService.CurrentPlayerMap.visibleMaxY + 1)) + cameraWorldHalfSize;

            minVector.y -= bottomOffset;
            var maxVector =
                HexGridUtils.ConvertOffsetToWorldCoordinates(new Vector2Int(mapService.CurrentPlayerMap.visibleMaxX + 1,
                                                                            mapService.CurrentPlayerMap.visibleMinY - 1)) - cameraWorldHalfSize;

            maxVector.y += topOffset;
            var position = transform.position;

            if (minVector.x > maxVector.x)
            {
                var xMiddle = (mapService.CurrentPlayerMap.visibleMaxX + mapService.CurrentPlayerMap.visibleMinX) / 2;
                var cameraOffsetPosition = HexGridUtils.ConvertOffsetToWorldCoordinates(new Vector2Int(xMiddle, 0));
                minVector.x = cameraOffsetPosition.x;
                maxVector.x = cameraOffsetPosition.x;
            }

            if (minVector.y > maxVector.y)
            {
                var yMiddle = (mapService.CurrentPlayerMap.visibleMaxY + mapService.CurrentPlayerMap.visibleMinY) / 2;
                var cameraOffsetPosition = HexGridUtils.ConvertOffsetToWorldCoordinates(new Vector2Int(0, yMiddle));
                minVector.y = cameraOffsetPosition.y;
                maxVector.y = cameraOffsetPosition.y;
            }


            if (position.x < minVector.x)
            {
                position.x = minVector.x;
            }

            if (position.y < minVector.y)
            {
                position.y = minVector.y;
            }
            if (position.x > maxVector.x)
            {
                position.x = maxVector.x;
            }

            if (position.y > maxVector.y)
            {
                position.y = maxVector.y;
            }

            transform.position = position;
        }
Esempio n. 2
0
 private void HandleTap(LeanFinger finger)
 {
     if (!finger.IsOverGui)
     {
         var worldPosition = Camera.main.ScreenToWorldPoint(finger.ScreenPosition);
         var tileCoords    = HexGridUtils.ConvertWorldToOffsetCoordinates(worldPosition);
         var tile          = currentMap.tiles.Find(t => t.posX == tileCoords.x && t.posY == tileCoords.y);
         if (tile != null)
         {
             HandleTileTap(tile);
         }
     }
 }
Esempio n. 3
0
        private void RecenterCamera()
        {
            var mainCamera     = Camera.main;
            var cameraPosition = new Vector3(0f, 0f, mainCamera.transform.position.z);

            var xMiddle = (currentMap.maxX + currentMap.minX) / 2;
            var yBottom = currentMap.maxY;

            var cameraOffsetPosition = HexGridUtils.ConvertOffsetToWorldCoordinates(new Vector2Int(xMiddle, yBottom));

            cameraOffsetPosition.y       += mainCamera.orthographicSize - 1.7f;
            mainCamera.transform.position = cameraPosition + cameraOffsetPosition;
        }
        public void SetPlayerTile(PlayerMap map, PlayerMapTile tile, MapTileConfig mapTileConfig)
        {
            PosX = tile.posX;
            PosY = tile.posY;

            transform.localPosition = HexGridUtils.ConvertOffsetToWorldCoordinates(new Vector2Int(tile.posX, tile.posY));
            gameObject.name         = $"X{tile.posX} Y{tile.posY} {tile.type}";

            background.sprite = mapTileConfig.MapTileTypeConfig[tile.type];
            var baseLayer = 10 * tile.posY;

            background.sortingOrder = baseLayer;

            var bottomLeftEmpty  = tile.discovered && BottomLeftEmpty(map, tile);
            var bottomRightEmpty = tile.discovered && BottomRightEmpty(map, tile);

            if (bottomLeftEmpty && bottomRightEmpty)
            {
                AddIcon(mapTileConfig.bottomLeftAndRightEmpty, baseLayer + LAYER_FAKE_3D, 1f, Vector2.zero);
            }
            else if (bottomLeftEmpty)
            {
                AddIcon(mapTileConfig.bottomLeftEmpty, baseLayer + LAYER_FAKE_3D, 1f, Vector2.zero);
            }
            else if (bottomRightEmpty)
            {
                AddIcon(mapTileConfig.bottomRightEmpty, baseLayer + LAYER_FAKE_3D, 1f, Vector2.zero);
            }

            if (tile.discovered)
            {
                if (tile.structure != null || (tile.fightIcon != null && (tile.fightRepeatable == true || tile.victoriousFight == false)))
                {
                    AddIcon(mapTileConfig.whiteTile, baseLayer + LAYER_WHITE, 1f, Vector2.zero, new Color {
                        a = 0.35f, b = 1f, g = 1f, r = 1f
                    });
                }

                if (tile.structure != null)
                {
                    var tileToSprite = mapTileConfig.MapStructureConfig[(MapTileStructure)tile.structure];
                    AddIcon(tileToSprite.sprite, baseLayer + LAYER_STRUCTURE, tileToSprite.scale, tileToSprite.offset);
                }

                if (tile.fightIcon != null && (tile.fightRepeatable == true || tile.victoriousFight == false))
                {
                    var fightToSprite = mapTileConfig.MapFightConfig[(FightIcon)tile.fightIcon];
                    AddIcon(fightToSprite.sprite, baseLayer + LAYER_FIGHT, fightToSprite.scale, fightToSprite.offset);
                }
            }
            else if (tile.discoverable)
            {
                AddIcon(mapTileConfig.whiteTile, baseLayer + LAYER_WHITE, 1f, Vector2.zero, new Color {
                    a = 0.75f, b = 1f, g = 1f, r = 1f
                });
                AddIcon(mapTileConfig.discoverIcon, baseLayer + LAYER_STRUCTURE, mapTileConfig.discoverScale, mapTileConfig.discoverOffset, text: map.discoverySteamCost.ToString());
                someText.text = map.discoverySteamCost.ToString();
                someText.gameObject.SetActive(true);
                someText.gameObject.GetComponent <MeshRenderer>().sortingOrder = baseLayer + LAYER_STRUCTURE_TEXT;
                var locPos = someText.transform.localPosition;
                locPos.y += mapTileConfig.discoverOffset.y;
                someText.transform.localPosition = locPos;
            }

            progress.sortingOrder           = baseLayer + LAYER_PROGRESS;
            progressBackground.sortingOrder = baseLayer + LAYER_PROGRESS_BACKGROUND;
            progressBar.sortingOrder        = baseLayer + LAYER_PROGRESS_BAR;
        }