//////////////////////////////////////////////
private int[] ConvertCubeDataIntoIntArray(CubeStruct cubeData)
{
int[] dataArray = new int[6];
dataArray[0] = (int)cubeData.styleType;
dataArray[1] = (int)cubeData.health;
dataArray[2] = (int)cubeData.objectType;
dataArray[3] = (int)cubeData.rotation.x;
dataArray[4] = (int)cubeData.rotation.y;
dataArray[5] = (int)cubeData.rotation.z;
return(dataArray);
}
//////////////////////////////////////////////
private CubeStruct GetCubeData(GameObject xChild)
{
// set a empty data shell
CubeStruct data = new CubeStruct()
{
styleType = CubeObjectStyles.Default,
health = 0,
objectType = CubeObjectTypes.Empty,
rotation = Vector3.zero
};
GameObject cubeObject = null;
int activeChildcount = 0;
foreach (Transform child in xChild.transform)
{
if (child.gameObject.activeSelf)
{
cubeObject = child.gameObject;
activeChildcount += 1;
Debug.Log("Adding cubeObject.name >> " + cubeObject.name);
}
}
if (activeChildcount == 1)
{
if (!CheckAngle(cubeObject.transform.rotation.eulerAngles))
{
Debug.Log("BAD ANGLE at location >> " + xChild.transform.position);
}
return(data = new CubeStruct()
{
styleType = cubeObject.GetComponent <CubeObjectScript>().cubeStyle,
health = 100,
objectType = cubeObject.GetComponent <CubeObjectScript>().cubeType,
rotation = cubeObject.transform.rotation.eulerAngles
});
}
else if (activeChildcount == 0 || activeChildcount > 1)
{
if (activeChildcount > 1)
{
Debug.Log("TOOOOOOO many child active at loc: " + xChild.transform.position);
}
}
return(data);
}
//////////////////////////////////////////////
private void GetGridInteriorData()
{
dataArrayList = new List <int[]>();
foreach (List <List <GameObject> > yChild in yObjects)
{
foreach (List <GameObject> zChild in yChild)
{
foreach (GameObject xChild in zChild)
{
CubeStruct cubeData = GetCubeData(xChild);
int[] dataArray = ConvertCubeDataIntoIntArray(cubeData);
dataArrayList.Add(dataArray);
}
}
}
}
private void FixedUpdate()
{
foreach (var chunk in loadedChunks)
{
Debug.Log("foreach loadedChunks " + chunk.position.bytePosition);
Debug.Log("foreach loadedChunks player " + playerTransform.position.x + " " + playerTransform.position.y + " " + playerTransform.position.z);
var auxPos = chunk.position.position.ToVector3Float() * chunkSize;
Debug.Log("foreach loadedChunks chunk " + auxPos.x + " " + auxPos.y + " " + auxPos.z);
if ((playerTransform.position - (chunk.position.position.ToVector3Float() * chunkSize)).magnitude >= processedDistance)
{
Debug.Log("foreach loadedChunks >=processedDistance " + chunk.position.bytePosition);
processedChunks.Enqueue(new QueueActionCube(false, chunk.position));
}
}
if (processedChunks.Count > 0)
{
Debug.Log("processedChunks Count>0 " + processedChunks.Count);
var chunkAction = processedChunks.Dequeue();
var chunkPosition = chunkAction.position;
var chunkVectorPosition = chunkPosition.position;
if (chunkAction.add)
{
Debug.Log("true " + chunkVectorPosition.x);
if ((playerTransform.position - chunkVectorPosition.ToVector3Float() * chunkSize).magnitude < processedDistance)
{
Debug.Log("true <processedDistance " + chunkVectorPosition.x);
if (dictChunks.ContainsKey(chunkVectorPosition) && dictChunks[chunkVectorPosition] != null)
{
Debug.Log("true dictChunks Contains !=null " + chunkVectorPosition.x);
int halfChunkSize = chunkSize / 2;
for (int x = 0; x < chunkSize; x++)
{
for (int y = 0; y < chunkSize; y++)
{
for (int z = 0; z < chunkSize; z++)
{
if (dictChunks[chunkVectorPosition][x, y, z] != 0)
{
var addedCube = new CubeStruct(new Vector3Int(chunkVectorPosition.x * chunkSize + x - halfChunkSize, chunkVectorPosition.y * chunkSize + y - halfChunkSize, chunkVectorPosition.z * chunkSize + z - halfChunkSize), dictChunks[chunkVectorPosition][x, y, z]);
if (!Player.instance.grid[false].Contains(addedCube) && !Player.instance.grid[true].Contains(addedCube))
{
Player.instance.grid[false].Add(addedCube);
Debug.Log("true dictChunks Contains !=null for " + chunkVectorPosition.x * chunkSize + x);
}
}
}
}
}
Debug.Log("true dictChunks Contains !=null after for " + chunkVectorPosition.x);
var chunk = new Chunk(dictChunks[chunkVectorPosition], chunkPosition);
if (!loadedChunks.Contains(chunk))
{
Debug.Log("true dictChunks Contains !=null loadChunks NoContains " + chunk.position.bytePosition);
loadedChunks.Add(chunk);
var rightChunk = new Chunk(null, new ChunkPosition(-1, new Vector3Short(++chunkVectorPosition.x, chunkVectorPosition.y, chunkVectorPosition.z)));
chunkVectorPosition.x--;
Debug.Log("true dictChunks Contains !=null loadChunks NoContains right " + chunkVectorPosition.x);
var leftChunk = new Chunk(null, new ChunkPosition(-1, new Vector3Short(--chunkVectorPosition.x, chunkVectorPosition.y, chunkVectorPosition.z)));
chunkVectorPosition.x++;
Debug.Log("true dictChunks Contains !=null loadChunks NoContains left " + chunkVectorPosition.x);
var upChunk = new Chunk(null, new ChunkPosition(-1, new Vector3Short(chunkVectorPosition.x, ++chunkVectorPosition.y, chunkVectorPosition.z)));
chunkVectorPosition.y--;
Debug.Log("true dictChunks Contains !=null loadChunks NoContains up " + chunkVectorPosition.y);
var downChunk = new Chunk(null, new ChunkPosition(-1, new Vector3Short(chunkVectorPosition.x, --chunkVectorPosition.y, chunkVectorPosition.z)));
chunkVectorPosition.y++;
Debug.Log("true dictChunks Contains !=null loadChunks NoContains down " + chunkVectorPosition.y);
var forwardChunk = new Chunk(null, new ChunkPosition(-1, new Vector3Short(chunkVectorPosition.x, chunkVectorPosition.y, ++chunkVectorPosition.z)));
chunkVectorPosition.z--;
Debug.Log("true dictChunks Contains !=null loadChunks NoContains forward " + chunkVectorPosition.z);
var backwardChunk = new Chunk(null, new ChunkPosition(-1, new Vector3Short(chunkVectorPosition.x, chunkVectorPosition.y, --chunkVectorPosition.z)));
chunkVectorPosition.z++;
Debug.Log("true dictChunks Contains !=null loadChunks NoContains backward " + chunkVectorPosition.z);
if (!dictChunks.ContainsKey(rightChunk.position.position))
{
Debug.Log("true dictChunks Contains !=null loadChunks NoContains right dictChunks NoContains " + chunkVectorPosition.x);
if (!ReadChunkInformation(rightChunk.position.position))
{
Debug.Log("true dictChunks Contains !=null loadChunks NoContains right dictChunks NoContains !Read" + chunkVectorPosition.x);
writeQueue.Enqueue(rightChunk.position.position);
processedChunks.Enqueue(new QueueActionCube(true, rightChunk.position));
}
}
if (!dictChunks.ContainsKey(leftChunk.position.position))
{
if (!ReadChunkInformation(leftChunk.position.position))
{
writeQueue.Enqueue(leftChunk.position.position);
processedChunks.Enqueue(new QueueActionCube(true, leftChunk.position));
}
}
if (!dictChunks.ContainsKey(upChunk.position.position))
{
if (!ReadChunkInformation(upChunk.position.position))
{
writeQueue.Enqueue(upChunk.position.position);
processedChunks.Enqueue(new QueueActionCube(true, upChunk.position));
}
}
if (!dictChunks.ContainsKey(downChunk.position.position))
{
if (!ReadChunkInformation(downChunk.position.position))
{
writeQueue.Enqueue(downChunk.position.position);
processedChunks.Enqueue(new QueueActionCube(true, downChunk.position));
}
}
if (!dictChunks.ContainsKey(forwardChunk.position.position))
{
if (!ReadChunkInformation(forwardChunk.position.position))
{
writeQueue.Enqueue(forwardChunk.position.position);
processedChunks.Enqueue(new QueueActionCube(true, forwardChunk.position));
}
}
if (!dictChunks.ContainsKey(backwardChunk.position.position))
{
if (!ReadChunkInformation(backwardChunk.position.position))
{
writeQueue.Enqueue(backwardChunk.position.position);
processedChunks.Enqueue(new QueueActionCube(true, backwardChunk.position));
}
}
}
}
else
{
ReadChunkInformation(chunkPosition.position);
processedChunks.Enqueue(chunkAction);
}
}
else
{
processedChunks.Enqueue(new QueueActionCube(false, chunkPosition));
}
}
else
{
Debug.Log("false " + chunkVectorPosition.x);
if (dictChunks.ContainsKey(chunkVectorPosition))
{
Debug.Log("false dictChunks Contains " + chunkVectorPosition.x);
var chunk = new Chunk(dictChunks[chunkVectorPosition], chunkPosition);
if (loadedChunks.Contains(chunk))
{
Debug.Log("false loadedChunks Contains " + chunk.position.bytePosition);
loadedChunks.Remove(chunk);
}
dictChunks.Remove(chunkVectorPosition);
}
}
}
}
private void CollectObjectsData()
{
ObjectScript[] objs = FindObjectsOfType(typeof(ObjectScript)) as ObjectScript[];
objectsData = new Dictionary <Vector3, int[]>();
foreach (ObjectScript obj in objs)
{
Vector3 objPos = obj.transform.position;
Vector3 globalRot = obj.transform.rotation.eulerAngles;
Vector3 localRot = obj.transform.localRotation.eulerAngles;
Vector3 objFace = obj.transform.forward;
Vector3Int forceRotation = obj.GetComponent <ObjectScript>().forcedRotation;
int parentYAxis = (int)obj.transform.parent.localEulerAngles.y;
//Debug.Log("objFace == " + objFace); //<< This is where we left off (need to combine both trans.forward & tras.euler, to get proper pos/rot data
// Debug.Log("objRot == " + objRot); //<< This is where we left off (need to combine both trans.forward & tras.euler, to get proper pos/rot data
Vector3Int objRot = new Vector3Int(forceRotation.x, forceRotation.y + parentYAxis, forceRotation.z);
if (objRot.x >= 360)
{
objRot.x -= 360;
}
if (objRot.y >= 360)
{
objRot.y -= 360;
}
if (objRot.z >= 360)
{
objRot.z -= 360;
}
if (objRot.z == 90) // Walls
{
if (objRot.y == 0 || objRot.y == 180)
{
objRot.y = 0;
}
if (objRot.y == 90 || objRot.y == 270)
{
objRot.y = 90;
}
}
else
{
}
//Debug.Log("globalRot.y == " + globalRot + " localRot.y == " + localRot); //<< This is where we left off (need to combine both trans.forward & tras.euler, to get proper pos/rot data
//Debug.Log("objRot >>>>>>>>> " + objRot); //<< This is where we left off (need to combine both trans.forward & tras.euler, to get proper pos/rot data
string name = obj.gameObject.GetComponent <Renderer>().material.name.Replace("(Instance)", "");
//Debug.Log("f**k name >>>>>>>> " + name);
ObjectTextures objTexture = (ObjectTextures)Enum.Parse(typeof(ObjectTextures), name);
CubeStruct data = new CubeStruct()
{
objectType = obj.objectType,
styleType = obj.objectStyle,
objectTexture = objTexture,
health = 100,
rotation = objRot
};
int[] dataArray = ConvertCubeDataIntoIntArray(data);
Vector3 roundedPos = GetRoundedVector3(objPos);
if (!objectsData.ContainsKey(roundedPos))
{
objectsData.Add(roundedPos, dataArray);
}
// Debug.Log("Total Panel Objects Postion == " + objPos);
}
Debug.Log("Total Panel Objects in Scene == " + objectsData.Count);
}
//////////////////////////////////////////////
private void SaveDataArrayIntoDoc()
{
#if UNITY_EDITOR
string path = AssetDatabase.GetAssetPath(TextFile);
File.WriteAllText(path, "");
if (File.Exists(path))
{
int count = 1;
int successfulData = 0;
foreach (Vector3 loc in gridNodeLocations)
{
int[] dataArray;
if (objectsData.ContainsKey(loc))
{
dataArray = objectsData[loc];
successfulData++;
//Debug.Log("Recording data into file at loc == " + loc);
}
else
{
// set a empty data shell
CubeStruct data = new CubeStruct()
{
objectType = CubeObjectTypes.Empty,
styleType = CubeObjectStyles.Default,
objectTexture = ObjectTextures.Nothing,
health = 0,
rotation = Vector3Int.zero
};
dataArray = ConvertCubeDataIntoIntArray(data);
}
string dataString = "";
for (int i = 0; i < dataArray.Length; i++)
{
int data = dataArray[i];
dataString += data.ToString();
if (i < dataArray.Length - 1)
{
dataString += " ";
}
else if (count != gridNodeLocations.Count)
{
dataString += ",\n";
}
}
File.AppendAllText(path, dataString);
count++;
}
Debug.Log("Recording data successfulData == " + successfulData);
}
else
{
Debug.Log("GOT AN ISSUE HERE");
}
#endif
}
public QueueActionPlayer(bool add, CubeStruct cube)
{
this.add = add;
this.cube = cube;
}
