public void SetData(BrickData data)
{
reference = data.reference;
mesh = new Mesh();
Vector3[] vertices = new Vector3[data.vertices.Length / 3];
for (int i = 0; i < vertices.Length; i++)
{
vertices[i] = new Vector3((float)data.vertices[3 * i], (float)data.vertices[3 * i + 1], (float)data.vertices[3 * i + 2]);
}
int[] triangles = new int[data.triangles.Length];
for (int i = 0; i < triangles.Length; i++)
{
triangles[i] = Mathf.RoundToInt((float)data.triangles[i]);
}
Vector2[] uvs = new Vector2[data.uvs.Length / 2];
for (int i = 0; i < uvs.Length; i++)
{
uvs[i] = new Vector2((float)data.uvs[2 * i], (float)data.uvs[2 * i + 1]);
}
mesh.vertices = vertices;
mesh.triangles = triangles;
mesh.uv = uvs;
mesh.RecalculateNormals();
}
private int SortByGridYPosition(BrickData t1, BrickData t2)
{
var cell1 = GetBrickCell(t1.id);
var cell2 = GetBrickCell(t2.id);
return(cell2.Coordinates.y.CompareTo(cell1.Coordinates.y));
}
public List <BrickData> GetNeighbourPowerBricks(BrickData powerBrick)
{
List <BrickData> visited = new List <BrickData>();
RecurseNeighbourPowerBricks(powerBrick, visited);
return(visited);
}
void ConnectBricks(BrickData b1, BrickData b2)
{
b1.ConnectedBricks.Add(b2);
b2.ConnectedBricks.Add(b1);
b1.NeighbourBricks.Add(b2);
b2.NeighbourBricks.Add(b1);
}
/*****************************************************************************
* COMPUTE METHODS
*****************************************************************************/
/// <summary>
/// An example of how to use compute shaders in Unity.
/// Does not perform any useful function with regards to rendering the volume.
/// </summary>
/// <returns></returns>
public BrickData[] runBrickAnalysis()
{
// Create the brick data
BrickData[] computeData = new BrickData[currentVolume.Bricks.Length];
for (int i = 0; i < currentVolume.Bricks.Length; i++)
{
computeData[i] = currentVolume.Bricks[i].getBrickData();
}
// Put the brick data into a compute buffer
ComputeBuffer buffer = new ComputeBuffer(computeData.Length, 28); // Note: 28 is the number of bytes in a BrickData struct
buffer.SetData(computeData);
// Send the compute buffer data to the GPU
brickAnalysisShader.SetBuffer(analysisKernelID, "dataBuffer", buffer);
// Send the camera's position to the GPU
brickAnalysisShader.SetVector("cameraPosition", new Vector4(mainCamera.transform.position.x, mainCamera.transform.position.y, mainCamera.transform.position.z, 0.0f));
// Run the kernel
brickAnalysisShader.Dispatch(analysisKernelID, computeData.Length, 1, 1);
// Retrieve the data
BrickData[] analyzedData = new BrickData[currentVolume.Bricks.Length];
buffer.GetData(analyzedData);
buffer.Dispose();
// Return the analyzed data
return(analyzedData);
}
public List <string> getElements(BrickData collection)
{
List <string> elements = new List <string>();
if (collection.Rows != null)
{
List <Dictionary <string, Dictionary <string, string> > > brickRows = collection.Rows;
foreach (Dictionary <string, Dictionary <string, string> > brickpoint in brickRows)
{
foreach (Dictionary <string, string> br in brickpoint.Values)
{
foreach (string b in br.Values)
{
if (b != "http://building1.com")
{
//text=text+b+"\n";
elements.Add(b);
//UnityEngine.Debug.Log(b);
}
}
}
}
}
return(elements);
}
public List <LXFMLCell> GetBrickCells(int brickId)
{
List <LXFMLCell> cells = new List <LXFMLCell>();
BrickData brickData = _bricks[brickId];
int brickWidth = LXFMLHelper.GetBrickWidth(brickData.design.id);
int brickHeight = LXFMLHelper.GetBrickHeight(brickData.design.id);
Vector2 brickOrigin = GetBrickOrigin(brickId);
int originX = !LXFMLHelper.IsBrickFlipped(brickData) ? (int)brickOrigin.x : (int)brickOrigin.x - brickWidth + 1;
int originY = (int)brickOrigin.y;
// Debug.Log ("brickId = " + brickId.ToString());
// Debug.Log (brickOrigin);
// Debug.Log (originX);
// Debug.Log("***");
for (int i = originX; i < originX + brickWidth; i++)
{
for (int j = originY; j < originY + brickHeight; j++)
{
// Debug.Log (i.ToString() + " - " + j.ToString());
cells.Add(_grid.GetCellAt(i, j));
}
}
// Debug.Log("-------------------------");
return(cells);
}
public IEnumerator AnimateBrickScanRandom()
{
_numBricksToAnimate = _bricks.Count;
_bricks.Sort(SortByYAscending);
for (int i = 0; i < _bricks.Count; ++i)
{
_bricks[i].gameObject.SetLayerRecursively(8);
_bricks[i].gameObject.SetActive(false);
}
for (int i = 0; i < _bricks.Count; ++i)
{
yield return(new WaitForEndOfFrame());
yield return(new WaitForEndOfFrame());
_bricks[i].gameObject.SetActive(true);
LegoBrickId legoBrick = _bricks[i].GetComponent <LegoBrickId>();
BrickData bd = construction.GetBrick(legoBrick.id);
int[] availColors = LXFMLHelper.GetColors(legoBrick.designId);
int numIterations = Random.Range(15, 20);
StartCoroutine(AnimateBrickColors(LXFMLHelper.GetColors(legoBrick.designId), bd.materialId, _bricks[i].gameObject, numIterations));
}
yield return(StartCoroutine("WaitForAnimComplete"));
}
void RenderSlope(BrickData brick)
{
_fullGO.SetActive(true);
_slopeGO.SetActive(true);
_fullTransform.localScale = new Vector3(1.0f, (float)brick.design.height, 1.0f);
var scaleX = (float)brick.design.width - 1.0f;
var scaleY = (float)brick.design.height;
if (brick.isFlipped)
{
scaleX *= -1.0f;
}
else
{
_slopeTransform.localPosition = Vector3.right * _slopeTransform.rect.width;
}
if (brick.design.type == BrickType.SlopeUp || brick.design.type == BrickType.CurveIn)
{
var pos = _slopeTransform.localPosition;
_slopeTransform.localPosition = new Vector3(pos.x, _slopeTransform.rect.width * scaleY, pos.z);
scaleY *= -1.0f;
}
_slopeTransform.localScale = new Vector3(scaleX, scaleY, 1.0f);
}
public List <StageData> JsonParser(JsonData jsonData)
{
List <StageData> dataList = new List <StageData>();
for (int dataCount = 0; dataCount < jsonData.Count; ++dataCount)
{
JsonData nowJsonData = jsonData[dataCount];
StageData tempData = new StageData();
tempData.stageName = nowJsonData["stageName"].ToString();
int.TryParse(nowJsonData["difficulty"].ToString(), out tempData.difficulty);
int.TryParse(nowJsonData["gold"].ToString(), out tempData.gold);
for (int i = 0; i < nowJsonData["brickData"].Count; ++i) // 벽돌 데이터 가져오기.
{
BrickData tempBrickData = new BrickData(
int.Parse(nowJsonData["brickData"][i]["id"].ToString()),
double.Parse(nowJsonData["brickData"][i]["x"].ToString()),
double.Parse(nowJsonData["brickData"][i]["y"].ToString())
);
tempData.brickData.Add(tempBrickData);
}
for (int i = 0; i < nowJsonData["lockBullet"].Count; ++i) // 총알 잠금데이터 가져오기.
{
tempData.lockBullet = new List <int>();
tempData.lockBullet.Add(
int.Parse(nowJsonData["lockBullet"][i].ToString())
);
}
dataList.Add(tempData); // 데이터 리스트에 저장.
}
return(dataList);
}
public void showVAVs()
{
string query2 = "SELECT ?vav WHERE {?vav rdf:type brick:VAV . ?room bf:isLocatedIn building1:Floor_1 . ?vav bf:isLocatedIn ?room .};";
string vavData = runQuery(query2);
List <string> vavs = new List <string>();
BrickData vavCollection = JsonConvert.DeserializeObject <BrickData>(vavData);
while (vavCollection.Errors != null)
{
vavData = runQuery(query2);
vavCollection = JsonConvert.DeserializeObject <BrickData>(vavData);
}
vavs = getElements(vavCollection);
foreach (string vav in vavs)
{
string query1 = "SELECT ?room WHERE {building1:" + vav + " bf:isLocatedIn ?room .};";
string roomData = runQuery(query1);
UnityEngine.Debug.Log(roomData);
BrickData roomCollection = JsonConvert.DeserializeObject <BrickData>(roomData);
List <string> rooms = getElements(roomCollection);
foreach (string room in rooms)
{
createBlob(vav, "Cube3", room);
visibleObjects.Add("sensor_" + vav);
}
}
}
public void Accumulate(ref BrickData _other)
{
albedo += _other.albedo;
opacity += _other.opacity;
normal += _other.normal;
variance += _other.variance;
accumulationCounter++;
}
public void AddBrick(BrickData brick)
{
_bricks[brick.id] = brick;
_bricksCellsCache[brick.id] = new LXFMLCell[brick.design.width * brick.design.height];
var brickOrigin = GetNormalizedBrickOrigin(brick);
var normalizedOrigin = new Vector2(brickOrigin.x, brickOrigin.y);
if (brick.isFlipped)
{
normalizedOrigin.x = normalizedOrigin.x - (brick.design.width - 1);
}
LXFMLCell originCell = _grid.GetCellAt(brickOrigin);
LXFMLCell cell;
LXFMLCellData cellData;
int cellCount = 0;
for (int y = 0; y < brick.design.height; ++y)
{
for (int x = 0; x < brick.design.width; ++x)
{
cellData = new LXFMLCellData();
cell = _grid.GetCellAt(normalizedOrigin.x + x, normalizedOrigin.y + y);
if (normalizedOrigin.x + x >= LXFMLHelper.kGridSize || normalizedOrigin.y + y >= LXFMLHelper.kGridSize)
{
Debug.LogWarning("Invalid position");
}
_bricksCellsCache[brick.id][cellCount++] = cell;
if (!cell.IsEmpty)
{
//Debug.LogWarningFormat("Overriting cell at {0}.", cell.Coordinates);
}
cellData.Brick = brick;
//TODO: Is it necessary?
cellData.IsFull = true;
cell.Data = cellData;
cell.BrickOrigin = originCell;
}
}
SetConnectedBricks(brick, brickOrigin);
originCell.Data.IsOrigin = true;
CommitChange(ConstructionChangesetOperation.Addition, originCell.Data.Brick, originCell.Coordinates);
_lastBrickId++;
}
void CommitChange(ConstructionChangesetOperation operation, BrickData brick, Vector2 coordinates)
{
_rectIsDirty = true;
if (OnChanged != null)
{
OnChanged(new ConstructionChangeset(operation, brick, coordinates));
}
}
public void StopBricksAnimation()
{
StopAllCoroutines();
_numBricksAnimateComplete = _numBricksToAnimate;
for (int i = 0; i < _bricks.Count; ++i)
{
var renderer = _bricks [i].GetComponentInChildren <MeshRenderer>();
LegoBrickId legoBrick = _bricks [i].GetComponent <LegoBrickId> ();
BrickData bd = construction.GetBrick(legoBrick.id);
renderer.sharedMaterial = ConstructionController.Instance.resourcesProvider.GetMaterial(bd.materialId);
}
}
public void Init(BrickData data, Transform[] blocks)
{
_data = data;
Blocks = blocks;
for (int i = 0; i < _data.Cells.Length; i++)
{
var block = Blocks[i];
block.SetParent(this.transform);
block.localPosition = _data.Cells[i];
}
}
public void showRooms()
{
string query = "SELECT ?room WHERE {?room rdf:type brick:Room . ?room bf:isLocatedIn building1:Floor_1 .};";
string roomsData = runQuery(query);
List <string> Rooms = new List <string>();
BrickData roomsCollection = JsonConvert.DeserializeObject <BrickData>(roomsData);
Rooms = getElements(roomsCollection);
foreach (string room in Rooms)
{
string roomObj = room.Replace("Room-", "");
Collider newObj = GameObject.Find(roomObj).GetComponent <Collider>();
Vector3 centreOfRoom = newObj.bounds.center;
centreOfRoom.y = 4.0f;
if (centreOfRoom.z > 25.0f)
{
centreOfRoom.z = centreOfRoom.z + UnityEngine.Random.Range(-1.0f, 1.0f);
}
if (roomObj.Contains("-184"))
{
centreOfRoom.x = centreOfRoom.x - 5.0f;
}
else if (roomObj.Contains("-158"))
{
centreOfRoom.z = centreOfRoom.z - 4.0f;
}
else if (roomObj.Contains("-150"))
{
centreOfRoom.z = centreOfRoom.z - 4.0f;
}
else if (roomObj.Contains("-152"))
{
centreOfRoom.z = centreOfRoom.z - 4.0f;
}
GameObject blob = Instantiate(roomTextBox2);
blob.transform.position = centreOfRoom;
blob.gameObject.SetActive(true);
TextMeshPro textmeshPro = blob.gameObject.GetComponent <TextMeshPro>();
textmeshPro.SetText(roomObj);
blob.name = room;
visibleObjects.Add(blob.name);
}
}
public void showBrickData(string roomNumber, Vector3 position, Color color)
{
Vector3 offset = new Vector3(350, 0, 0);
brickBox.transform.position = position + offset;
brickBox.gameObject.SetActive(true);
TMP_InputField textscript = GameObject.Find("InputField").GetComponentInChildren <TMP_InputField>(); // This will get the script responsable for editing text
Outline outl = GameObject.Find("InputField").GetComponentInChildren <Outline>();
outl.effectColor = color;//new Color(0.0f, 0.0f, 0.0f);
//refresh input box value
textscript.text = "";
string query = "SELECT ?point WHERE{building1:Room-" + roomNumber + " bf:isLocationOf ?point};";
string text = "";
UnityEngine.Debug.Log(query);
string brickData = getBrickData(query);
UnityEngine.Debug.Log(brickData);
BrickData brickCollection = JsonConvert.DeserializeObject <BrickData>(brickData);
List <string> points = getElements(brickCollection);
foreach (string point in points)
{
string query2 = "SELECT ?type WHERE {building1:" + point + " a ?type.};";
string pointData = getBrickData(query2);
BrickData pointCollection = JsonConvert.DeserializeObject <BrickData>(pointData);
string type = getElements(pointCollection)[0];
if (type.Contains("Sensor"))
{
text = text + " <sprite index=1><b>" + type + "</b>\n";
UnityEngine.Debug.Log("Object creating " + point);
GameObject blob = createBlob(point, "Cube", "Room-" + roomNumber);
}
if (type.Contains("Setpoint"))
{
text = text + " <sprite index=0><b>" + type + "</b>\n";
UnityEngine.Debug.Log("Object creating " + point);
GameObject blob = createBlob(point, "Cube2", "Room-" + roomNumber);
}
text = text + point + "\n";
}
string message = "<b><u>Room" + roomNumber + "</u></b>\n" + text;
textscript.text = message; // This will change the text inside it
}
private void StoreBrick(BrickBase levelBrick)
{
var position = levelBrick.transform.position;
position = RoundVector(position);
var newData = new BrickData
{
position = position,
eulerRotation = levelBrick.transform.localEulerAngles,
scale = levelBrick.transform.localScale,
brickType = levelBrick.brickType
};
levelData.bricks.Add(newData);
}
void RenderNormal(BrickData brick)
{
_fullGO.SetActive(true);
var scaleX = (float)brick.design.width;
var scaleY = (float)brick.design.height;
if (brick.isFlipped)
{
scaleX *= -1.0f;
_fullTransform.localPosition = Vector3.right * _fullTransform.rect.width;
}
_fullTransform.localScale = new Vector3(scaleX, scaleY, 1.0f);
}
public void PutBrick()
{
Debug.Log("Put brick functino called");
Vector2 mousePos = Input.mousePosition;
Vector2 worldPos = Camera.main.ScreenToWorldPoint(mousePos);
Vector2 brickPos = new Vector2(Mathf.RoundToInt(worldPos.x / brickOffset.x) * brickOffset.x, Mathf.RoundToInt(worldPos.y / brickOffset.y) * brickOffset.y);
int maxXBricks = (int)(GameManager.GetBounds().x / brickOffset.x);
Debug.Log("Max X Axis bricks : " + maxXBricks + " | X bound : " + GameManager.GetBounds().x);
float remainingX = GameManager.GetBounds().x - (maxXBricks * brickOffset.x) - (brickOffset.x / 2);
Debug.Log("Remaining X : " + remainingX);
int maxYBricks = (int)(GameManager.GetBounds().y / brickOffset.y);
float remainingY = GameManager.GetBounds().y - (maxYBricks * brickOffset.y) - (brickOffset.y / 2);
float maxX = GameManager.GetBounds().x - (remainingX + brickOffset.x * (sidesOffset - 1));
Collider2D[] overlapping = Physics2D.OverlapCircleAll(worldPos, 0.3f);
if (overlapping.Length == 0 &&
!removing &&
worldPos.y >= yMinPos &&
worldPos.y <= GameManager.GetBounds().y - (remainingY + brickOffset.y * topOffset) &&
worldPos.x <= maxX &&
worldPos.x >= -maxX)
{
Debug.Log("<color=green>Brick successfully placed</color>");
GameObject obj = Instantiate(brickPrefab, brickPos, Quaternion.identity);
bricksObj.Add(obj);
BrickData bd = new BrickData(brickPos, brickType);
bricks.Add(bd);
}
if (removing)
{
if (bricksObj.Count > 0)
{
int brickIndex = bricksObj.IndexOf(overlapping[0].gameObject);
if (bricksObj.Contains(overlapping[0].gameObject))
{
Destroy(bricksObj[brickIndex]);
bricksObj.RemoveAt(brickIndex);
bricks.RemoveAt(brickIndex);
}
}
}
}
public void Render(BrickData brick)
{
Reset();
if (brick.design.type == BrickType.Normal)
{
RenderNormal(brick);
}
else
{
RenderSlope(brick);
}
_fullImage.color = LXFMLHelper.GetBrickColor(brick.materialId);
_slopeImage.color = LXFMLHelper.GetBrickColor(brick.materialId);
}
// Misc
public void SetBrickProperties(BrickData b, int ID)
{
Brick br = LoadedMap.MapElements[ID] as Brick; // unsafe, what if this element isn't a brick?
br.Name = b.Name;
br.Position = b.Position;
br.Scale = b.Scale;
br.Rotation = b.Rotation;
br.BrickColor = b.BrickColor;
br.Transparency = b.Transparency;
br.CollisionEnabled = b.Collision;
br.Clickable = b.Clickable;
br.Shape = (Brick.ShapeType)b.Shape;
br.Model = b.Model;
br.ScuffedScale = b.Rotation != 0 && b.Rotation != 180;
}
void CreateLaser(BrickData laserBrick, int direction)
{
var laser = new ConstructionLaser();
laser.brickId = laserBrick.id;
laser.direction = direction;
var neighbours = GetNeighbourPowerBricks(laserBrick);
int power = 0;
for (int k = 0; k < neighbours.Count; k++)
{
power += neighbours[k].design.width * neighbours[k].design.height;
}
laser.power = power / 2;
_lasers.Add(laser);
}
public static bool IsBrickFlipped(BrickData brick)
{
var rotation = brick.rotation.eulerAngles;
if (MathUtils.NearEqual(rotation.y, 0.0f) || MathUtils.NearEqual(rotation.y, 90.0f))
{
return(false);
}
if (MathUtils.NearEqual(rotation.y, 180.0f) || MathUtils.NearEqual(rotation.y, 270.0f))
{
return(true);
}
throw new Exception(string.Format("Brick [{0}] has an invalid Y rotation of {1}.", brick.id, rotation.y));
}
void RecurseVisitedBricks(BrickData brick, List <BrickData> visited)
{
if (visited.Contains(brick))
{
return;
}
else
{
visited.Add(brick);
}
foreach (BrickData connected in brick.ConnectedBricks)
{
RecurseVisitedBricks(connected, visited);
}
}
public List <string> returnInfo(string query)
{
string data = getBrickData(query);
List <string> result = new List <string>();
BrickData collection = JsonConvert.DeserializeObject <BrickData>(data);
while (collection.Rows == null)
{
data = getBrickData(query);
collection = JsonConvert.DeserializeObject <BrickData>(data);
}
result = getElements(collection);
return(result);
}
void RecurseNeighbourPowerBricks(BrickData brick, List <BrickData> visited)
{
if (visited.Contains(brick) || !LXFMLHelper.IsPowerBrick(brick.design.id, brick.materialId))
{
return;
}
else
{
visited.Add(brick);
}
foreach (BrickData connected in brick.NeighbourBricks)
{
RecurseNeighbourPowerBricks(connected, visited);
}
}
public void Copy(Brick[] bricks)
{
Clipboard.bricks = new BrickData[bricks.Length];
for (int i = 0; i < bricks.Length; i++)
{
BrickData b = new BrickData(bricks[i]);
if (SettingsManager.Settings.CopySuffix)
{
b.Name = b.Name + " - Copy";
}
Clipboard.bricks[i] = b;
}
string bricksToCopy = SettingsManager.Settings.CopyToWorkshopFormat ? MapExporter.ExportBRKFromBricklist(Clipboard) : JsonUtility.ToJson(Clipboard);
Helper.CopyToClipboard(bricksToCopy);
}
public BrickData GetBrickData()
{
var brick = new BrickData();
brick.design = new BrickDesignData();
brick.id = id;
brick.materialId = materialId;
brick.design.id = designId;
brick.design.width = designWidth;
brick.design.height = designHeight;
brick.design.type = designType;
brick.position = new Vector3(positionX, positionY, positionZ);
brick.scale = new Vector3(scaleX, scaleY, scaleZ);
brick.rotation = new Quaternion(rotationX, rotationY, rotationZ, rotationW);
brick.isFlipped = isFlipped;
return(brick);
}
public void SaveStageData()
{
stageData.brickData = new List <BrickData>();
foreach (var it in FindObjectsOfType <BrickItem>()) // 블럭 찾기.
{
if (it.isSetup)
{
BrickData temp = new BrickData(it.brickId, it.pivot.x, it.pivot.y);
stageData.brickData.Add(temp);
}
}
if (SaveStageDataReturn())
{
m_animator.SetTrigger("Save");
}
return;
}
void Update()
{
if(Application.loadedLevelName == "Title"){
CurrentGameState = GameState.Title;
}
switch (CurrentGameState){
case GameState.Title:
if(!guiManager.displayingWindow){
if(guiManager.displayWindowFor(titleWindows[titleIterator], 5f)){
titleIterator++;
if(titleIterator == titleWindows.Length){
titleIterator = 0;
}
}
}
if(Input.GetMouseButtonDown(0)){
Application.LoadLevel("HughTestLevel01");
CurrentGameState = GameState.ConfigureLevel;
}
break;
case GameState.ConfigureLevel:
guiManager.resetWindow();
GameObject[] Blocks = GameObject.FindGameObjectsWithTag("block");
allBricks = new BrickData[Blocks.Length];
for(int i = 0; i<allBricks.Length; i++){
brick currBrick = Blocks[i].GetComponent<brick>();
currBrick.id = i;
allBricks[i] = new BrickData((int)currBrick.maxHealth, i, currBrick, this);
}
aliveBricks = new List<BrickData>(allBricks);
totalLevelHealth = GetTotalLevelHealth();
roundClock = Time.time + roundDuration;
guiManager.displayingUi = true;
CurrentGameState = GameState.Playing;
break;
case GameState.Start:
break;
case GameState.Playing:
if(Input.GetMouseButtonDown(0)){
//ballIterator++;
currDodgeballs.Add(Shoot(Input.mousePosition).GetComponent<Dodgeball>());//new DodgeballData(Shoot(Input.mousePosition),ballIterator));
}
float currProg = ((float)GetDestroyedBlocks()/(float)allBricks.Length);
currDispTickets = Mathf.MoveTowards(currDispTickets, currProg,
Time.deltaTime*meterFill*Mathf.Abs(currDispTickets-currProg));//*meterFill);
guiManager.updateSlider("CompletionMeter", currDispTickets);
guiManager.progressPercent = (int)(currProg*100f);
for(int i =0; i<aliveBricks.Count;i++){
int aliveBrickId = aliveBricks[i].id;
if(allBricks[aliveBrickId].checkBlock()){
aliveBricks.RemoveAt(i);
}
}
if(currDodgeballs.Count > 0){
for(int i = 0; i<currDodgeballs.Count;i++){
if(currDodgeballs[i].destroyMe){
if(currDodgeballs[i].amtOfBricksHit >= 30){
guiManager.displayWindowFor("50kills", 5f);
}
currTickets = currTickets + Mathf.Clamp((Mathf.Pow((1f+comboRate),(float)(currDodgeballs[i].amtOfBricksDestroyed)))/100, 0, 100); //combo rate
compTickets += (int)(Mathf.Floor(currTickets));
currTickets = currTickets-(Mathf.Floor(currTickets));
guiManager.updateSlider("ticketMeter", currTickets);
Destroy(currDodgeballs[i]);
currDodgeballs.RemoveAt(i);
}
}
}
//------ UPDATE GUIMANAGER WITH TIMER AND TICKETS
guiManager.timeLeft = Mathf.Ceil(roundClock-Time.time);
guiManager.dispTickets = compTickets;
if(roundClock-Time.time <= 0){
guiManager.resetWindow(false);
CurrentGameState = GameState.Lost;
}
if(aliveBricks.Count == 0){
CurrentGameState = GameState.Won;
}
break;
case GameState.Won:
guiManager.displayingUi = false;
if(guiManager.displayWindowFor("Won", 5f)){
if(guiManager.finishedDisplaying.ToLower() == "won"){
guiManager.resetWindow();
CurrentGameState = GameState.GameOver;
}
}
break;
case GameState.Lost:
guiManager.displayingUi = false;
if(guiManager.displayWindowFor("Lost", 5f)){
if(guiManager.finishedDisplaying.ToLower() == "lost"){
guiManager.resetWindow();
CurrentGameState = GameState.GameOver;
}
}
break;
case GameState.GameOver:
guiManager.displayingUi = false;
if(guiManager.displayWindowFor("gameover", 5f)){
if(guiManager.finishedDisplaying.ToLower() == "gameover"){
guiManager.resetWindow();
CurrentGameState = GameState.Title;
Application.LoadLevel("Title");
}
}
break;
default:
break;
}
print(CurrentGameState);
}
