Пример #1
0
    void Awake()
    {
        connectedRoads = new List<Road>();

        roadMgr = FindObjectOfType<RoadManager>();
        highlighter = gameObject.AddComponent<Highlighter>();

        gameObject.name = string.Format("Node{0}", gameObject.GetInstanceID());
    }
Пример #2
0
 void Awake()
 {
     if (s_instance == null) {
         s_instance = this;
     }
     else {
         if (s_instance!=this) {
             Destroy(gameObject);
         }
     }
 }
Пример #3
0
    // Use this for initialization
    void Awake()
    {
        score = 0;

        playerController = GameObject.Find("Player").GetComponent<PlayerController>();
        roadManager = GameObject.Find("RoadManager").GetComponent<RoadManager>();
        spawner = GameObject.Find("Spawner").GetComponent<Spawner>();
        scoreText = GameObject.Find("ScoreText").GetComponent<Text>();
        restartText = GameObject.Find("ScoreCanvas").transform.GetChild(1).GetComponent<Text>();
        restartText.enabled = false;
    }
Пример #4
0
    void Start()
    {
        AudioSource[] sources = GetComponents<AudioSource>();
        mainSong = sources[0];

        time = 0;
        waveStartTime = restDuration;
        waveCounter = 1;
        countdown = GameObject.Find("GameStuff").GetComponent<Countdown>();
        countdown.SetCountdownDuration(countdownDuration);
        roadManager = GameObject.Find("RoadManager").GetComponent<RoadManager>();
        lastPlayerNode = roadManager.playerNode;
        status = Status.Rest;
        initFov = Camera.main.fov;

        StartCoroutine(StartSongDelay(5));
    }
Пример #5
0
    void Start()
    {
        AudioSource[] sources = GetComponents<AudioSource>();
        engineSound = sources[2];
        engineStart = sources[3];

        roadManager = GameObject.Find("RoadManager").GetComponent<RoadManager>();
        ship = transform.FindChild("Ship");
        time = 0;
        direction = transform.forward * speed;
        offset = 0;
        basePosition = new Vector3(0, 0, 0);
        tiltTime = 0;
        initSpeed = speed;
        speed = initSpeed / 1.5f;

        engineStart.Play();
        engineSound.loop = true;
        engineSound.Play();
    }
    public override void Awake()
    {
        StageController.Instance = this;
        var         go          = GameObject.Find("GameRoot");
        RoadManager roadManager = null;

        if (go != null)
        {
            roadManager = go.GetComponent <RoadManager>();
            if (roadManager != null)
            {
                // init ink from roadManager
                UpdateInk(roadManager.Ink);
            }
        }

        // handle clear event
        this.UpdateAsObservable()
        .Where(_ => this.unityChan.transform.position.x >= this.stageClearPoint.position.x)
        .First()
        .Subscribe(_ =>
        {
            this.IsCleared = true;
            // after 2s
            Observable.Timer(TimeSpan.FromSeconds(2f))
            .Subscribe(__ =>
            {
                AppController.Instance.SetResult(this.Coin, this.Damage, roadManager.UsedInk);
                Application.LoadLevel("Result");
            });
        });

        this.Coin = 0;

        base.Awake();
    }
Пример #7
0
    // Start is called before the first frame update
    void Start()
    {
        _resourceManager = FindObjectOfType <ResourceManager>();

        if (OilExtractor.ExtractedOilSlick.type == OilSlickType.Land)
        {
            OilVehicle        = OilTruck;
            LoadedOilCapacity = 100f;
        }
        else
        {
            OilVehicle        = OilTanker;
            LoadedOilCapacity = 1_000f;
        }
        //OilVehicle.SetActive(true);
        //OilVehicle.transform.position = OilExtractor.DockingArea.transform.position;

        City.RegisterTradeRoute(this);
        OilExtractor.RegisterTradeRoute(this);

        _roadManager = OilExtractor.ExtractedOilSlick.type == OilSlickType.Land ? GameObject.FindGameObjectWithTag("TruckRoadManager").GetComponent <RoadManager>() :
                       GameObject.FindGameObjectWithTag("SeaLaneManager").GetComponent <RoadManager>();
        _roadManager.GenerateTradeRoutePath(this);
    }
Пример #8
0
        public void SpawnVehicle()
        {
            if (!bIsSpawner)
            {
                return;
            }
            if (DijkstraTable.Table.Count == 0)
            {
                DijkstraTable = RoadManager.CalculatePathTable(this);
            }

            Connection selectedRoad  = Roads[0];
            GameObject vehicleObject = Instantiate(Resources.Load("TestVehiclePrefab") as GameObject);
            Vehicle    veh           = vehicleObject.GetComponent <Vehicle>();

            veh.StartIntersectionPoint = this;
            while (veh.Route.Count <= 2)
            {
                veh.EndIntersectionPoint = RoadManager.GetRandomOtherIntersectionPoint(this);
                veh.Route = RoadManager.CalculateRoute(DijkstraTable, veh.StartIntersectionPoint,
                                                       veh.EndIntersectionPoint);
            }
            veh.ConvertRouteToPath();
        }
        public void RoadManagerTestsGetStatusWithoutNeighbor()
        {
            var results = RoadManager.GetRoadNeighborStatus(new Vector3(27, 0, 27), _grid, null);

            Assert.AreEqual(0, results);
        }
Пример #10
0
 private void checkBox1_CheckedChanged(object sender, EventArgs e)
 {
     RoadManager.setContinuousCreationMode(checkBox1.Checked);
 }
Пример #11
0
 void Awake()
 {
     _Instance = this;
 }
Пример #12
0
        public void RoadManagerTestsGetStatusNeighbourUpRight()
        {
            var result = RoadManager.GetRoadNeighboursStatus(new Vector3(3, 0, 3), grid, null);

            Assert.AreEqual((int)Direction.Up | (int)Direction.Right, result);
        }
Пример #13
0
        public void RoadManagerTestsGetStatusNoNeighbours()
        {
            var result = RoadManager.GetRoadNeighboursStatus(new Vector3(27, 0, 27), grid, null);

            Assert.AreEqual(0, result);
        }
Пример #14
0
        public void RoadManagerTestsGetStatusNeighbourDownUpLeftRight()
        {
            var result = RoadManager.GetRoadNeighboursStatus(new Vector3(6, 0, 6), grid, null);

            Assert.AreEqual((int)Direction.Up | (int)Direction.Down | (int)Direction.Left | (int)Direction.Right, result);
        }
        public void RoadManagerTestsGetStatusNeighborIsDownRight()
        {
            var results = RoadManager.GetRoadNeighborStatus(new Vector3(3, 0, 9), _grid, null);

            Assert.AreEqual((int)Direction.Down | (int)Direction.Right, results);
        }
Пример #16
0
    void DFSNextRoad(Vector2Int currTile) //get the next block to go
    {
        RoadManager roadManager = MapManager.GetInstance().GetRoadManager();

        if (roadManager == null)
        {
            return;
        }

        List <Vector2Int> neighbourRoads = new List <Vector2Int>();

        //check up first, if never visited and theres a tile there add it
        Vector2Int newGridoffsetPos = currTile + new Vector2Int(0, 1);

        if (roadManager.CheckMapAvailability(newGridoffsetPos) && !m_VistedRoads.ContainsKey(newGridoffsetPos))
        {
            neighbourRoads.Add(newGridoffsetPos);
        }

        //check down
        newGridoffsetPos = currTile + new Vector2Int(0, -1);
        if (roadManager.CheckMapAvailability(newGridoffsetPos) && !m_VistedRoads.ContainsKey(newGridoffsetPos))
        {
            neighbourRoads.Add(newGridoffsetPos);
        }

        //check right
        newGridoffsetPos = currTile + new Vector2Int(1, 0);
        if (roadManager.CheckMapAvailability(newGridoffsetPos) && !m_VistedRoads.ContainsKey(newGridoffsetPos))
        {
            neighbourRoads.Add(newGridoffsetPos);
        }

        //check left
        newGridoffsetPos = currTile + new Vector2Int(-1, 0);
        if (roadManager.CheckMapAvailability(newGridoffsetPos) && !m_VistedRoads.ContainsKey(newGridoffsetPos))
        {
            neighbourRoads.Add(newGridoffsetPos);
        }

        if (neighbourRoads.Count == 0) //if theres nothing
        {
            //look into the queue to see if theres any other previous roads
            //if queue is empty, reset the position to NPC current tile and reset the visited list
            if (m_RoadsQueue.Count == 0)
            {
                m_VistedRoads.Clear();
                DFSNextRoad(m_CurrentTile);
            }
            else
            {
                int        lastAddedIndex = m_RoadsQueue.Count - 1;
                Vector2Int prev           = m_RoadsQueue[lastAddedIndex];
                m_RoadsQueue.RemoveAt(lastAddedIndex); //remove the last element added

                InitNextTile(prev);
            }
        }
        else //go to next neighbouring tile
        {
            m_RoadsQueue.Add(m_CurrentTile);

            int randomNeighbourIndex = Random.Range(0, neighbourRoads.Count);
            InitNextTile(neighbourRoads[randomNeighbourIndex]);
        }
    }
Пример #17
0
 private void button4_Click(object sender, EventArgs e)
 {
     RoadManager.maskSelectedRoadTerrain();
 }
Пример #18
0
 private void button5_Click(object sender, EventArgs e)
 {
     RoadManager.smoothSelectedRoadTerrain();
 }
Пример #19
0
 private void button3_Click(object sender, EventArgs e)
 {
     RoadManager.snapSelectedRoadToTerrain();
 }
Пример #20
0
 private void button2_Click(object sender, EventArgs e)
 {
     RoadManager.collapseSelectedPoints();
 }
Пример #21
0
 private void button1_Click(object sender, EventArgs e)
 {
     RoadManager.splitSelectedPoints();
 }
Пример #22
0
 private void checkBox2_CheckedChanged(object sender, EventArgs e)
 {
     RoadManager.setSnapToPrimeMode(checkBox2.Checked);
 }
        public void RoadManagerTestsGetStatusNeighborIsOnTheLeft()
        {
            var results = RoadManager.GetRoadNeighborStatus(new Vector3(18, 0, 6), _grid, null);

            Assert.AreEqual((int)Direction.Left, results);
        }
        public void RoadManagerTestsGetStatusNeighborIsUp()
        {
            var results = RoadManager.GetRoadNeighborStatus(new Vector3(6, 0, 0), _grid, null);

            Assert.AreEqual((int)Direction.Up, results);
        }
Пример #25
0
    private static int showRoadNowNum = 0;//当前显示到的路径的长度


    void Awake()
    {
        instance  = this;
        roadMaker = new GeneralRoadMaker();
    }
Пример #26
0
 public NetInfoLane(NetInfo.Lane lane, RoadManager.VehicleType vehicleTypes, SpecialLaneType specialLaneType = SpecialLaneType.None) : this(vehicleTypes, specialLaneType)
 {
     CopyAttributes(lane);
 }
Пример #27
0
 // Start is called before the first frame update
 void Start()
 {
     roadSpawner = GetComponent <RoadManager>();
 }
Пример #28
0
        public void RoadManagerTestsGetNeighboursRight()
        {
            var result = RoadManager.GetRoadNeighboursForPosition(grid, new Vector3Int(0, 0, 6));

            Assert.IsTrue(result.ContainsKey(new Vector3Int(3, 0, 6)));
        }
Пример #29
0
 private void Spawn()
 {
     RoadManager.NumberOfVehicles++;
     RoadManager.GetRandomIntersectionPoint().SpawnVehicle();
 }
Пример #30
0
        public void RoadManagerTestsGetStatusNeighbourDownLeft()
        {
            var result = RoadManager.GetRoadNeighboursStatus(new Vector3(15, 0, 9), grid, null);

            Assert.AreEqual((int)Direction.Down | (int)Direction.Left, result);
        }
Пример #31
0
 public NetInfoLane(RoadManager.VehicleType vehicleTypes, SpecialLaneType specialLaneType = SpecialLaneType.None)
 {
     this.m_allowedVehicleTypes = vehicleTypes;
     this.m_specialLaneType = specialLaneType;
 }
Пример #32
0
 private void OnEnable()
 {
     roadManager = GameObject.FindObjectOfType <RoadManager>();
 }
Пример #33
0
        private void readConnection(JsonTextReader reader, JsonSerializer serializer, RoadManager roads, List <Node> nodes, out Node start, out Vector3 startTangent, out Vector3 startOffset)
        {
            start        = null;
            startTangent = new Vector3(float.NaN, float.NaN, float.NaN);
            startOffset  = new Vector3(float.NaN, float.NaN, float.NaN);
            if (reader.Read())
            {
                if (reader.TokenType == JsonToken.StartObject)
                {
                    int depth = reader.Depth;
                    do
                    {
                        if (reader.Read())
                        {
                            if (reader.TokenType == JsonToken.PropertyName)
                            {
                                switch ((string)reader.Value)
                                {
                                case Constants.TAG_SEGMENT_CONNECTION_NODE:
                                {
                                    int nodeID = reader.ReadAsInt32() ?? -1;
                                    start = nodes[nodeID];
                                }
                                break;

                                case Constants.TAG_SEGMENT_CONNECTION_TANGENT:
                                {
                                    if (reader.Read())
                                    {
                                        startTangent = serializer.Deserialize <Vector3D>(reader);
                                    }
                                }
                                break;

                                case Constants.TAG_SEGMENT_CONNECTION_OFFSET:
                                {
                                    if (reader.Read())
                                    {
                                        startOffset = serializer.Deserialize <Vector3D>(reader);
                                    }
                                }
                                break;
                                }
                            }
                        }
                    } while (reader.Depth > depth);
                }
            }
        }
Пример #34
0
    /**********************************************************************************/
    // функция генерирует внутренности блока
    //
    // порядок генерации объектов:
    // - Здания
    // - Дороги
    // - Генерируемое окружение
    /**********************************************************************************/
    void GenerateBlockContent(GameObject block, BlockDescriptor descriptor, int x, int y)
    {
        // определяемся с ограничениями на соединение дорог
        RoadManager.GetInstance().SetRoadRulesToBlock(descriptor, x, y);


        // обновляем карту занятых и свободных клеток
        descriptor.UpdateFreeSpaceMap(SizeOfBlocks);


        // определяем тип блока для генерации
        Base.BLOCK_TYPE blockToGenerate = GetBlockTypeToGenerate();

        // олучаем настройки для данного блока из библиотеки блоков
        BlockSettings settingsForGeneration = BlockLibrary.GetInstance().GetBlockSettings(blockToGenerate);

        // устанавливаем здания
        // для это выбираем его(их) из имеющейся коллекции
        List <GameObject> toInstantiateCollection = GetBuildingToInstance(settingsForGeneration);

        foreach (GameObject toInstantiate in toInstantiateCollection)
        {
            // получаем контроллер у объекта шаблона, он нам потребуется для определения размеров здания
            BuildingController bcOfPattern = toInstantiate.GetComponent <BuildingController>();

            // пробуем установить здание в блок
            bool success  = false;
            int  attempts = 10;
            while (!success && attempts > 0)
            {
                int xBuildingSize = bcOfPattern.XBuildingSize;
                int yBuildingSize = bcOfPattern.YBuildingSize;


                int xCorToPlace = Random.Range(0, (descriptor.xSize * SizeOfBlocks) - xBuildingSize + 1);
                int yCorToPlace = Random.Range(0, (descriptor.ySize * SizeOfBlocks) - yBuildingSize + 1);

                bool isPossible = true;

                // проверяем тушку здания
                for (int xCorToCheck = xCorToPlace; xCorToCheck < xCorToPlace + xBuildingSize; xCorToCheck++)
                {
                    for (int yCorToCheck = yCorToPlace; yCorToCheck < yCorToPlace + yBuildingSize; yCorToCheck++)
                    {
                        if (descriptor.FreeSpaceMap[xCorToCheck, yCorToCheck] != true)
                        {
                            isPossible = false;
                        }
                    }
                }

                // проверяем точку выхода из здания
                if (isPossible)
                {
                    Point roadPoint = new Point(xCorToPlace, yCorToPlace) + bcOfPattern.RoadPoint;
                    if (roadPoint.x < 0 || roadPoint.y < 0 || roadPoint.x >= SizeOfBlocks || roadPoint.y >= SizeOfBlocks)
                    {
                        isPossible = false;
                    }
                    else
                    {
                        if (descriptor.FreeSpaceMap[roadPoint.x, roadPoint.y] != true)
                        {
                            isPossible = false;
                        }
                    }
                }

                // если получилось подобрать координаты, устанавливаем новое здание в позицию и выходим из цикла
                if (isPossible)
                {
                    // правильные координаты будут выставлены несколькими шагами дальше через localPosition
                    GameObject instance = Instantiate(toInstantiate, new Vector3(0.0f, 0.0f, 0.0f), Quaternion.identity) as GameObject;

                    // устанавливаем в родителя
                    instance.transform.SetParent(block.transform);
                    instance.transform.localPosition = new Vector3((float)(xCorToPlace + xBuildingSize / 2) * SizeOfCell,
                                                                   (float)(yCorToPlace + yBuildingSize / 2) * SizeOfCell, 0.0f);

                    // сохраняем ссылку на все сгенерированные здания
                    descriptor.Buildings.Add(instance);

                    // обновляем карту свободных клеток в блоке
                    descriptor.UpdateFreeSpaceMap(SizeOfBlocks);

                    success = true;
                }

                // уменьшаем оставшееся кол-во попыток
                attempts--;
            }
        }


        // достраиваем дороги
        RoadManager.GetInstance().BuildRoadInBlock(descriptor, x, y, SizeOfBlocks);

        // генерируем прочие декоротивные и не только объекты
        GenerateBlockEnviroment(block, descriptor, settingsForGeneration, SizeOfBlocks);
    }
Пример #35
0
 void roadWidthSlider_ValueChanged(object sender, EventArgs e)
 {
     RoadManager.changeSelectedRoadWidth((float)roadWidthSlider.NumericValue);
     RoadManager.rebuildSelectedRoadVisuals();
 }
Пример #36
0
    /**********************************************************************************/
    // функция ответсвенная за генерацию блоков
    //
    /**********************************************************************************/
    void GenerateBlocks(int xSize, int ySize)
    {
        // проверяем соответствие размера карты и блоков, они должны быть кратными
        if (MapSizeX % SizeOfBlocks != 0 || MapSizeY % SizeOfBlocks != 0)
        {
            Debug.LogError("MapGenerator::GenerateBlocks size of map or size of blocks is wrong!");
            return;
        }

        // шанс использования предопределённого блока
        // вынести в настройки (?)
        // ! НА ТЕКУЩИЙ МОМЕНТ ФУНКЦИОНАЛ ОТКЛЮЧЁН !
        // требуется коллекция предопределённых блоков для использования
        float chanseOfSpecialBloks = -0.1f;


        int xMapSizeInBlocks = MapSizeX / SizeOfBlocks;
        int yMapSizeInBlocks = MapSizeY / SizeOfBlocks;

        // проходимся по всей карте и заполняем её блоками
        for (int x = 0; x < xMapSizeInBlocks; x++)
        {
            for (int y = 0; y < yMapSizeInBlocks; y++)
            {
                // определяем, используем ли мы специальный блок или генерируемый
                float      chanse        = Random.Range(0.0f, 1.0f);
                bool       isGenerated   = false;
                GameObject toInstantiate = null;

                // выбираем блок для "постройки"
                if (chanse <= chanseOfSpecialBloks)
                {
                    int  attempts = 5;
                    bool succsecc = false;

                    while (attempts > 0 && !succsecc)
                    {
                        toInstantiate = BaseBlockCollection[Random.Range(0, BaseBlockCollection.Length)];
                        succsecc      = RoadManager.GetInstance().IsBlockOk(toInstantiate, x, y);
                        attempts--;
                    }

                    // если не получилось выбрать блок - переключаемся на генерацию
                    if (!succsecc)
                    {
                        toInstantiate = EmptyBlock;
                        isGenerated   = true;
                    }
                }
                // генерируем блок, для этого используется пустая болванка
                else
                {
                    toInstantiate = EmptyBlock;
                    isGenerated   = true;
                }


                // проверяем возможность установки
                // если нет - уходим на следующую итерацию
                BlockDescriptor descriptor = toInstantiate.GetComponent <BlockDescriptor>();

                if (!IsPositionFree(x, y, descriptor))
                {
                    continue;
                }

                // создаём новый экземпляр блока
                GameObject instance = Instantiate(toInstantiate, new Vector3((float)x * SizeOfCell * SizeOfBlocks, (float)y * SizeOfCell * SizeOfBlocks, 0.0f), Quaternion.identity) as GameObject;

                // устанавливаем в родителя
                instance.transform.SetParent(BuildingCollector.transform);

                // выполняем окончательную установку и настройку блока
                bool res = PlaceBlockAtPosition(instance, x, y);
                if (res == false)
                {
                    Debug.LogError("Somothing is wrong with block place!");
                }

                BlockDescriptor instDescriptor = instance.GetComponent <BlockDescriptor>();

                if (isGenerated)
                {
                    // генерируем внутярнку блока
                    // объекты, дороги
                    GenerateBlockContent(instance, instDescriptor, x, y);
                }
                else
                {
                    instDescriptor.UpdateFreeSpaceMap(SizeOfBlocks);
                    // обновляем правила дорог
                    RoadManager.GetInstance().UpdateRulesForBlock(x, y, instDescriptor.RoadConnections);
                }

                PathFinder.GetInstance().ApplyBlockMapData(x, y, instDescriptor);
            }
        }
    }
Пример #37
0
        private IEnumerable <Segment> readSegments(JsonTextReader reader, RoadManager roads, JsonSerializer serializer, List <Node> nodes, List <SegmentDescription> descriptions)
        {
            if (reader.Read())
            {
                // start array
                if (reader.TokenType == JsonToken.StartArray)
                {
                    do
                    {
                        if (reader.Read()) // inside node
                        {
                            if (reader.TokenType == JsonToken.StartObject)
                            {
                                Node    start = null, end = null;
                                Vector3 startTangent = Vector3.zero, endTangent = Vector3.zero;
                                Vector3 startOffset = Vector3.zero, endOffset = Vector3.zero;

                                SegmentDescription description = null;
                                int depth = reader.Depth;
                                do
                                {
                                    if (reader.Read())
                                    {
                                        if (reader.TokenType == JsonToken.PropertyName)
                                        {
                                            switch ((string)reader.Value)
                                            {
                                            case Constants.TAG_SEGMENT_START:
                                                readConnection(reader, serializer, roads, nodes, out start, out startTangent, out startOffset);
                                                break;

                                            case Constants.TAG_SEGMENT_END:
                                                readConnection(reader, serializer, roads, nodes, out end, out endTangent, out endOffset);
                                                break;

                                            case Constants.TAG_SEGMENT_DESCRIPTION:
                                                description = descriptions[reader.ReadAsInt32() ?? -1];
                                                break;
                                            }
                                        }
                                    }
                                } while (reader.Depth > depth);

                                if (start != null && end != null)
                                {
                                    var seg = roads.CreateSegment(start, end, description);
                                    seg.Start.Tangent = startTangent;
                                    seg.End.Tangent   = endTangent;
                                    seg.Start.Offset  = startOffset;
                                    seg.End.Offset    = endOffset;
                                    yield return(seg);
                                }
                                else
                                {
                                    throw new FormatException("expected start AND end connections for segment");
                                }
                            }
                        }
                    } while (reader.TokenType != JsonToken.EndArray);
                }
            }
        }