private void Form1_Move(object sender, EventArgs e)
{
GameState.Refresh();
GameReset.Refresh();
GameUp.Refresh();
GameDown.Refresh();
}
public void PrepareNewGame()
{
GameReset?.Invoke();
foreach (IGameCellView computerGameCell in computerGameCells)
{
computerGameCell.ClearEvents();
computerGameCell.cellClicked += (coordinates) => CellAttacked?.Invoke(coordinates);
}
}
public void ResetGame()
{
this.IsRunning = false;
GameReset?.Invoke();
UnityEngine.SceneManagement.SceneManager.LoadScene(
UnityEngine.SceneManagement.SceneManager.GetActiveScene().buildIndex
);
this.IsRunning = true;
}
public void Initalize()
{
if (playerTemp != null)
{
Destroy(playerTemp);
}
IsNotFreezed = CanMove = true;
GameReset?.Invoke(this);
booted = false;
}
private void Awake()
{
if (_instance != null && _instance != this)
{
Destroy(gameObject);
}
else
{
_instance = this;
DontDestroyOnLoad(this);
}
}
/// <summary>
/// プレイヤーが死んだときに呼ばれます。
/// </summary>
public void Initalize()
{
if (playerTemp != null)
{
Destroy(playerTemp);
}
Player.Life = Player.MaxLife;
Player.WaterPoint = PlayerData.MaxWaterPoint;
Player.FoodPoint = PlayerData.MaxFoodPoint;
IsNotFreezed = CanMove = true;
GameReset?.Invoke(this);
IsPostInitialized = false;
}
private void Awake()
{
followProjectile = GameObject.FindObjectOfType(typeof(FollowProjectile)) as FollowProjectile;
gameReset = GameObject.FindObjectOfType(typeof(GameReset)) as GameReset;
catapult = GameObject.FindObjectOfType(typeof(Catapult)) as Catapult;
catapultRigidBody = GameObject.Find("/Catapult").GetComponent <Rigidbody2D>();
spring = GetComponent <SpringJoint2D>();
CircleRadius = (GetComponent <Collider2D>() as CircleCollider2D).radius;
maxStretchSquared = MaxStretch * MaxStretch;
rb = GetComponent <Rigidbody2D>();
rb.mass = 5.0f;
rb.drag = 0.15f;
rb.angularDrag = 15.0f;
rb.gravityScale = 1.0f;
}
public static void InvokeGameReset()
{
GameReset?.Invoke();
}
public void Build()
{
firstSet = false;
// Fetches other scripts for
gameReset = FindObjectOfType <GameReset>();
adjacentBombChecker = FindObjectOfType <AdjacentBombChecker>();
gameManager = FindObjectOfType <GameManager>();
floodCheck = FindObjectOfType <FloodCheck>();
playerControllers = FindObjectOfType <PlayerControllers>();
gridSizeX = gameManager.gridSizeX;
gridSizeZ = gameManager.gridSizeZ;
numberOfBombs = gameManager.numberOfBombs;
//bombDevide = gameManager.bombDevide;
Grid = new int[gridSizeX, gridSizeZ];
//numberOfBombs = ((gridSizeX * gridSizeZ) / bombDevide);
for (int x = 0; x < gridSizeX; x++)
{
for (int z = 0; z < gridSizeZ; z++)
{
SpawnTile(x, z);
}
}
// Initialize date for use in other scripts
floodCheck.Initialize();
adjacentBombChecker.Initialize();
// Each tile knows their neighbors
floodCheck.NeighbourAssigner();
// Turns a set number of random safeTiles into bombTiles
PlaceBombs();
playerControllers.Initialize();
// Checks every safe tile for bomb neighbors then adds the number to them
adjacentBombChecker.CheckAdjacentBombs();
// Sets the starting sprites
foreach (TileSO singleTile in allTileSOs)
{
if (singleTile.numOfAdjacent == 0 && !firstSet && singleTile.type == Type.Safe)
{
singleTile.spriteHolder.gameObject.SetActive(true);
singleTile.spriteHolder.sprite = singleTile.tileSprites[0];
singleTile.spriteHolder.color = Color.green;
firstSet = true;
firstTile.Add(singleTile);
playerControllers.firstClick = false;
playerControllers.firstTile = firstTile;
}
else
{
singleTile.spriteHolder.gameObject.SetActive(true);
singleTile.spriteHolder.sprite = singleTile.tileSprites[0];
singleTile.spriteHolder.color = Color.yellow;
}
}
// Used to do 2 loops, figured just one was better
//
//foreach(TileSO singleTile in safeTileSOs)
//{
// singleTile.spriteHolder.gameObject.SetActive(true);
// singleTile.spriteHolder.sprite = singleTile.tileSprites[0];
//}
// This was for testing purposes
//foreach (TileSO singleSO in safeTileSOs)
//{
// //singleSO.adjacentTMP.text = "[" + singleSO.coordX.ToString() + ","
// // + singleSO.coordZ.ToString() + "]";
// singleSO.adjacentTMP.text = singleSO.numOfAdjacent.ToString();
// singleSO.adjacentTMP.gameObject.SetActive(true);
//}
//foreach(TileSO singleSO in bombTileSOs)
//{
// singleSO.spriteHolder.color = Color.red;
// singleSO.spriteHolder.gameObject.SetActive(true);
//}
}
void Update()
{
if (!_startReady)
{
return;
}
float dt = Time.deltaTime;
if (_finished)
{
if (Input.anyKey && Time.time - _gameTimerElapsed > LevelResumeTime)
{
if (_result != Result.Running && _result != Result.LostEarnings && _result != Result.LostExhaustion)
{
if (LevelIdx < LevelList.Count)
{
LevelIdx++;
if (LevelIdx == LevelList.Count)
{
_gameTimerElapsed = Time.time;
GameBeaten?.Invoke(LevelResumeTime);
}
else
{
CheckStartFatigue();
GameReset?.Invoke();
InitLevel(LevelList[LevelIdx]);
}
}
else
{
LevelIdx = 0;
StartFatigue = 0;
InitLevel(LevelList[LevelIdx]);
}
}
else
{
StartFatigue = 0;
GameReset?.Invoke();
InitLevel(LevelList[LevelIdx]);
}
}
return;
}
_gameTimerElapsed += dt;
bool exhausted = _result == Result.LostExhaustion;
int nextRev = 0;
if (_gameTimerElapsed >= CurrentLevel.LevelTimeSeconds || exhausted)
{
if (_revenue < CurrentLevel.MinRevenue)
{
_result = Result.LostEarnings;
nextRev = CurrentLevel.MinRevenue;
}
else if (_revenue < CurrentLevel.GoodRevenue)
{
_result = Result.WonBase;
nextRev = CurrentLevel.GoodRevenue;
}
else if (_revenue < CurrentLevel.GreatRevenue)
{
_result = Result.WonGood;
nextRev = CurrentLevel.GreatRevenue;
}
else
{
_result = Result.WonGreat;
}
if (exhausted)
{
_result = Result.LostExhaustion; // Override to avoid several ifs above.
}
_finished = true;
GameFinished?.Invoke(_result, _revenue, nextRev, LevelResumeTime);
_gameTimerElapsed = Time.time;
}
else
{
// requests check:
if (_requestIdx < CurrentLevel.NumClients)
{
_requestElapsed += dt;
if (_requestElapsed >= _requestTimes[_requestIdx])
{
RequestData reqData = GenerateRequest();
int slotIdx = ActiveClientRequestSlots.FindIndex(x => !_requestAllocations.ContainsKey(x));
if (slotIdx < 0)
{
_stalledRequests.Enqueue(reqData);
}
else
{
_requestAllocations[ActiveClientRequestSlots[slotIdx]] = reqData;
ActiveClientRequestSlots[slotIdx].InitClient(reqData);
}
_requestIdx++;
}
}
if (_dragging)
{
float fatigueDelta = dt * DragDepletionRate;
_fatigue += fatigueDelta;
bool exhaustionCheck = _fatigue >= MaxFatigue;
if (exhaustionCheck)
{
_fatigue = MaxFatigue;
_result = Result.LostExhaustion;
}
OnFatigueChanged?.Invoke(FatiguePercent);
if (exhaustionCheck)
{
return;
}
}
else if (_elapsedSinceLastDragFinished >= 0)
{
_elapsedSinceLastDragFinished += dt;
if (_elapsedSinceLastDragFinished > IdleToRestoreTime)
{
_elapsedSinceLastDragFinished = IdleToRestoreTime;
_fatigue -= dt * FatigueRestoreRate;
if (_fatigue < 0)
{
_fatigue = 0;
_elapsedSinceLastDragFinished = -1.0f;
}
OnFatigueChanged?.Invoke(FatiguePercent);
}
}
foreach (var resBuilding in ActiveResourceBuildings)
{
resBuilding.UpdateGame(dt);
}
foreach (var recBuilding in ActiveRecipeBuildings)
{
recBuilding.UpdateGame(dt);
}
foreach (var slot in ActiveClientRequestSlots)
{
slot.UpdateLogic(dt);
}
}
}
public static void ResetGame()
{
GameReset?.Invoke();
}
