Пример #1
0
        public List <MapElement> CreateOpenablePortal(RCT rct, string innername, string outername, string outsidename)
        {
            Portal     exit       = new Portal(rct, floorNumber, innername, outername, true);
            RCT        doorRCT    = CreatePortal(exit);
            MapElement mapElement = Stage.GetNode(doorRCT.Start, GetFloorNumber()).mapElement;
            Portal     entrence;

            if (mapElement.GetType() == typeof(Building))
            {
                entrence = new Portal(doorRCT, floorNumber, innername, outsidename, false);
                Building building = mapElement as Building;
                building.CreatePortal(entrence);
            }
            else
            {
                entrence = new Portal(doorRCT, floorNumber, outername, outsidename, false);
                Room room = mapElement as Room;
                room.CreatePortal(entrence);
            }
            Portal.Bind(exit, entrence);
            return(new List <MapElement>()
            {
                exit, entrence
            });
        }
Пример #2
0
 // Use this for initialization
 void Start()
 {
     CameraMoving.instance.SetMapLengths(Stage.GetStage().rct.Height, Stage.GetStage().rct.Width);
     pathfinder     = new Pathfinder();
     activeUnitNode = Stage.GetNode(new CRD(27, 16));
     //UnitsGenerator.instance.enabled = true;
 }
Пример #3
0
        public List <MapElement> CreateDoublePortal(CRD crd, bool openable = false)
        {
            string crdDirection = rct.GetDirection(crd), twinNode;

            switch (crdDirection)
            {
            case "l":
                twinNode = "b";
                break;

            case "r":
                twinNode = "t";
                break;

            case "t":
                twinNode = "l";
                break;

            case "b":
                twinNode = "r";
                break;

            default:
                twinNode = "t";
                break;
            }
            CRD twinCRD = Stage.GetNode(crd).GetSibling(twinNode).crd;
            List <MapElement> RightPortals;
            List <MapElement> LeftPortals;

            if (openable)
            {
                RightPortals = CreateOpenablePortal(new RCT(crd, crd), "InnerDoubleDoorR", "InnerDoublePortalL", "OuterDoublePortalL");
                LeftPortals  = CreateOpenablePortal(new RCT(twinCRD, twinCRD), "InnerDoubleDoorL", "InnerDoublePortalR", "OuterDoublePortalR");
            }
            else
            {
                RightPortals = CreateOpenablePortal(new RCT(crd, crd), "InnerDoublePortalR", "InnerDoublePortalL", "OuterDoublePortalL");
                LeftPortals  = CreateOpenablePortal(new RCT(twinCRD, twinCRD), "InnerDoublePortalL", "InnerDoublePortalR", "OuterDoublePortalR");
            }
            List <MapElement> list = new List <MapElement>();

            for (int i = 0; i < 2; i++)
            {
                Portal p1 = RightPortals[i] as Portal;
                Portal p2 = LeftPortals[i] as Portal;
                Portal.BindTwin(p1, p2);
            }
            list.AddRange(RightPortals);
            list.AddRange(LeftPortals);
            return(list);
        }
Пример #4
0
        public List <Node> GetMapElementSiblingdsNoDiagonals()
        {
            List <Node> siblings = new List <Node>();

            for (int x = -1; x <= 1; x++)
            {
                for (int z = -1; z <= 1; z++)
                {
                    Node node = Stage.GetNode(crd.x + x, crd.z + z, floor.number);
                    if ((z == 0 && x == 0) || (!mapElement.childNodes.Contains(node)) || (z != 0 && x != 0))
                    {
                        continue;
                    }
                    siblings.Add(node);
                }
            }
            return(siblings);
        }
Пример #5
0
        public List <Node> GetSiblingsNoDiagonals()// Получение соседних узлов
        {
            List <Node> siblings = new List <Node>();
            RCT         rct      = Stage.GetStage().rct;

            for (int x = -1; x <= 1; x++)
            {
                for (int z = -1; z <= 1; z++)
                {
                    if ((z == 0 && x == 0) || !rct.isContainCRD(new CRD(crd.x + x, crd.z + z)) || (z != 0 && x != 0))
                    {
                        continue;
                    }
                    siblings.Add(Stage.GetNode(crd.x + x, crd.z + z, floor.number));
                }
            }
            return(siblings);
        }
Пример #6
0
 public override void HookAfterAddNodesToMapElement()
 {
     foreach (Node node in childNodes)
     {
         node.isWalkable = true;
         for (int x = -1; x <= 1; x++)
         {
             for (int z = -1; z <= 1; z++)
             {
                 CRD crd = new CRD(node.x + x, node.z + z);
                 if ((x != 0 || z != 0) && rct.isContainCRD(crd))
                 {
                     float w = 1;
                     if (x != 0 && z != 0)
                     {
                         w = 1.5f;
                     }
                     node.LinkNode(Stage.GetNode(crd, floorNumber), w);
                 }
             }
         }
     }
 }
Пример #7
0
        private void GenerateSurface()// генерация поверхности
        {
            float extraHeight = 0;

            if (floor.number == 0)
            {
                extraHeight = 0;
            }
            if (floor.number == 1)
            {
                extraHeight = 3.075f;
            }
            if (floor.number > 1)
            {
                Node prevFloorNode = Stage.GetNode(crd, floor.number - 1);
                if (!prevFloorNode.empty)
                {
                    Debug.Log(name + " prev -> " + prevFloorNode.name);
                    extraHeight = prevFloorNode.mapElement.extraHeight;
                }
            }
            Vector3    rotation     = GetRotation();
            Vector3    position     = new Vector3(crd.x, extraHeight, crd.z);
            GameObject cellInstance = GameObject.Instantiate(Game.GameManager.instance.Cell, position, Quaternion.Euler(rotation)) as GameObject;

            cellInstance.transform.name = name;
            Cell = cellInstance;
            Cell.GetComponent <CellController>().node = this;
            Cell.transform.SetParent(MapManager.instance.gameObject.transform);

            if (this.surface != "None")
            {
                GameObject surface = GameObject.Instantiate(Resources.Load("Stage/" + this.floor.stage.DesignName + "/Premetives/Surface/" + this.surface + "/" + this.order + "/" + this.prefabNumber), position, Quaternion.Euler(rotation)) as GameObject;
                surface.transform.SetParent(Cell.transform);
            }
        }
Пример #8
0
 public static Node GetNode(int x, int z)
 {
     return(Stage.GetNode(new CRD(x, z)));
 }
Пример #9
0
 public static Node GetNode(int x, int z, int floornumber)
 {
     return(Stage.GetNode(new CRD(x, z), floornumber));
 }
Пример #10
0
        public void RenderBackground()//Добавление фона карты
        {
            //stage.groundFloor
            Node[,] map = stage.floors.Find(x => x.number == stage.groundFloor).map;
            // left side
            int sbg = 0, ebg = 0;

            for (int x = 0; x < map.GetLength(0); x++)
            {
                Node       node       = Stage.GetNode(x, stage.rct.Start.z);
                MapElement mapElement = node.mapElement.GetParentByClass(typeof(Street));

                if (mapElement.GetType() == typeof(Street))
                {
                    Street street = mapElement as Street;
                    if (street.axis == 'h')
                    {
                        createQuads(new CRD(sbg, stage.rct.Start.z - 1), new Vector3(0, 0, 0), ebg - sbg + 1);
                        int sx = x;
                        int ex = x + mapElement.rct.Height - 1;
                        x   = ex + 1;
                        sbg = x;
                        BackgroundStreet bgStreet = new BackgroundStreet(new RCT(new CRD(sx, stage.rct.Start.z - 25), new CRD(ex, stage.rct.Start.z - 1)), street.axis, street.sidewalk);
                    }
                }
                else
                {
                    ebg = x;
                }
            }
            createQuads(new CRD(sbg, stage.rct.Start.z - 1), new Vector3(0, 0, 0), ebg - sbg + 1);
            //right side
            sbg = 0; ebg = 0;
            for (int x = 0; x < map.GetLength(0); x++)
            {
                Node       node       = Stage.GetNode(x, stage.rct.End.z);
                MapElement mapElement = node.mapElement.GetParentByClass(typeof(Street));
                if (mapElement.GetType() == typeof(Street))
                {
                    Street street = mapElement as Street;
                    if (street.axis == 'h')
                    {
                        createQuads(new CRD(sbg, stage.rct.End.z + 1), new Vector3(0, 180, 0), ebg - sbg + 1);
                        int sx = x;
                        int ex = x + mapElement.rct.Height - 1;
                        x   = ex + 1;
                        sbg = x;
                        BackgroundStreet bgStreet = new BackgroundStreet(new RCT(new CRD(sx, stage.rct.End.z + 1), new CRD(ex, stage.rct.End.z + 25)), street.axis, street.sidewalk);
                    }
                }
                else
                {
                    ebg = x;
                }
            }
            createQuads(new CRD(sbg, stage.rct.End.z + 1), new Vector3(0, 180, 0), ebg - sbg + 1);
            //top side
            sbg = 0; ebg = 0;
            for (int z = 0; z < map.GetLength(1); z++)
            {
                Node       node       = Stage.GetNode(stage.rct.Start.x, z);
                MapElement mapElement = node.mapElement.GetParentByClass(typeof(Street));
                if (mapElement.GetType() == typeof(Street))
                {
                    Street street = mapElement as Street;
                    if (street.axis == 'v')
                    {
                        createQuads(new CRD(stage.rct.Start.x - 1, sbg), new Vector3(0, 90, 0), ebg - sbg + 1);
                        int sz = z;
                        int ez = z + mapElement.rct.Width - 1;
                        z   = ez + 1;
                        sbg = z;
                        BackgroundStreet bgStreet = new BackgroundStreet(new RCT(new CRD(stage.rct.Start.x - 25, sz), new CRD(stage.rct.Start.x - 1, ez)), street.axis, street.sidewalk);
                    }
                }
                else
                {
                    ebg = z;
                }
            }
            createQuads(new CRD(stage.rct.Start.x - 1, sbg), new Vector3(0, 90, 0), ebg - sbg + 1);
            //bottom side
            sbg = 0; ebg = 0;
            for (int z = 0; z < map.GetLength(1); z++)
            {
                Node       node       = Stage.GetNode(stage.rct.End.x, z);
                MapElement mapElement = node.mapElement.GetParentByClass(typeof(Street));
                if (mapElement.GetType() == typeof(Street))
                {
                    Street street = mapElement as Street;
                    if (street.axis == 'v')
                    {
                        createQuads(new CRD(stage.rct.End.x + 1, sbg), new Vector3(0, 270, 0), ebg - sbg + 1);
                        int sz = z;
                        int ez = z + mapElement.rct.Width - 1;
                        z   = ez + 1;
                        sbg = z;
                        BackgroundStreet bgStreet = new BackgroundStreet(new RCT(new CRD(stage.rct.End.x + 1, sz), new CRD(stage.rct.End.x + 25, ez)), street.axis, street.sidewalk);
                    }
                }
                else
                {
                    ebg = z;
                }
            }
            createQuads(new CRD(stage.rct.End.x + 1, sbg), new Vector3(0, 270, 0), ebg - sbg + 1);
            createQuad(new CRD(-1, -1), new Vector3(0, 45, 0), -1);
            createQuad(new CRD(-1, stage.width), new Vector3(0, 135, 0), -1);
            createQuad(new CRD(stage.height, -1), new Vector3(0, -45, 0), -1);
            createQuad(new CRD(stage.height, stage.width), new Vector3(0, -135, 0), -1);
        }