// Use this for initialization
private void Start()
{
var ppos = Player.transform.position;
Player.transform.position = new Vector3(ppos.x,
Utils.GenerateHeight(ppos.x, ppos.z) + 1,
ppos.z);
lastBuildPos = Player.transform.position;
Player.SetActive(false);
Firstbuild = true;
Chunks = new ConcurrentDictionary <string, Chunk>();
this.transform.position = Vector3.zero;
this.transform.rotation = Quaternion.identity;
queue = new CoroutineQueue(maxCoroutines, StartCoroutine);
//build starting chunk
BuildChunkAt((int)(Player.transform.position.x / ChunkSize),
(int)(Player.transform.position.y / ChunkSize),
(int)(Player.transform.position.z / ChunkSize));
//draw it
queue.Run(DrawChunks());
//create a bigger world
queue.Run(BuildRecursiveWorld((int)(Player.transform.position.x / ChunkSize),
(int)(Player.transform.position.y / ChunkSize),
(int)(Player.transform.position.z / ChunkSize), Radius));
}
// Use this for initialization
void Start()
{
Vector3 ppos = player.transform.position;
player.transform.position = new Vector3(ppos.x,
Utils.GenerateHeight(ppos.x, ppos.z) + 1,
ppos.z);
lastbuildPos = player.transform.position;
player.SetActive(false);
firstbuild = true;
chunks = new ConcurrentDictionary <string, Chunk>();
this.transform.position = Vector3.zero;
this.transform.rotation = Quaternion.identity;
queue = new CoroutineQueue(maxCoroutines, StartCoroutine);
startTime = Time.time;
Debug.Log("Start Build");
//build starting chunk
BuildChunkAt((int)(player.transform.position.x / chunkSize),
(int)(player.transform.position.y / chunkSize),
(int)(player.transform.position.z / chunkSize));
//draw it
queue.Run(DrawChunks());
//create a bigger world
queue.Run(BuildRecursiveWorld((int)(player.transform.position.x / chunkSize),
(int)(player.transform.position.y / chunkSize),
(int)(player.transform.position.z / chunkSize), radius, radius));
}
private void Start()
{
// set player on the ground
Vector3 playerPos = player.transform.position;
player.transform.position = new Vector3(playerPos.x, Utils.GenerateHeight(playerPos.x, playerPos.z) + 1, playerPos.z);
lastBuildPos = player.transform.position;
player.SetActive(false);
firstBuild = true;
chunks = new ConcurrentDictionary <string, Chunk>();
this.transform.position = Vector3.zero;
this.transform.rotation = Quaternion.identity;
coroutineQueue = new CoroutineQueue(maxCoroutines, StartCoroutine);
// build starting chunk
BuildChunkAt((int)(player.transform.position.x / chunkSize), (int)(player.transform.position.y / chunkSize), (int)(player.transform.position.z / chunkSize));
// draw the chunk
coroutineQueue.Run(DrawChunks());
// build a bigger world
coroutineQueue.Run(
BuildRecursiveWorld((int)(player.transform.position.x / chunkSize), (int)(player.transform.position.y / chunkSize), (int)(player.transform.position.z / chunkSize), radius)
);
}
private IEnumerator BuildRecursiveWorld(int x, int y, int z, int rad)
{
rad--;
if (rad <= 0)
{
yield break;
}
BuildChunkAt(x, y, z - 1);
queue.Run(BuildRecursiveWorld(x, y, z - 1, rad));
BuildChunkAt(x, y - 1, z);
queue.Run(BuildRecursiveWorld(x, y - 1, z, rad));
BuildChunkAt(x - 1, y, z);
queue.Run(BuildRecursiveWorld(x - 1, y, z, rad));
BuildChunkAt(x, y, z + 1);
queue.Run(BuildRecursiveWorld(x, y, z + 1, rad));
BuildChunkAt(x, y + 1, z);
queue.Run(BuildRecursiveWorld(x, y + 1, z, rad));
BuildChunkAt(x + 1, y, z);
queue.Run(BuildRecursiveWorld(x + 1, y, z, rad));
yield return(null);
}
// Use this for initialization
void Start()
{
GameObject[] players = GameObject.FindGameObjectsWithTag("FPSController");
foreach (GameObject plyr in players)
{
if (plyr.GetComponent <PlayerSetup>().isLocalPlayer)
{
player = plyr;
break;
}
}
Vector3 ppos = player.transform.position;
player.transform.position = new Vector3(ppos.x,
Utils.GenerateHeight(ppos.x, ppos.z) + 1,
ppos.z);
lastbuildPos = player.transform.position;
player.SetActive(false);
firstbuild = true;
chunks = new ConcurrentDictionary <string, Chunk>();
this.transform.position = Vector3.zero;
this.transform.rotation = Quaternion.identity;
queue = new CoroutineQueue(maxCoroutines, StartCoroutine);
startTime = Time.time;
Debug.Log("Start Build");
/*
* while(Time.time < startTime+2000) {
*
* }*/
//build starting chunk
BuildChunkAt((int)(player.transform.position.x / chunkSize),
(int)(player.transform.position.y / chunkSize),
(int)(player.transform.position.z / chunkSize));
//draw it
queue.Run(DrawChunks());
//create a bigger world
queue.Run(BuildRecursiveWorld((int)(player.transform.position.x / chunkSize),
(int)(player.transform.position.y / chunkSize),
(int)(player.transform.position.z / chunkSize), radius, radius));
if (!player.activeSelf)
{
player.SetActive(true);
Debug.Log("Built in " + (Time.time - startTime));
firstbuild = false;
}
}
void Start()
{
numArtworks = Artworks.Instance.numMaxArtworks;
// Create a coroutine queue that can run up to two coroutines at once
var queue = new CoroutineQueue(2, StartCoroutine);
for (int i = 0; i < numArtworks; i++)
{
queue.Run(LoadImages(i));
queue.Run(LoadThumbnails(i));
}
}
// Use this for initialization
void Start()
{
//generate all vertices
for (int z = 0; z <= chunkSize; z++)
{
for (int y = 0; y <= chunkSize; y++)
{
for (int x = 0; x <= chunkSize; x++)
{
allVertices[x, y, z] = new Vector3(x, y, z);
}
}
}
allNormals[(int)NDIR.UP] = Vector3.up;
allNormals[(int)NDIR.DOWN] = Vector3.down;
allNormals[(int)NDIR.LEFT] = Vector3.left;
allNormals[(int)NDIR.RIGHT] = Vector3.right;
allNormals[(int)NDIR.FRONT] = Vector3.forward;
allNormals[(int)NDIR.BACK] = Vector3.back;
Vector3 ppos = player.transform.position;
player.transform.position = new Vector3(ppos.x, Utils.GenerateHeight(ppos.x, ppos.z) + 5,
ppos.z);
lastBuildPos = player.transform.position;
player.SetActive(false);
firstbuild = true;
chunks = new ConcurrentDictionary <string, Chunk> ();
this.transform.position = Vector3.zero;
this.transform.rotation = Quaternion.identity;
queue = new CoroutineQueue(maxCoroutines, StartCoroutine);
// starting chunk
BuildChunkAt((int)(player.transform.position.x / chunkSize),
(int)(player.transform.position.y / chunkSize),
(int)(player.transform.position.z / chunkSize));
startTime = Time.time;
Debug.Log("Start Build");
//draw it
queue.Run(DrawChunks());
//create a bigger world
queue.Run(BuildRecursiveWorld((int)(player.transform.position.x / chunkSize),
(int)(player.transform.position.y / chunkSize),
(int)(player.transform.position.z / chunkSize), radius));
}
void FollowWaypoint()
{
if (wayPointsCount < waypoints.Length)
{
coroutineQueueObject.Run(FollowWaypointRoutine());
}
}
void OnGUI()
{
if (GUI.Button(new Rect(0, 0, 100, 50), "弹"))
{
queue.Run(DelayAddForce());
}
}
/// <summary>
/// Unity lifecycle start method. Initializes the world and its first chunk and triggers the building of further chunks.
/// Player is disabled during Start() to avoid him falling through the floor. Chunks are built using coroutines.
/// </summary>
void Start()
{
mumie = SetMumie;
Vector3 ppos = createPosition();
setCactusSeed();
waterFrequencySeed();
setSignPos(ppos);
Vector3 level = new Vector3(levelID / 60 + 1, cactusSeed, (levelID % 10f) + 1);
Debug.Log("Levelparameter:" + level);
Debug.Log("LevelID:" + levelID);
player.transform.position = new Vector3(ppos.x,
Utils.GenerateHeightMountains(ppos.x, ppos.z) + 1,
ppos.z);
lastbuildPos = player.transform.position;
player.SetActive(false);
firstbuild = true;
chunks = new ConcurrentDictionary <string, Chunk>();
this.transform.position = Vector3.zero;
this.transform.rotation = Quaternion.identity;
queue = new CoroutineQueue(maxCoroutines, StartCoroutine);
// Build starting chunk
BuildChunkAt((int)(player.transform.position.x / chunkSize),
(int)(player.transform.position.y / chunkSize),
(int)(player.transform.position.z / chunkSize));
// Draw starting chunk
queue.Run(DrawChunks());
// Create further chunks
// queue.Run(BuildRecursiveWorld((int)(player.transform.position.x/chunkSize),
// (int)(player.transform.position.y/chunkSize),
// (int)(player.transform.position.z/chunkSize),radius,radius));
// use buildworld with radius 15 instead of buildrecursivworld to build the whole world at once
// (takes a while and isnt working yet for every seed)
queue.Run(BuildWorld((int)(player.transform.position.x / chunkSize),
(int)(player.transform.position.z / chunkSize), radius));
}
IEnumerator BuildRecursiveWorld(int x, int y, int z, int startrad, int rad)
{
int nextrad = rad - 1;
if (rad <= 0 || y < 0 || y > columnHeight)
{
yield break;
}
//build chunk front
BuildChunkAt(x, y, z + 1);
queue.Run(BuildRecursiveWorld(x, y, z + 1, rad, nextrad));
yield return(null);
//build chunk back
BuildChunkAt(x, y, z - 1);
queue.Run(BuildRecursiveWorld(x, y, z - 1, rad, nextrad));
yield return(null);
if (rad <= radius / 2)
{
yield break;
}
//build chunk left
BuildChunkAt(x - 1, y, z);
queue.Run(BuildRecursiveWorld(x - 1, y, z, rad, nextrad));
yield return(null);
//build chunk right
BuildChunkAt(x + 1, y, z);
queue.Run(BuildRecursiveWorld(x + 1, y, z, rad, nextrad));
yield return(null);
if (rad <= (radius / 2) + 1)
{
yield break;
}
//build chunk up
BuildChunkAt(x, y + 1, z);
queue.Run(BuildRecursiveWorld(x, y + 1, z, rad, nextrad));
yield return(null);
//build chunk down
BuildChunkAt(x, y - 1, z);
queue.Run(BuildRecursiveWorld(x, y - 1, z, rad, nextrad));
yield return(null);
}
private void Start()
{
Vector3 playerpos = player.transform.position;
player.transform.position = new Vector3(playerpos.x, Utils.GenerateHeight(playerpos.x, playerpos.z) + 1, playerpos.z);
lastBuildPosition = player.transform.position;
player.SetActive(false);
firstBuild = true;
chunks = new ConcurrentDictionary <string, Chunk>();
coroutineQueue = new CoroutineQueue(maxCouroutines, StartCoroutine);
transform.position = Vector3.zero;
transform.rotation = Quaternion.identity;
BuildChunkAt((int)(player.transform.position.x / chunkSize), (int)(player.transform.position.y / chunkSize), (int)(player.transform.position.z / chunkSize));
coroutineQueue.Run(DrawChunk());
coroutineQueue.Run(BuildRecursiveWorld((int)(player.transform.position.x / chunkSize), (int)(player.transform.position.y / chunkSize), (int)(player.transform.position.z / chunkSize), radious));
}
private void Update()
{
Vector3 movement = lastBuildPos - player.transform.position;
if (movement.magnitude > chunkSize)
{
lastBuildPos = player.transform.position;
BuildNearPlayer();
}
if (!player.activeSelf)
{
player.SetActive(true);
firstBuild = false;
}
coroutineQueue.Run(DrawChunks());
coroutineQueue.Run(RemoveOldChunks());
}
public void ExecuteCommand()
{
if (queue == null)
{
queue = new CoroutineQueue(1, StartCoroutine);
queue.finished += ClearCommands;
}
foreach (Command theCommand in m_Commands)
{
m_CommandsHistory.Add(theCommand);
queue.Run(theCommand.Execute());
}
m_Commands.Clear();
}
IEnumerator BuildRecursiveWorld(int x, int y, int z, int rad)
{
int nextrad = rad - 1;
if (nextrad <= 0)
{
yield break;
}
//build chunk front
BuildChunkAt(x, y, z + 1);
queue.Run(BuildRecursiveWorld(x, y, z + 1, nextrad));
yield return(null);
//build chunk back
BuildChunkAt(x, y, z - 1);
queue.Run(BuildRecursiveWorld(x, y, z - 1, nextrad));
yield return(null);
//build chunk left
BuildChunkAt(x - 1, y, z);
queue.Run(BuildRecursiveWorld(x - 1, y, z, nextrad));
yield return(null);
//build chunk right
BuildChunkAt(x + 1, y, z);
queue.Run(BuildRecursiveWorld(x + 1, y, z, nextrad));
yield return(null);
//build chunk up
BuildChunkAt(x, y + 1, z);
queue.Run(BuildRecursiveWorld(x, y + 1, z, nextrad));
yield return(null);
//build chunk down
BuildChunkAt(x, y - 1, z);
queue.Run(BuildRecursiveWorld(x, y - 1, z, nextrad));
yield return(null);
}
// Use this for initialization
void Start()
{
Vector3 ppos = player.transform.position;
player.transform.position = new Vector3(ppos.x, Utils.GenHeight(ppos.x, ppos.z) + 5, ppos.z);
lastBuildPos = player.transform.position;
player.SetActive(false);
chunks = new ConcurrentDictionary <string, Chunk>();
this.transform.position = Vector3.zero;
this.transform.rotation = Quaternion.identity;
queue = new CoroutineQueue(maxCoroutines, StartCoroutine);
// Build starting chunk
// BuildChunkAt((int)(player.transform.position.x / chunkSize), (int)(player.transform.position.y / chunkSize), (int)(player.transform.position.z / chunkSize));
// Start Chunk drawing coroutine
// queue.Run(DrawChunks());
// Create the rest of the world
queue.Run(BuildRecWorld((int)(player.transform.position.x / chunkSize), (int)(player.transform.position.y / chunkSize), (int)(player.transform.position.z / chunkSize), radius, radius));
}
// Start is called before the first frame update
void Start()
{
objPrePosition = transform.position;
for (int i = 0; i < gos.Length; i++)
{
particle p = new particle();
p.curPos = gos[i].transform.position;
p.prePos = gos[i].transform.position;
p.initPos = gos[i].transform.localPosition;
infos.Add(p);
if (i == gos.Length - 1)
{
hookPos2 = gos[i].transform.position;
}
else if (i == gos.Length - width)
{
hookPos1 = gos[i].transform.position;
}
}
queue = new CoroutineQueue(2, StartCoroutine);
queue.Run(DelayAddForce());
}
void Flush()
{
queue.Run(Dump());
}
public void EndCurrentGame()
{
coroutineQueue.Run(EndChapter());
}
private void AnimateRotate(string faceTag, char axisName, float angle)
{
queue.Run(RotateFace(faceTag, axisName, angle));
}
/// <summary>
/// Unity lifecycle start method. Initializes the world and its first chunk and triggers the building of further chunks.
/// Player is disabled during Start() to avoid him falling through the floor. Chunks are built using coroutines.
/// </summary>
void Start()
{
/*
* Vector3 ppos = player.transform.position;
* player.transform.position = new Vector3(ppos.x,
* Noise.GenerateHeight(ppos.x,ppos.z) + 2,
* ppos.z);
* lastbuildPos = player.transform.position;
* player.SetActive(false);
*/
firstbuild = true;
chunks = new ConcurrentDictionary <string, Chunk>();
/*
* this.transform.position = Vector3.zero;
* this.transform.rotation = Quaternion.identity;
*/
spawnPosX = worldSize * chunkSize / 2;
spawnPosZ = worldSize * chunkSize / 2;
Vector3 ppos = player.transform.position;
player.transform.position = randomSpawnpoint();
/*
* player.transform.position = new Vector3(spawnPosX,
* Noise.GenerateHeight(spawnPosX,spawnPosZ) + 2,
* spawnPosZ);
*
*/
var evnt = PlayerVisibilityChanged.Create(Bolt.GlobalTargets.Others);
evnt.Player = player.GetComponent <FirstPersonController>().GetEntity();
evnt.Visible = false;
evnt.Send();
player.SetActive(false);
BuildChunkAt((int)(player.transform.position.x / chunkSize),
(int)(player.transform.position.y / chunkSize),
(int)(player.transform.position.z / chunkSize));
DrawChunks();
for (int y = 0; y < columnHeight; y++)
{
BuildChunkAt((int)player.transform.position.x / chunkSize, y, (int)player.transform.position.z / chunkSize);
}
DrawChunks();
queue = new CoroutineQueue(maxCoroutines, StartCoroutine);
for (int x = 0; x < worldSize; x++)
{
for (int z = 0; z < worldSize; z++)
{
for (int y = 0; y < columnHeight; y++)
{
BuildChunkAt(x, y, z);
}
}
}
// Draw starting chunk
queue.Run(DrawChunks());
/*
* // Create further chunks
* queue.Run(BuildRecursiveWorld((int)(player.transform.position.x/chunkSize),
* (int)(player.transform.position.y/chunkSize),
* (int)(player.transform.position.z/chunkSize),radius,radius));
*/
}
/// <summary>
/// Unity lifecycle start method. Initializes the world and its first chunk and triggers the building of further chunks.
/// Player is disabled during Start() to avoid him falling through the floor. Chunks are built using coroutines.
/// </summary>
void Start()
{
Vector3 ppos = player.transform.position;
player.transform.position = new Vector3(ppos.x,
Utils.GenerateHeight(ppos.x, ppos.z) + 1,
ppos.z);
lastbuildPos = player.transform.position;
player.SetActive(false);
firstbuild = true;
chunks = new ConcurrentDictionary <string, Chunk>();
this.transform.position = Vector3.zero;
this.transform.rotation = Quaternion.identity;
World.chunks = chunks;
queue = new CoroutineQueue(maxCoroutines, StartCoroutine);
mapGiver.width = caveWidth;
mapGiver.height = caveHeight;
mapGiver.GenerateNewMap();
int[,] caveMap = mapGiver.currentMap;
int[,,] cave = new int[caveWidth, caveHeight, chunkSize];
for (int i = 0; i < caveWidth; i++)
{
for (int j = 0; j < caveHeight; j++)
{
for (int k = 0; k < chunkSize; k++)
{
cave[i, j, k] = caveMap[i, j];
}
}
}
for (int i = 0; i < caveWidth / chunkSize; i++)
{
for (int j = 0; j < caveHeight / chunkSize; j++)
{
for (int k = 0; k < chunkSize / chunkSize; k++)
{
int[,,] chunckMap = new int[chunkSize, chunkSize, chunkSize];
for (int l = 0; l < chunkSize; l++)
{
for (int m = 0; m < chunkSize; m++)
{
for (int n = 0; n < chunkSize; n++)
{
chunckMap[l, m, n] = cave[i * chunkSize + l, j *chunkSize + m, k *chunkSize + n];
}
}
}
BuildChunkAt(i, j, k, chunckMap);
}
}
}
queue.Run(DrawChunks());
/*
* automaton.CreateNew();
* int[,,] cave3D = automaton.cells;
*
*
* for (int i = 0; i < caveWidth / chunkSize; i++)
* {
* for (int j = 0; j < caveHeight / chunkSize; j++)
* {
* for (int m = 0; m < caveDepth / chunkSize; m++)
* {
* int[,,] chunckMap = new int[chunkSize,chunkSize,chunkSize];
* for (int k = 0; k < chunkSize; k++)
* {
* for (int l = 0; l < chunkSize; l++)
* {
* for (int n = 0; n < chunkSize; n++)
* {
*
* chunckMap[k,l,n] = cave3D[i*chunkSize+k,j*chunkSize+l,m*chunkSize+n];
* }
* }
* }
*
* BuildChunkAt(i,j,m,chunckMap);
* }
* }
* }
*/
}
