private void CheckForDirtAndCleanIfPossible()
{
if (_currentCapacity == 0)
{
return;
}
// Check tile below me
var realWorldPosition = transform.position;
var vLocPos = _doodadsBackgroundTilemap.transform.InverseTransformPoint(realWorldPosition);
var gridX = BrushUtil.GetGridX(vLocPos, _doodadsBackgroundTilemap.CellSize);
var gridY = BrushUtil.GetGridY(vLocPos, _doodadsBackgroundTilemap.CellSize);
var gridPosition = TilemapUtils.GetGridPosition(
_doodadsBackgroundTilemap,
new Vector2(realWorldPosition.x, realWorldPosition.y)
);
gridPosition = new Vector2(gridX, gridY);
var tileData = _doodadsBackgroundTilemap.GetTileData(gridPosition);
// Remove the tile below me!
if (IsDirtTile(tileData))
{
_doodadsBackgroundTilemap.Erase(gridPosition);
_doodadsBackgroundTilemap.UpdateMesh();
_currentCapacity--;
}
}
public override void OnSceneGUI()
{
base.OnSceneGUI();
if (!m_tilemap && !m_tileset)
{
return;
}
Vector2 center = Vector2.zero;
if ((ePositionType)m_action.positionType.Value == ePositionType.LocalPosition)
{
center = m_action.position.Value;
}
else// if ((ePositionType)positionType.Value == ePositionType.GridPosition)
{
if (m_tilemap)
{
center = TilemapUtils.GetTileCenterPosition(m_tilemap, (int)m_action.position.Value.x, (int)m_action.position.Value.y);
}
else if (m_tileset)
{
center = TilemapUtils.GetGridWorldPos((int)m_action.position.Value.x, (int)m_action.position.Value.y, m_tileset.TilePxSize / m_tileset.PixelsPerUnit);
}
}
EditorCompatibilityUtils.CircleCap(0, center, Quaternion.identity, m_action.radius.Value);
}
protected void DoColorPaintAction()
{
var go = Fsm.GetOwnerDefaultTarget(gameObject);
if (UpdateCache(go))
{
STETilemap tilemap = cachedComponent as STETilemap;
Vector2 center;
if ((ePositionType)positionType.Value == ePositionType.LocalPosition)
{
center = position.Value;
}
else// if ((ePositionType)positionType.Value == ePositionType.GridPosition)
{
center = TilemapUtils.GetTileCenterPosition(tilemap, (int)position.Value.x, (int)position.Value.y);
}
if (applyToTilemapGroup.Value && tilemap.ParentTilemapGroup)
{
tilemap.ParentTilemapGroup.IterateTilemapWithAction(
(STETilemap tmap) =>
{
TilemapVertexPaintUtils.VertexPaintCircle(tmap, center, radius.Value, tileColor.Value, (eBlendMode)blendingMode.Value, (eTileColorPaintMode)tileColorPaintMode.Value == eTileColorPaintMode.Vertex, intensityCurve.curve);
tmap.UpdateMesh();
}
);
}
else
{
TilemapVertexPaintUtils.VertexPaintCircle(tilemap, center, radius.Value, tileColor.Value, (eBlendMode)blendingMode.Value, (eTileColorPaintMode)tileColorPaintMode.Value == eTileColorPaintMode.Vertex, intensityCurve.curve);
tilemap.UpdateMesh();
}
}
}
protected virtual void RecalculateDebugPoints(Vector2 startPoint, Vector2 endPoint, DrawingFunction drawingFunc)
{
STETilemap tilemap = GetTargetTilemap();
if (!tilemap)
{
return;
}
Vector2 cellSizeDiv2 = tilemap.CellSize / 2f;
m_debugPoints.Clear();
int x0, y0, x1, y1;
if ((ePositionType)m_action.positionType.Value == ePositionType.LocalPosition)
{
x0 = TilemapUtils.GetGridX(tilemap, startPoint);
y0 = TilemapUtils.GetGridY(tilemap, startPoint);
x1 = TilemapUtils.GetGridX(tilemap, endPoint);
y1 = TilemapUtils.GetGridY(tilemap, endPoint);
}
else //if ((ePositionType)m_action.positionType.Value == ePositionType.GridPosition)
{
x0 = (int)startPoint.x;
y0 = (int)startPoint.y;
x1 = (int)endPoint.x;
y1 = (int)endPoint.y;
}
drawingFunc(x0, y0, x1, y1,
(x, y) =>
{
m_debugPoints.Add(new Vector2(x * tilemap.CellSize.x + cellSizeDiv2.x, y * tilemap.CellSize.y + cellSizeDiv2.y));
return(true);
});
}
public override void Reset()
{
base.Reset();
material = new FsmMaterial()
{
Value = TilemapUtils.FindDefaultSpriteMaterial()
};
}
public override void OnInspectorGUI()
{
base.DrawDefaultInspector();
TilemapUtils tilemapUtils = (TilemapUtils)target;
if (GUILayout.Button("Clear Tilemap"))
{
tilemapUtils.ClearTilemap();
}
}
public static TilemapSerializedData SerializeTilemap(STETilemap tilemap)
{
TilemapSerializedData data = new TilemapSerializedData();
System.Action <STETilemap, int, int, uint> action = (tmap, gridX, gridY, tileData) =>
{
data.tileDataList.Add(new TilemapSerializedData.TileData()
{
gridX = gridX, gridY = gridY, tileData = tileData
});
};
TilemapUtils.IterateTilemapWithAction(tilemap, action);
return(data);
}
public override void Reset()
{
base.Reset();
material = new FsmMaterial()
{
Value = TilemapUtils.FindDefaultSpriteMaterial()
};
tintColor = Color.white;
parallaxFactor = Vector2.one;
pixelSnap = false;
sortingLayer = "Default";
orderInLayer = 0;
innerPadding = 0f;
visible = true;
}
public override void Reset()
{
name = "";
tileset = null;
//parentGameObject = new FsmOwnerDefault() { OwnerOption = OwnerDefaultOption.SpecifyGameObject, GameObject = { UseVariable = true } };
parentGameObject = null;
material = new FsmMaterial()
{
Value = TilemapUtils.FindDefaultSpriteMaterial()
};
sortingLayer = "Default";
orderInLayer = 0;
minGridX = 0;
minGridY = 0;
maxGridX = 0;
maxGridY = 0;
}
public override void OnEnter()
{
var go = Fsm.GetOwnerDefaultTarget(gameObject);
if (UpdateCache(go))
{
STETilemap tilemap = cachedComponent as STETilemap;
int gridX;
int gridY;
if ((ePositionType)positionType.Value == ePositionType.LocalPosition)
{
gridX = TilemapUtils.GetGridX(tilemap, startPaintingPosition.Value);
gridY = TilemapUtils.GetGridY(tilemap, startPaintingPosition.Value);
}
else// if ((ePositionType)positionType.Value == ePositionType.GridPosition)
{
gridX = (int)startPaintingPosition.Value.x;
gridY = (int)startPaintingPosition.Value.y;
}
if (tileSelection.selectionData.Length == 1)
{
tilemap.SetTileData(gridX, gridY, (uint)tileSelection.selectionData[0]);
}
else
{
int w = tileSelection.rowLength;
int h = tileSelection.columnLength;
int xf = -(w >> 1) + 1 - (w & 1);
int yf = -(h >> 1) + 1 - (h & 1);
for (int y = h - 1, idx = 0; y >= 0; --y)
{
for (int x = 0; x < w; ++x, ++idx)
{
tilemap.SetTileData(gridX + x + xf, gridY + y + yf, (uint)tileSelection.selectionData[idx]);
}
}
}
tilemap.UpdateMesh();
}
Finish();
}
private void SetDirtiableTiles()
{
var data = new List <Vector2>();
TilemapUtils.IterateTilemapWithAction(_shipBackgroundTilemap, (tilemap, x, y, tileData) =>
{
var tile = tilemap.GetTile(x, y);
if (tile?.paramContainer == null)
{
return;
}
if (tile.paramContainer.GetBoolParam("CanBeDirty"))
{
data.Add(new Vector2(x, y));
}
});
_dirtiableTiles = data;
}
protected override void OnTick()
{
Entities.ForEach((Entity intent, ref MoveIntentComponent movement) =>
{
var allGridPos = GetComponentDataFromEntity <GridPos>();
if (allGridPos.HasComponent(movement.target))
{
var curGridPos = allGridPos[movement.target];
curGridPos.Value += movement.direction.ToInt2();
if (TilemapUtils.IsValidPos(curGridPos.Value, EntityManager))
{
PostUpdateCommands.SetComponent(movement.target, curGridPos);
}
}
PostUpdateCommands.DestroyEntity(intent);
});
}
private RoombaStationBehaviour FindNextRoombaStation()
{
RoombaStationBehaviour choosenStation = null;
var lowestDist = float.MaxValue;
TilemapUtils.IterateTilemapWithAction(_doodadsForegroundTilemap, (tilemap, gx, gy, data) =>
{
var tile = tilemap.GetTile(gx, gy);
if (tile?.paramContainer == null)
{
return;
}
if (!tile.paramContainer.GetBoolParam("IsRoombaStation"))
{
return;
}
var roombaStation = tilemap.GetTileObject(gx, gy).GetComponent <RoombaStationBehaviour>();
if (!roombaStation.CanRoombaDockHere(this))
{
return;
}
var gridWorldPos = TilemapUtils.GetGridWorldPos(
_doodadsForegroundTilemap,
gx,
gy);
var transformPosition = transform.position.magnitude - gridWorldPos.magnitude;
if (transformPosition < lowestDist)
{
System.Console.WriteLine("gridWorldPos " + gridWorldPos);
System.Console.WriteLine("roombaStation " + roombaStation.transform);
choosenStation = roombaStation;
lowestDist = transformPosition;
}
});
return(choosenStation);
}
public override void OnEnter()
{
if (!m_tilemap)
{
var go = Fsm.GetOwnerDefaultTarget(gameObject);
if (UpdateCache(go))
{
m_tilemap = cachedComponent as STETilemap;
gridX.Value = m_tilemap.MinGridX - 1; //NOTE: OnEnter will add 1 the first time
gridY.Value = m_tilemap.MinGridY;
storePosition.Value = (ePositionType)positionType.Value == ePositionType.LocalPosition ?
(Vector2)TilemapUtils.GetGridWorldPos(m_tilemap, gridX.Value, gridY.Value)
:
new Vector2(gridX.Value, gridY.Value);
}
}
if (gridX.Value < m_tilemap.MaxGridX)
{
++gridX.Value;
}
else if (gridY.Value < m_tilemap.MaxGridY)
{
++gridY.Value;
gridX.Value = m_tilemap.MinGridX;
}
else
{
Finish();
return;
}
storePosition.Value = (ePositionType)positionType.Value == ePositionType.LocalPosition?
(Vector2)TilemapUtils.GetGridWorldPos(m_tilemap, gridX.Value, gridY.Value)
:
new Vector2(gridX.Value, gridY.Value);
Fsm.Event(iterationNextElement);
}
private PF.Point ChooseDestination()
{
List <Vector3> targets = TilemapUtils.GetTargets(World.instance.tilemapInterests);
float closestDist = float.MaxValue;
Vector3 closest = character.transform.position;
foreach (Vector3 target in targets)
{
float dist = (target - character.transform.position).magnitude;
if (dist < closestDist)
{
closestDist = dist;
closest = target;
}
}
Vector3Int pos = World.instance.GetGridPos(closest);
return(new PF.Point((int)pos.x, (int)pos.y));
}
protected override void DoPaintAction()
{
var go = Fsm.GetOwnerDefaultTarget(gameObject);
if (UpdateCache(go))
{
STETilemap tilemap = cachedComponent as STETilemap;
int gridX;
int gridY;
if ((ePositionType)positionType.Value == ePositionType.LocalPosition)
{
gridX = TilemapUtils.GetGridX(tilemap, startPaintingPosition.Value);
gridY = TilemapUtils.GetGridY(tilemap, startPaintingPosition.Value);
}
else// if ((ePositionType)positionType.Value == ePositionType.GridPosition)
{
gridX = (int)startPaintingPosition.Value.x;
gridY = (int)startPaintingPosition.Value.y;
}
TilemapDrawingUtils.FloodFill(tilemap as STETilemap, gridX, gridY, tileSelection.Get2DTileDataArray(), randomizePattern.Value);
tilemap.UpdateMesh();
}
}
private void HandleSearchDirt()
{
if (!navMeshAgent2D.hasPath && _currentCapacity > 0)
{
// Find the nearest dirt tile
_waitingTicks = 60;
var choosenPosition = Vector2.positiveInfinity;
var lowestDist = float.MaxValue;
TilemapUtils.IterateTilemapWithAction(_doodadsBackgroundTilemap, (tilemap, gx, gy, data) =>
{
if (IsDirtTile(data))
{
var gridWorldPos = TilemapUtils.GetGridWorldPos(
_doodadsBackgroundTilemap,
gx,
gy);
var transformPosition = Vector2.Distance(transform.position, gridWorldPos);
if (transformPosition < lowestDist)
{
lowestDist = transformPosition;
choosenPosition = new Vector2(gx, gy);
}
}
});
if (Math.Abs(lowestDist - float.MaxValue) > 0.01)
{
var gridWorldPos = TilemapUtils.GetGridWorldPos(
_doodadsBackgroundTilemap,
(int)choosenPosition.x,
(int)choosenPosition.y);
// add 0.25f to y so the roomba is on top of dirt tiles
navMeshAgent2D.destination = gridWorldPos + new Vector3(0, 0.25f, 0);
}
}
}
// Use to process your families.
protected override void onProcess(int familiesUpdateCount)
{
GameObject go = _selectorGO.First();
if (go != null)
{
SelectorEntity selector = go.GetComponent <SelectorEntity>();
bool isOnBuyable = false;
foreach (GameObject buyable in _buyableSelectableGO)
{
if (Input.GetMouseButtonDown(0))
{
unSelectAll(selector);
SelectableEntity selectable = buyable.GetComponent <SelectableEntity>();
selectable.isSelected = true;
GameObjectManager.setGameObjectTag(buyable, "Selected");
isOnBuyable = true;
break;
}
}
if (!isOnBuyable)
{
// If we press the right mouse button, move selected units or buy unit
if (Input.GetMouseButtonDown(1) && !selector.isSelecting && _selectedGO.Count > 0)
{
foreach (GameObject selectedObject in _selectedGO)
{
Move move = null;
if (selector.hasSelected)
{
//Case : unit selected -> move the unit
move = selectedObject.GetComponent <Move>();
}
else
{
//Case : buyable object selected -> buy
UIUnit ui = selectedObject.GetComponent <UIUnit>();
GameObject playerGO = _playerGO.First();
if (ui != null && ui.prefab != null && playerGO != null)
{
Player player = playerGO.GetComponent <Player>();
Energy playerEnergy = playerGO.GetComponent <Energy>();
Buyable buyable = ui.prefab.GetComponent <Buyable>();
//Check if we have enough "money"
if (buyable != null && buyable.energyPrice <= playerEnergy.energyPoints)
{
playerEnergy.energyPoints -= buyable.energyPrice;
//Spawn
List <Vector3> spawnArea = TilemapUtils.getAllWorldPosition(player.spawnArea);
Vector3 position = Vector3.zero;
if (spawnArea.Count > 0)
{
position = spawnArea[Random.Range(0, spawnArea.Count)];
}
GameObject myNewUnit = Object.Instantiate <GameObject>(ui.prefab, position, Quaternion.Euler(0f, 0f, Random.Range(0f, 360f)));
GameObjectManager.bind(myNewUnit);
move = myNewUnit.GetComponent <Move>();
}
//unSelectAll();
}
}
//Move the unit
if (move != null)
{
move.targetPosition = Camera.main.ScreenToWorldPoint(Input.mousePosition);
move.newTargetPosition = true;
move.forcedTarget = true;
}
}
}
// If we press the left mouse button, begin selection and remember the location of the mouse
if (Input.GetMouseButtonDown(0))
{
selector.isSelecting = true;
selector.mousePosition1 = Input.mousePosition;
unSelectAll(selector);
}
// If we let go of the left mouse button, end selection
if (Input.GetMouseButtonUp(0))
{
List <GameObject> selectedObjects = new List <GameObject>();
foreach (GameObject selectableObject in _selectableGO)
{
if (IsWithinSelectionBounds(selectableObject, selector))
{
SelectableEntity selectable = selectableObject.GetComponent <SelectableEntity>();
selectable.isSelected = false;
GameObjectManager.setGameObjectTag(selectableObject, "Selected");
selectedObjects.Add(selectableObject);
}
}
var sb = new StringBuilder();
sb.AppendLine(string.Format("Selecting [{0}] Units", selectedObjects.Count));
foreach (GameObject selectedObject in selectedObjects)
{
sb.AppendLine("-> " + selectedObject.name);
}
Debug.Log(sb.ToString());
selector.isSelecting = false;
if (selectedObjects.Count > 0)
{
selector.hasSelected = true;
}
}
// Highlight all objects within the selection box
foreach (GameObject selectableObject in _selectableGO)
{
Renderer r = selectableObject.GetComponentInChildren <Renderer>();
if (IsWithinSelectionBounds(selectableObject, selector))
{
if (r != null)
{
r.material.color = Color.green;
}
}
else
{
if (r != null)
{
r.material.color = Color.white;
}
}
}
}
if (Input.GetMouseButtonDown(0))
{
//Update infos
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit2D hit2d = Physics2D.GetRayIntersection(ray, Mathf.Infinity, LayerMask.GetMask("Ignore Raycast"));
if (hit2d.collider != null)
{
GameObject collideGO = hit2d.collider.gameObject;
if (collideGO != null)
{
Info infos = collideGO.GetComponent <Info>();
if (infos != null)
{
foreach (GameObject infoPanelGo in _infoPanelGO)
{
UIUnit ui = infoPanelGo.GetComponent <UIUnit>();
if (ui.image != null)
{
SpriteRenderer sr = collideGO.GetComponentInChildren <SpriteRenderer>();
if (sr != null)
{
ui.image.sprite = sr.sprite;
ui.image.color = sr.color;
}
else
{
ui.image.sprite = Resources.Load <Sprite>("Icons/placeholder");
ui.image.color = Color.white;
}
}
if (ui.text != null)
{
ui.text.text = infos.myName.Replace("\\n", "\n");;
}
if (ui.description != null)
{
StringBuilder sb = new StringBuilder();
Prey prey = collideGO.GetComponent <Prey>();
if (prey != null)
{
sb.AppendLine("Type : " + prey.myType);
}
Predator predator = collideGO.GetComponent <Predator>();
if (predator != null)
{
sb.AppendLine("Targets : " + string.Join(" / ", predator.myPreys) + "\n");
}
sb.AppendLine(infos.myDescription);
ui.description.text = sb.ToString().Replace("\\n", "\n");;
RectTransform rtInfoPanel = (RectTransform)ui.gameObject.transform;
RectTransform rtDescriptionText = (RectTransform)ui.description.GetComponent <ContentSizeFitter>().transform;
LayoutRebuilder.ForceRebuildLayoutImmediate(rtDescriptionText);
float posy = -10 - rtDescriptionText.rect.height / 2;
rtDescriptionText.anchoredPosition = new Vector2(rtDescriptionText.anchoredPosition.x, posy);
rtInfoPanel.sizeDelta = new Vector2(rtInfoPanel.sizeDelta.x, rtDescriptionText.rect.height);
}
if (ui.button != null)
{
ui.button.onClick.RemoveAllListeners();
ButtonSystem_wrapper b = Object.FindObjectOfType <ButtonSystem_wrapper>();
if (infos.moreInfoUrl != null && infos.moreInfoUrl != "" && b != null)
{
ui.button.onClick.AddListener(delegate { b.openURL(infos.moreInfoUrl); });
GameObjectManager.setGameObjectState(ui.button.gameObject, true);
}
else
{
GameObjectManager.setGameObjectState(ui.button.gameObject, false);
}
}
}
}
}
}
}
}
}
// Use to process your families.
protected override void onProcess(int familiesUpdateCount)
{
if (!levelInit)
{
// Pause all game system during initialisation
foreach (FSystem system in SystemHolder.pausableSystems)
{
if (system == this)
{
continue;
}
system.Pause = true;
}
foreach (GameObject go in _mapSpawnerGO)
{
Factory factory = go.GetComponent <Factory>();
Tilemap tilemap = go.GetComponent <Tilemap>();
//factory.reloadProgress += Time.deltaTime;
if (factory.reloadProgress >= factory.reloadTime)
{
foreach (var pos in tilemap.cellBounds.allPositionsWithin)
{
Vector3Int localPos = new Vector3Int(pos.x, pos.y, pos.z);
if (tilemap.HasTile(localPos))
{
Vector3 worldPos = tilemap.CellToWorld(localPos);
//Instantiate and bind to FYFY a new instance of antibodies drift (factory prefab)
GameObject mySpawn = Object.Instantiate <GameObject>(factory.prefab, worldPos, Quaternion.Euler(0f, 0f, Random.Range(0f, 360f)));
GameObjectManager.bind(mySpawn);
}
}
factory.reloadProgress = 0f;
}
}
foreach (GameObject go in _playerGO)
{
Player player = go.GetComponent <Player>();
foreach (GameObject buyableGO in player.levelBuyablePrefabs)
{
Buyable buyable = buyableGO.GetComponent <Buyable>();
//Create a new visual
GameObject myUI = Object.Instantiate <GameObject>(player.unitUIVisual, player.unitContainer.transform);
GameObjectManager.bind(myUI);
//Add height to container (each new element is 100px height here)
RectTransform rt = player.unitContainer.GetComponent <RectTransform>();
rt.sizeDelta = new Vector2(rt.sizeDelta.x, rt.sizeDelta.y + 100);
SpriteRenderer sr = buyableGO.GetComponentInChildren <SpriteRenderer>();
Info info = buyableGO.GetComponent <Info>();
//Update UI image and text
UIUnit ui = myUI.GetComponent <UIUnit>();
ui.image.sprite = sr.sprite;
ui.image.color = sr.color;
ui.text.text = info.myName.Replace("\\n", "\n");;
if (buyable != null)
{
ui.text.text += "\nCost : " + buyable.energyPrice.ToString("F0") + " energy";
}
ui.prefab = buyableGO;
}
}
levelInit = true;
// Resume systems
foreach (FSystem system in SystemHolder.pausableSystems)
{
system.Pause = false;
}
}
else
{
foreach (GameObject go in _playerGO)
{
Health playerHealth = go.GetComponent <Health>();
Energy playerEnergy = go.GetComponent <Energy>();
//Update health
if (playerHealth != null && !gamePaused)
{
bool init = false;
if (playerHealth.maxHealthPoints == 0)
{
init = true;
}
playerHealth.healthPoints = 0;
foreach (GameObject cellGO in _cellsGO)
{
Health cellHealth = cellGO.GetComponent <Health>();
if (init)
{
playerHealth.maxHealthPoints += cellHealth.maxHealthPoints;
}
playerHealth.healthPoints += cellHealth.healthPoints;
}
}
//Update energy
if (playerEnergy != null && !gamePaused)
{
foreach (GameObject energizerGO in _energizerGO)
{
Energizer energizer = energizerGO.GetComponent <Energizer>();
energizer.reloadProgress += Time.deltaTime;
if (energizer.reloadProgress >= energizer.reloadTime)
{
playerEnergy.energyPoints += energizer.recoverPoints;
energizer.reloadProgress = 0f;
}
}
//Cap at max
if (playerEnergy.energyPoints > playerEnergy.maxEnergyPoints)
{
playerEnergy.energyPoints = playerEnergy.maxEnergyPoints;
}
if (playerEnergy.energyPoints < 0)
{
playerEnergy.energyPoints = 0f;
}
}
}
//Check cell spawn position of cell is dead
foreach (GameObject go in _mapSpawnerGO)
{
Tilemap tilemap = go.GetComponent <Tilemap>();
//Remove cell tile position when cell is dead
foreach (var pos in tilemap.cellBounds.allPositionsWithin)
{
Vector3Int localPos = new Vector3Int(pos.x, pos.y, pos.z);
if (tilemap.HasTile(localPos))
{
bool cellFound = false;
Vector3 worldPos = tilemap.CellToWorld(localPos);
Collider2D[] colliders = Physics2D.OverlapCircleAll(worldPos, 1f, LayerMask.GetMask("Ignore Raycast"));
foreach (Collider2D collider in colliders)
{
GameObject collidedGO = collider.gameObject;
if (_cellsGO.contains(collidedGO.GetInstanceID()))
{
//There is a cell at position
cellFound = true;
break;
}
}
if (!cellFound)
{
tilemap.SetTile(localPos, null);
}
}
}
}
//Spawn waves
if (!gamePaused)
{
foreach (GameObject go in _levelSpawnerGO)
{
FactoryLevel factory = go.GetComponent <FactoryLevel>();
factory.reloadProgress += Time.deltaTime;
if (factory.reloadProgress >= factory.reloadTime)
{
if (factory.currentWave < factory.waves.Count)
{
Wave wave = factory.waves[factory.currentWave];
List <Vector3> spawnArea = TilemapUtils.getAllWorldPosition(factory.spawnArea);
List <Vector3> targetArea = TilemapUtils.getAllWorldPosition(factory.spawnTargetArea);
//Spawn each group of entity
foreach (Group g in wave.groups)
{
int i = 0;
while (i < g.nbSpawn)
{
Vector3 position = Vector3.zero;
if (spawnArea.Count > 0)
{
position = spawnArea[Random.Range(0, spawnArea.Count)];
}
GameObject mySpawn = Object.Instantiate <GameObject>(g.prefab, position, Quaternion.Euler(0f, 0f, Random.Range(0f, 360f)));
GameObjectManager.bind(mySpawn);
//Init first target move
Vector3 target = Vector3.zero;
if (targetArea.Count > 0)
{
target = targetArea[Random.Range(0, targetArea.Count)];
}
Move mv = mySpawn.GetComponent <Move>();
if (mv != null)
{
mv.targetPosition = target;
mv.targetObject = null;
mv.newTargetPosition = true;
mv.forcedTarget = true;
}
i++;
}
}
factory.reloadTime = wave.timeBeforeNext;
factory.reloadProgress = 0f;
factory.currentWave += 1;
}
}
//Destroy level wave factory if last wave was released (for victory condition)
if (factory.currentWave >= factory.waves.Count)
{
if (factory.waveIndicator != null)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("Wave : " + factory.currentWave + " / " + factory.waves.Count);
sb.AppendLine("Final Wave");
factory.waveIndicator.text = sb.ToString();
}
GameObjectManager.removeComponent <FactoryLevel>(go);
//GameObjectManager.unbind(go);
//Object.Destroy(go);
}
else
{
if (factory.waveIndicator != null)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("Wave : " + factory.currentWave + " / " + factory.waves.Count);
float time = factory.reloadTime - factory.reloadProgress;
sb.AppendLine("Time remain : " + time.ToString("F0"));
factory.waveIndicator.text = sb.ToString();
}
}
}
}
//Check level status
if (_attackersGO.Count == 0)
{
levelStatus = "Victory";
}
else
{
int nbHealth = 0;
int nbHealthZero = 0;
foreach (GameObject go in _playerGO)
{
Health playerHealth = go.GetComponent <Health>();
if (playerHealth != null)
{
nbHealth += 1;
if (playerHealth.healthPoints == 0)
{
nbHealthZero += 1;
}
}
}
if (nbHealthZero == nbHealth)
{
levelStatus = "Defeat";
}
}
}
GameObject playerGO = _playerGO.First();
if (playerGO != null)
{
Player player = playerGO.GetComponent <Player>();
string title, descr;
switch (levelStatus)
{
case "Victory":
title = "Victoire !";
descr = "Vous avez réussi à vous protéger de la menace pathogène.";
endGame(player, title, descr);
break;
case "Defeat":
title = "Défaite.";
descr = "La menace pathogène s'est trop répandue et est maintenant hors de contrôle.";
endGame(player, title, descr);
break;
case "Pending":
default:
break;
}
}
}
public void InitPathFindGrid()
{
bool[,] solids = TilemapUtils.GetWalkableMonster(tilemapLayout);
pathFindGrid = new PF.Grid(solids);
}
