コード例 #1
0
 public void Start()
 {
     if (PhotonNetwork.connected)
     {
         roadGenerator = GameObject.FindObjectOfType <RoadGenerator>();
     }
 }
コード例 #2
0
    private void GenerateProcedualLevel()
    {
        if (useGraphicAsBase)
        {
            elevationMap = ProcessBaseGraphicIntoArray();
            moistureMap  = ProcessBaseGraphicIntoArray();
            float[] perlinElevation = PerlinMapGenerator.GeneratePerlinMap(mapDimensions.width, mapDimensions.height, elevationSettings, false);
            float[] perlinMoisture  = PerlinMapGenerator.GeneratePerlinMap(mapDimensions.width, mapDimensions.height, moistureSettings, false);
            elevationMap = Utility.AddSameLengthArrays(elevationMap, perlinElevation, perlinWeightOnBaseGrafic);
            elevationMap = Utility.ClampPerlinValues(elevationMap);
            moistureMap  = Utility.AddSameLengthArrays(moistureMap, perlinMoisture, perlinWeightOnBaseGrafic);
            moistureMap  = Utility.ClampPerlinValues(moistureMap);
        }
        else
        {
            elevationMap = PerlinMapGenerator.GeneratePerlinMap(mapDimensions.width, mapDimensions.height, elevationSettings);
            moistureMap  = PerlinMapGenerator.GeneratePerlinMap(mapDimensions.width, mapDimensions.height, moistureSettings);
        }
        terrainMap = CombinePerlinMaps();

        terrainMap = SeedGrowth.PopulateGrid(terrainMap, forestParam, mapDimensions);
        terrainMap = SeedGrowth.PopulateGrid(terrainMap, citiesParam, mapDimensions);

        terrainMap = RoadGenerator.GenerateRoads(terrainMap, riversParam);
        terrainMap = RoadGenerator.GenerateRoads(terrainMap, roadParam);

        InitializePerlinMap();
    }
コード例 #3
0
    private void Start()
    {
        coordGen    = gameObject.GetComponent <CoordinateGenerator>();
        roadGen     = gameObject.GetComponent <RoadGenerator>();
        buildingGen = gameObject.GetComponent <BuildingGenerator>();

        GenerateRoads();
    }
コード例 #4
0
    void Start()
    {
        roadGeneratorGO     = GameObject.FindGameObjectWithTag("roadGenerator");
        roadGeneratorScript = roadGeneratorGO.GetComponent <RoadGenerator>();

        txtTime.text     = "2:00";
        txtDistance.text = "0";
    }
コード例 #5
0
        private void GenerateRoads(HeightMap <ushort> heightMap)
        {
            //var generator = new RoadGenerator(2, heightMap);
            var generator = new RoadGenerator <double>(2, () => new RoadCellMapDouble(heightMap, 8));

            generator.Generate();
            generator.Save(BaseDirectory);
        }
コード例 #6
0
ファイル: ScenaryVisual.cs プロジェクト: KittyMac/LD32
 public void CheckRoadGenerator()
 {
     if (roadGenerator == null)
     {
         gameController = PUCode.GetSingletonByName <GameController> ();
         roadGenerator  = gameController.roadGenerator;
     }
 }
コード例 #7
0
    void Start()
    {
        roadGen = (RoadGenerator)GameObject.Find("Road").GetComponent <RoadGenerator>();

        foreach (Transform t in transform)
        {
            roadGen.ReportVertex(t.position);
        }
    }
コード例 #8
0
    public Dictionary <Vector3, string> surroundingRoads; // Dictionary of all road positions and associated surroundingRoadString

    protected override void Awake()
    // Initiates all of the dictionaries for lookups and all other variables that need to be initialized
    {
        if (Serializer.IsLoading)
        {
            return;
        }
        base.Awake();
        if (instance != this)
        {
            instance = this;
        }

        roads            = new Dictionary <Vector3, GameObject>();
        surroundingRoads = new Dictionary <Vector3, string>();

        Quaternion zero        = new Quaternion(0, 0, 0, 1);
        Quaternion ninety      = new Quaternion(0, 0.7071f, 0, 0.7071f);
        Quaternion opposite    = new Quaternion(0, 1, 0, 0);
        Quaternion minusNinety = new Quaternion(0, -0.7071f, 0, 0.7071f);

        roadObject = new Dictionary <string, GameObject>();
        roadObject.Add("0000", smallRoadStraight);
        roadObject.Add("1000", smallRoadStraight);
        roadObject.Add("0100", smallRoadStraight);
        roadObject.Add("0010", smallRoadStraight);
        roadObject.Add("0001", smallRoadStraight);
        roadObject.Add("1100", smallRoadStraight);
        roadObject.Add("0011", smallRoadStraight);
        roadObject.Add("1010", smallRoadTurn);
        roadObject.Add("0101", smallRoadTurn);
        roadObject.Add("1001", smallRoadTurn);
        roadObject.Add("0110", smallRoadTurn);
        roadObject.Add("0111", smallRoadTJunction);
        roadObject.Add("1110", smallRoadTJunction);
        roadObject.Add("1011", smallRoadTJunction);
        roadObject.Add("1101", smallRoadTJunction);
        roadObject.Add("1111", smallRoadXJunction);

        roadRotation = new Dictionary <string, Quaternion>();
        roadRotation.Add("0000", zero);
        roadRotation.Add("1000", ninety);
        roadRotation.Add("0100", ninety);
        roadRotation.Add("0010", zero);
        roadRotation.Add("0001", zero);
        roadRotation.Add("1100", ninety);
        roadRotation.Add("0011", zero);
        roadRotation.Add("1010", zero);
        roadRotation.Add("0101", opposite);
        roadRotation.Add("1001", ninety);
        roadRotation.Add("0110", minusNinety);
        roadRotation.Add("0111", opposite);
        roadRotation.Add("1110", minusNinety);
        roadRotation.Add("1011", zero);
        roadRotation.Add("1101", ninety);
        roadRotation.Add("1111", zero);
    }
コード例 #9
0
        // awake happens too soon like a bitch
        void Update()
        {
            RoadGenerator rg = gameObject.GetComponent <RoadGenerator>();
            int           r  = Random.Range(0, 100);

            if (r < GrassPopulationManager.instance.ChanceFences)
            {
                int        f             = Random.Range(0, GrassPopulationManager.Fences.Length);
                GameObject FenceTemplate = GrassPopulationManager.Fences[f];
                int        d             = 2 * Random.Range(0, 4);

                rg.DoHits();
                WorldTile tiled = rg.GetNeighbours()[d];
                if (tiled && tiled.GetComponent <GrassPopulator>() && tiled.GetComponent <GrassPopulator>().FenceDir == RoadGenerator.Wrap0to7(d - 4))
                {
                    //Debug.Log("fence collision prevented");
                }
                else
                {
                    GameObject fence = Instantiate(FenceTemplate, transform.position + new Vector3((RoadGenerator.Xoffset(d) * WorldTileManager.TILE_SIZE) / 2, 0, (RoadGenerator.Zoffset(d) * WorldTileManager.TILE_SIZE) / 2), Quaternion.identity, transform);
                    fence.transform.Rotate(0, d * 45 - 90, 0);
                    FenceDir = d;
                }
            }

            int            t     = Random.Range(0, GrassPopulationManager.instance.MaximumTreeDensity);
            List <Vector3> trees = new List <Vector3>();

            trees.Clear();
            float x, y;

            x = y = 0.0f;
            bool bCollides = true;

            for (int i = 0; i < t; ++i)
            {
                bCollides = true;
                while (bCollides)
                {
                    x         = Random.Range(-9.0f, 9.0f);
                    y         = Random.Range(-9.0f, 9.0f);
                    bCollides = false;
                    foreach (Vector3 treepos in trees)
                    {
                        if ((treepos - new Vector3(x, 0, y)).magnitude < 4.0f)
                        {
                            bCollides = true;
                        }
                    }
                }
                trees.Add(new Vector3(x, 0, y));
                Instantiate(GrassPopulationManager.Tree, transform.position + new Vector3(x, 0, y), Quaternion.identity, transform);
            }

            enabled = false;
        }
コード例 #10
0
ファイル: GameController.cs プロジェクト: KittyMac/LD32
    public void Start()
    {
        GameIsOver = false;

        roadGenerator = new RoadGenerator();

        roadGenerator.GenerateRoadMap(LevelNumber);

        CreateTiledRoad(roadGenerator);

        CreateScenary();

        CreatePlayerObject();


        NumberOfKetchupUses = 10;

        NumberOfCollectedTurnips = 0;
        for (int i = 0; i < NumberOfTurnipsThisLevel; i++)
        {
            AddTurnip();
        }

        NotificationCenter.addObserver(this, "SpawnAllEnemies", null, (args, name) => {
            if (enemies.Count == 0)
            {
                for (int i = 0; i < (LevelNumber); i++)
                {
                    AddEnemyOfType1();
                }

                EndIntro();
            }
        });

        NotificationCenter.addObserver(this, "UnconventionalWeaponActivate", null, (args, name) => {
            if (NumberOfKetchupUses > 0)
            {
                GameObject localKetchupAnim = GameObject.Instantiate(KetchupAnim, player.transform.position, Quaternion.Euler(new Vector3(0, 45, 0))) as GameObject;
                localKetchupAnim.SetActive(true);
                LeanTween.delayedCall(1.0f, () => {
                    GameObject.DestroyImmediate(localKetchupAnim);
                });

                Vector3 pos = player.transform.position;
                pos.y       = 2;
                GameObject localKetchupSpill = GameObject.Instantiate(KetchupSpill, pos, Quaternion.Euler(new Vector3(90, 320, 0))) as GameObject;
                localKetchupSpill.SetActive(true);
                ketchupSpills.Add(localKetchupSpill);

                NumberOfKetchupUses--;
            }
        });

        AnimateIntro();
    }
コード例 #11
0
    public override void OnInspectorGUI()
    {
        DrawDefaultInspector();
        RoadGenerator rg = (RoadGenerator)target;

        if (GUILayout.Button("BuildRoad"))
        {
            rg.buildRoad();
        }
    }
コード例 #12
0
    void initComponents()
    {
        roadGeneratorGO     = GameObject.FindGameObjectWithTag("roadGenerator");
        roadGeneratorScript = roadGeneratorGO.GetComponent <RoadGenerator>();

        regressiveCountGO   = GameObject.FindGameObjectWithTag("regressiveCount");
        regressiveCountComp = regressiveCountGO.GetComponent <SpriteRenderer>();

        carGO         = GameObject.FindGameObjectWithTag("Player");
        carController = GameObject.FindGameObjectWithTag("carController");
    }
コード例 #13
0
    public override void OnInspectorGUI()
    {
        RoadGenerator generator = (RoadGenerator)target;

        // Show default inspector property editor
        DrawDefaultInspector();

        if (GUILayout.Button("Generate"))
        {
            generator.Regenerate();
        }
    }
コード例 #14
0
 void Start()
 // Get manager instances
 {
     economyManager    = GameObject.Find("Managers").GetComponent <EconomyManager>();
     populationManager = GameObject.Find("Managers").GetComponent <PopulationManager>();
     roadGenerator     = GameObject.Find("Island").GetComponent <RoadGenerator>();
     if (Serializer.IsLoading)
     {
         ResetItems();
         return;
     }
 }
コード例 #15
0
    public void SetPlayer()
    {
        //GameObject tmpRoadGenerator;

        //마스터만 로드제네레이터를 생성한다
        if (PhotonNetwork.isMasterClient)
        {
            GameObject tmpRoadGenerator = PhotonNetwork.Instantiate("Prefabs/RoadGenerator", Vector3.zero,
                                                                    Quaternion.identity, 0);

            //만약 생성이 되어 있다면
            roadGenerator = tmpRoadGenerator.GetComponent <RoadGenerator>();
        }

        //만약 생성이 되어 있다면
        //roadGenerator = tmpRoadGenerator.GetComponent<RoadGenerator>();

        int num = PlayerPrefs.GetInt("SELECTPLAYER", 0);

        Player[] tmpPlayer = FindRankPlayer();

        //TODO : 랜덤하게 위치를 바꿔줘야 할것
        //Player.transform.position = Vector3.zero;
        if (tmpPlayer.Length >= 1)
        {
            //가장 늦은 플레이어 위치 값에 더 해준 위치값
            Vector3 tmpPos = tmpPlayer[tmpPlayer.Length - 1].transform.position;

            tmpPos += new Vector3(2f, 0, 0);

            //포톤뷰로 캐릭터 생성
            player = PhotonNetwork.Instantiate("Prefabs/" + characterArray[num].name, tmpPos, Quaternion.identity, 0);
        }
        else
        {
            //포톤뷰로 캐릭터 생성
            player = PhotonNetwork.Instantiate("Prefabs/" + characterArray[num].name, Vector3.zero, Quaternion.identity, 0);
        }

        player.name = characterArray[num].name;

        if (PhotonNetwork.connected)
        {
            Vector3 tmpPos = player.transform.position;

            mainCamera.GetComponent <Camerafollow>().OriginPosition(tmpPos);
        }

        if (PhotonNetwork.connected && PhotonNetwork.isMasterClient)
        {
            roadGenerator.InitializationRoad();
        }
    }
コード例 #16
0
    // Use this for initialization
    private void Start()
    {
        //photonView.isMine == true;
        animator = GetComponent <Animator>();

        playerHealth = GetComponent <PlayerHealth>();

        inputManager = GameObject.FindObjectOfType <InputManager>();

        gameManager = GameObject.FindObjectOfType <GameManager>();

        roadGenerator = GameObject.FindObjectOfType <RoadGenerator>();
    }
コード例 #17
0
 void Start()
 {
     if (Serializer.IsDeserializing)
     {
         return;
     }
     if (Serializer.IsLoading)
     {
         return;
     }
     controller    = GameObject.Find("LeftController");
     events        = controller.GetComponent <VRTK_ControllerEvents>();
     roadGenerator = GameObject.Find("Island").GetComponent <RoadGenerator>();
 }
コード例 #18
0
        void Start()
        {
            rg = gameObject.GetComponent <RoadGenerator>();
            if (rg.Exit.Length < 8)
            {
                rg.RefreshExits();
            }

            SpawnNonVehicles();
            if (Random.value < spawnChance)
            {
                TrySpawn();
            }
        }
コード例 #19
0
ファイル: GridInteraction.cs プロジェクト: rYuuk/SimpleRoads
    private void Start()
    {
        _roadGenerator = new RoadGenerator();
        Map.Init(m_Size.x, m_Size.y);
        m_MapGameobject.transform.localScale = new Vector3(m_Size.x / 10, 1, m_Size.y / 10);

        for (int i = 0; i < m_ObstacleCount; i++)
        {
            int x = Random.Range(0, m_Size.x);
            int y = Random.Range(0, m_Size.y);

            Map.SetTileType(x, y, Tile.Type.Structure);
            GameObject obstacle = GameObject.CreatePrimitive(PrimitiveType.Cube);
            obstacle.transform.position = new Vector3(x - m_Size.x / 2, 0, y - m_Size.y / 2);
            obstacle.GetComponent <Collider>().enabled = false;
        }
    }
コード例 #20
0
        void FixedUpdate()
        {
            if (Input.GetKey(KeyCode.Keypad0))
            {
                bCull = !bCull;
            }

            Transform playerTransform = checkpoint.FollowCamera.target.transform;

            //Debug.Log(checkpoint.RoadMapRoot.GetComponentsInChildren<RoadGenerator>().Length + " 35:" + checkpoint.RoadMapRoot.GetComponentsInChildren<RoadGenerator>()[35].gameObject.name);

            if (checkpoint.RoadMapRoot.GetComponentsInChildren <RoadGenerator>().Length > 100 /*usually around 140, prevent checking until the map is up to size*/ && EmergencyFieldRemover == null && checkpoint.RoadMapRoot.GetComponentsInChildren <RoadGenerator>()[35] as DisabledRoadGenerator != null /*35 is around a quarter, meaning grass at this position indicates a map with three quarters grass*/)
            {
                int i = RoadGenerator.Wrap0to7(Mathf.RoundToInt(playerTransform.rotation.eulerAngles.y / 45.0f));

                Vector3 player = RoundDownToGrid(playerTransform.position);
                hitTest.x = Mathf.FloorToInt(player.x / WorldTileManager.TILE_SIZE) + RoadGenerator.Xoffset(i) * 8;
                hitTest.z = Mathf.FloorToInt(player.z / WorldTileManager.TILE_SIZE) + RoadGenerator.Zoffset(i) * 8;
                //Debug.Log("Testing for a hit at grid "+hitTest.x+","+hitTest.z+"; World location "+hitTest.GetWorldPosition());
                WorldTile Hit = WorldTileManager.instance.GetTile(hitTest);

                if (!Hit)
                {
                    //Debug.Log("F****N FIELD, heading " + playerTransform.rotation.eulerAngles.y + "≈" + (RoadGenerator.Direction)i);

                    EmergencyFieldRemover = Instantiate(FourWay, hitTest.GetWorldPosition() + new Vector3(0, FourWay.GetComponent <RoadGenerator>().YOffset, 0), Quaternion.identity, checkpoint.RoadMapRoot.transform);
                    //Debug.Log("EFR: "+EmergencyFieldRemover.gameObject.name + " at " + (hitTest.GetWorldPosition() + new Vector3(0, FourWay.GetComponent<RoadGenerator>().YOffset, 0)));
                    WorldTileManager.instance.AddTile(EmergencyFieldRemover.GetComponent <WorldTile>());
                    EmergencyFieldRemover.transform.SetAsFirstSibling();
                    RoadGenerator newRG = EmergencyFieldRemover.GetComponent <RoadGenerator>();
                    newRG.CullingExempt = true;
                    newRG.RefreshExits();
                    //newRG.Extend(true);
                    //checkpoint.RoadMapRoot.BroadcastMessage("Extend", true);
                }
            }
            else if             // Emergency Field Remover has come within the invisible boundary lines (σ回ω・)σ
            ((EmergencyFieldRemover != null && Vector3.Distance(playerTransform.position, EmergencyFieldRemover.transform.position) < checkpoint.FollowCamera.CullDistance)
             ||                 // Emergency Field Remover is no longer in front of the player
             (EmergencyFieldRemover != null && Vector3.Dot(playerTransform.position - EmergencyFieldRemover.transform.position, playerTransform.forward) > 90))
            {
                EmergencyFieldRemover.GetComponent <RoadGenerator>().CullingExempt = false;
                EmergencyFieldRemover = null;
            }
        }
コード例 #21
0
ファイル: MapGenerator.cs プロジェクト: facybenbook/Piggy-Run
    // Update is called once per frame
    RoadGenerator nextRoad(bool newLevel = false, bool endPath = false)
    {
        if (firstRoad)
        {
            nextDirection = Direction.Straight;
            firstRoad     = false;
        }
        int space = 2 + Hardness();

        hasSpace   = Random.Range(0, space) < 2 ? false : true;                                                                                //random hasSpace
        nextLength = Random.Range((newLevel || endPath) ? (CurrentLevel < 5 ? 8 : 5) : (CurrentLevel < 5 ? 4 : 3), CurrentLevel < 5 ? 10 : 5); // random length

        GameObject    obj       = (GameObject)Instantiate(roadPrefap, nextPostiton, Quaternion.identity);                                      //get the road
        RoadGenerator road      = obj.GetComponent <RoadGenerator>();
        bool          longSpace = hasSpace ? Random.Range(0, 2) == 0 : false;

        road.Map       = this;
        road.direction = nextDirection;
        road.length    = nextLength;
        calculateNextPosition(longSpace);
        road.Generate(hasSpace, longSpace, endPath, newLevel);

        //next spawm position
        int changeDirectionRate = 2 + Hardness();

        if (Random.Range(0, changeDirectionRate) == 0)
        {
            nextDirection = convertIntToDirection(Random.Range(0, 3)); // random direction
        }
        else
        {
            int next = (Random.Range(0, 3));
            while (next == (int)nextDirection)
            {
                next = (Random.Range(0, 3));
            }
            nextDirection = convertIntToDirection(next);
        }

        //nextDirection = convertIntToDirection(Random.Range(0, 3)); // random direction
        obj.tag = nextDirection.ToString();

        return(road);
    }
    void RandomGenerateMap()
    {
        GameObject     planeObject = new GameObject("Plane Object");
        PlaneGenerator myPlaneGen  = planeObject.AddComponent <PlaneGenerator>();

        myPlaneGen.Size = new Vector3(40f, 0f, 40f);
        planeObject.transform.position = new Vector3(-450f, -1f, -450f);

        GameObject roadObject = new GameObject("Road_Object");

        myRoadGen = roadObject.AddComponent <RoadGenerator>();

        myRoadGen.RoadRadius   = Random.Range(80, 111);
        myRoadGen.RoadSegments = Random.Range(260, 360);
        myRoadGen.RoadWaviness = Random.Range(80, 201);
        myRoadGen.WaveScale    = Random.Range(1.6f, 2.4f);
        myRoadGen.WaveOffset   = new Vector2(Random.Range(0.65f, 1.65f), Random.Range(1.35f, 2.5f));
        myRoadGen.WaveStep     = new Vector2(Random.Range(0.01f, 0.02f), Random.Range(0.01f, 0.03f));
    }
コード例 #23
0
 public override void StartUsing(GameObject usingObject)
 {
     base.StartUsing(usingObject);
     if (controller == null)
     {
         controller = ReferenceManager.instance.leftController;
     }
     if (roadGenerator == null)
     {
         roadGenerator = ReferenceManager.instance.roadGenerator;
     }
     Physics.Raycast(controller.transform.position, controller.transform.forward, out hit, 100.0f);
     if (hit.transform.gameObject.tag == "road")
     {
         Vector3 rounded = Round(hit.point);
         roadGenerator.RemoveRoad(rounded);
         roadGenerator.RedrawLocalRoads(rounded);
     }
 }
コード例 #24
0
    void Start()
    {
        firstTouch = 1;
        transform  = gameObject.transform;
        RoadGen    = GameObject.Find("RoadGenerator").GetComponent <RoadGenerator>();

        isMove       = false;
        isChoose     = true;
        isOnCurve    = false;
        isNearCar    = false;
        isSlowMotion = false;

        numberNieghbor      = 0;
        targetNode          = currentNode.neighbors[numberNieghbor];
        transform.position += GetRightOffset(currentNode.roadsToNeighbors[numberNieghbor], 2);
        target              = currentNode.roadsToNeighbors[numberNieghbor];
        seed = 1;

        antiTarget = Vector3.zero;
        RotateCar(target);
    }
コード例 #25
0
ファイル: MapGenerator.cs プロジェクト: facybenbook/Piggy-Run
    void Start()
    {
        CurrentLevel = 20;

        nextPostiton = transform.position;
        //Debug.Log(CurrentLevel);
        Time.timeScale = CurrentTimeScale;

        NumberOfRoad += Hardness();

        for (int i = 0; i < NumberOfRoad; i++)
        {
            RoadGenerator road = nextRoad(i == 0, i == NumberOfRoad - 1);
            road.transform.parent = this.transform;

            if (i == NumberOfRoad - 1)
            {
                EndPosition = road.EndPosition;
            }
        }
        Maps.Add(this);
        if (Maps.Count > 2)
        {
            Destroy(Maps[0].gameObject);
            Maps.RemoveAt(0);
        }



        if (OnNewLevelLoaded != null)
        {
            OnNewLevelLoaded(CurrentLevel);
        }
        CurrentLevel++;


        Debug.Log("Map ready");

        SoundManager.PlayBGMusic(true);
    }
コード例 #26
0
    private void Initialize()
    {
        moveForward = FindObjectOfType <MoveForward>();
        if (moveForward != null)
        {
            moveForward.Initialize(mainConfig.Speed);
        }

        tilePool = GetComponent <RoadTilePool>();
        if (tilePool != null)
        {
            tilePool.Initialize(mainConfig.Speed);
        }

        roadGenerator = GetComponent <RoadGenerator>();
        if (roadGenerator != null)
        {
            roadGenerator.Initialize(mainConfig.Speed);
        }

        playerMover = FindObjectOfType <PlayerMover>();
        if (playerMover != null)
        {
            playerMover.Initialize(mainConfig.Speed);
        }

        treasure = FindObjectOfType <Treasure>();
        if (treasure != null)
        {
            treasure.Initialize();
        }

        towerController = FindObjectOfType <PlayerTowerController>();
        if (towerController != null)
        {
            towerController.Initialize();
        }
    }
コード例 #27
0
    void Start()
    {
        AudioListener.volume = AudioVolume;
        GameTime.Instance.m_timeMultiplier = PlaybackSpeed;

        m_trafficController = FindObjectOfType <TrafficController>();
        m_roadGenerator     = FindObjectOfType <RoadGenerator>();
        m_controller        = FindObjectOfType <SplineFollowControl>();
        m_uiController      = FindObjectOfType <UIController>();

        m_roadGenerator.Regenerate();

        m_trafficController.Begin();
        m_controller.ControlBegin();

        // Spawn riders
        for (int riderIndex = 0; riderIndex < NumRiders; ++riderIndex)
        {
            Rider newRider = Instantiate(RiderPrefab.gameObject).GetComponent <Rider>();
            newRider.TeamId = 0;
            newRider.RiderStart();
            m_riders.Add(newRider);
            m_trafficController.RegisterFocalObject(newRider.gameObject);

            m_uiController.RegisterPlayerRider(newRider, false);
        }

        for (int riderIndex = 0; riderIndex < NumEnemyRiders; ++riderIndex)
        {
            Rider newRider = Instantiate(EnemyRiderPrefab.gameObject).GetComponent <Rider>();
            newRider.TeamId = 1;
            newRider.RiderStart();
            m_enemyRiders.Add(newRider);
            m_trafficController.RegisterFocalObject(newRider.gameObject);

            m_uiController.RegisterPlayerRider(newRider, true);
        }
    }
コード例 #28
0
 void Start()
 {
     ContentManager = GetComponent <ContentManager>();
     SeasonalChange = GetComponent <SeasonalChange>();
     RoadGenerator  = GetComponent <RoadGenerator>();
     TerrainInfo    = new TerrainInfo(GetComponent <Terrain>());
     SplineScript   = GetComponentInChildren <Spline>();
     if (UseCustomTerrainSizeDefinitions)
     {
         TerrainInfo.TerrainWidth  = TerrainWidth;
         TerrainInfo.TerrainHeight = TerrainHeight;
         TerrainInfo.TerrainDepth  = TerrainDepth;
     }
     // Figure out how to do this better, for now info has "manager" info (so we can use it elsewhere)
     TerrainInfo.ContentManager   = ContentManager;
     ContentGenerator             = GetComponent <ContentGenerator>();
     TerrainInfo.ContentGenerator = ContentGenerator;
     TerrainInfo.RoadGenerator    = RoadGenerator;
     // Initialize manager, need to handle path for different platforms (OSX, Windows)
     SerializationManager.InitializeManager();
     // You can deserialize here and take the first NoiseParameter from the list if you dont want the default values
     InitializeTerrainWithPresetGeneration();
 }
コード例 #29
0
 public RoadMapGenerator()
 {
     globalGoals      = new GlobalGoals();
     localConstraints = new LocalConstraints();
     roadGenerator    = new RoadGenerator();
 }
コード例 #30
0
 public Road(RoadGenerator gen, WayPoint.Path inPath)
 {
     generator = generators[genIndex];
     path      = inPath;
 }
コード例 #31
0
//	private void generateRoads(){
//
//		Roads roads = new Roads (this);
//		roads.createRoads (this);
//
//		
//	}

	private void generateRoads(){

		RoadGenerator roadGen = new RoadGenerator (this);
		roadGen.generate ();
		roadPaths = roadGen.paths;

		DrawRoads drawRaod = new DrawRoads (m_terrainSize, m_heightMapSize, road);
		drawRaod.pathShader = pathShader;
		for (int i =0; i< cityCenters.Count; i++)
						for (int j=i+1; j< cityCenters.Count; j++) {						
							if (roadPaths[i,j].length == -1 ) continue;
							if(roadPaths[i,j].points.Count<2) continue;

							bool skip = false;
							for (int h=0; h< cityCenters.Count; h++){
								if ( h==i || h==j) continue;

								if (roadPaths[i,j].length >=(0.85f)*(roadPaths[i,h].length + roadPaths[h,j].length) ) skip =true;
								if (roadPaths[i,h].length == -1 || roadPaths[h,j].length == -1) skip = false;

							}

							if (skip) continue;

							drawRaod.createRoads(roadPaths[i,j].points);	
					
						}
	}
コード例 #32
0
ファイル: UpperLayersManager.cs プロジェクト: parmandorc/PCG
    // Launches the generation of the specified road (or all of them if index = -1).
    public void RecalculateRoads(int index = -1)
    {
        for (int i = ((index < 0) ? 0 : index); i < ((index < 0) ? roadsDefinitionData.Count : (index + 1)); i++) {

            if (roadThreads.ContainsKey (i)) // If thread already running, substitute it.
                roadThreads [i].Abort ();

            Eppy.Tuple<Vector2, Vector2, float, float> roadData = roadsDefinitionData [i];
            RoadGenerator thread = new RoadGenerator (roadData.Item1, roadData.Item2, roadData.Item3, roadData.Item4);
            thread.Start ();

            roadThreads [i] = thread;
        }

        // If the coroutine is already launch, no change is needed, since it will check for all currently running threads.
        if (roadsCoroutine == null)
            roadsCoroutine = StartCoroutine(WaitForRoadThreads());
    }