void OnHeatAmountUpdate(HeatController heat, float prevAmt)
{
if (heat.amountCurrent >= heat.amountCapacity)
{
gameObject.SetActive(false);
}
}
private void Start()
{
shipController = shipObject.GetComponent <ShipController>();
heatController = heatObject.GetComponent <HeatController>();
powerController = powerObject.GetComponent <PowerController>();
audioManager = FindObjectOfType <AudioManager>();
}
void OnCollisionEnter2D(Collision2D collision)
{
var coll = collision.collider;
//check if already contained
for (int i = 0; i < mCollisionContacts.Count; i++)
{
if (mCollisionContacts[i].coll == coll)
{
return;
}
}
//add
HeatController heat = coll.GetComponent <HeatController>();
if (heat)
{
if (mCollisionContacts.IsFull)
{
mCollisionContacts.Expand();
}
mCollisionContacts.Add(new Contact(coll, heat));
}
}
/**
* Attempt to transfer heat to the tile from the player if frozen,
* otherwise attempt to transfer heat to the enemy.
**/
void OnTriggerEnter2D(Collider2D other)
{
HeatController sourceHeatController = other.gameObject.GetComponent <HeatController> ();
if (heatController.getIsFrozen())
{
if (sourceHeatController != null)
{
if (other.gameObject.CompareTag("Player"))
{
heatController.Unfreeze(heatController, sourceHeatController);
}
}
else
{
Debug.LogWarning("Unable to find 'HeatController' script on " + other.gameObject.name);
}
} /*else {
* if (sourceHeatController != null) {
* if (other.gameObject.CompareTag ("Enemy")) {
* heatController.Unfreeze (sourceHeatController, heatController);
* }
* } else {
* Debug.LogWarning ("Unable to find 'HeatController' script on " + other.gameObject.name);
* }
* }*/
}
public void ReceiveHeat(HeatController source, float amount)
{
if (!amountIsFixed && absorptionScale != 0f)
{
float delta = amount * absorptionScale;
mCurAmount = Mathf.Clamp(mCurAmount + delta, 0f, amountCapacity);
}
}
void OnTriggerEnter2D(Collider2D other)
{
if (other.gameObject.CompareTag("Player"))
{
HeatController player = other.gameObject.GetComponent <HeatController>();
heat.Unfreeze(heat, player);
}
}
void AttemptMove()
{
if (heatController.getIsFrozen())
{
Vector2 start = transform.position;
int xDir = 0;
int yDir = 0;
if (Mathf.Abs(target.position.x - transform.position.x) < float.Epsilon)
{
if (target.position.y > transform.position.y)
{
yDir = 1;
animator.SetTrigger("WalkUp");
}
else
{
yDir = -1;
animator.SetTrigger("WalkDown");
}
}
else
{
if (target.position.x > transform.position.x)
{
xDir = 1;
animator.SetTrigger("WalkRight");
}
else
{
xDir = -1;
animator.SetTrigger("WalkLeft");
}
}
Vector2 movement = new Vector2(xDir, yDir);
Vector2 end = start + movement;
boxCollider.enabled = false;
RaycastHit2D hit = Physics2D.Linecast(start, end, blockingLayer);
boxCollider.enabled = true;
if (hit.transform == null)
{
StartCoroutine(Move(end));
}
else if (hit.collider.CompareTag("Player"))
{
HeatController player = hit.collider.GetComponent <HeatController>();
heatController.Unfreeze(heatController, player);
Destroy(this.gameObject);
}
}
}
void Start()
{
audioSources = GetComponents <AudioSource>();
animator = GetComponent <Animator>();
rb2d = GetComponent <Rigidbody2D>();
boxCollider = GetComponent <BoxCollider2D>();
heatController = GetComponent <HeatController>();
inverseMoveTime = 1f / moveTime;
collisionVector = boxCollider.size;
}
void Start()
{
heatController = GetComponent <HeatController>();
boxCollider = GetComponent <BoxCollider2D>();
rb2d = GetComponent <Rigidbody2D>();
inverseMoveTime = 1f / moveTime;
Debug.Log(heatController.getCurrentHeat() + ", " + heatController);
InvokeRepeating("AttemptMove", moveDelay, moveDelay);
}
protected void Awake() {
_basePosition = transform.position;
_thrusterForce = new TweakableFloat("_thrusterForce", 800.0f, 10000.0f, PLAYER_THRUSTER_FORCE_DEFAULT);
_hammerObj = transform.Find("BiscuitHammer").gameObject;
_characterCenterObj = transform.Find("CharacterCenter").gameObject;
_rigidbody = GetComponent<Rigidbody2D>();
_heatController = GetComponent<HeatController>();
_injuredParticleSystem = transform.Find("PInjuredParticleSystem").gameObject.GetComponent<ParticleSystem>();
}
void Start()
{
heatController = GetComponent <HeatController>();
boxCollider = GetComponent <BoxCollider2D>();
rb2d = GetComponent <Rigidbody2D>();
animator = GetComponent <Animator>();
target = GameObject.FindGameObjectWithTag("Player").transform;
inverseMoveTime = 1f / moveTime;
InvokeRepeating("AttemptMove", moveDelay, moveDelay);
}
void OnHeatAmountUpdate(HeatController heat, float prevAmt)
{
if (!mIsDead)
{
if (heat.amountCurrent >= heat.amountCapacity)
{
if (heat.entity)
{
heat.entity.state = (int)entityDeathState;
}
mIsDead = true;
}
}
}
/**
* Attempt to transfer heat from the source HeatController to the destination HeatController
* The heat transfer will not exceed the maximum & minimum heat level of the respective HeatControllers
**/
private void transferHeat(float transferRequest, HeatController source, HeatController destination)
{
float heatTransferred;
if (source.currentHeat >= transferRequest)
{
heatTransferred = transferRequest;
}
else
{
heatTransferred = source.currentHeat;
}
source.currentHeat = Mathf.Max(minHeat, source.currentHeat - heatTransferred);
destination.currentHeat = Mathf.Min(maxHeat, destination.currentHeat + heatTransferred);
}
void Update()
{
if (heatController.getPercentHeat() <= 0.35)
{
PlayerWarningEvent();
}
// Check in 4 directions for any heat sources
if (Input.GetKeyDown(KeyCode.Space))
{
for (int i = 0; i < direction.Length; i++)
{
float moveHorizontal = direction[i][0];
float moveVertical = direction[i][1];
Vector2 collisionCheck = new Vector2((moveDistance + collisionVector.x / 2) * moveHorizontal,
(moveDistance + collisionVector.y / 2) * moveVertical);
Vector2 start = new Vector2(Mathf.Round(transform.position.x * 10) / 10, Mathf.Round(transform.position.y * 10) / 10);
Vector2 collisionEnd = start + collisionCheck;
boxCollider.enabled = false;
RaycastHit2D hit = Physics2D.Linecast(start, collisionEnd, blockingLayer);
boxCollider.enabled = true;
if (hit.transform != null)
{
if (hit.collider.gameObject.CompareTag("Source"))
{
HeatController targetHeatController = hit.collider.gameObject.GetComponent <HeatController>();
if (targetHeatController == null)
{
Debug.LogError("Unable to find 'HeatController' script on " + hit.collider.name);
}
else
{
audioSources[1].Play();
heatController.Unfreeze(heatController, targetHeatController);
}
}
}
}
}
}
public void SpawnEnemy(float health)
{
float player_x = playerController.transform.position.x;
float player_y = playerController.transform.position.y;
int spawn_x, spawn_y;
while (true)
{
spawn_x = (int)Random.Range(Mathf.Max(1, player_x - enemySpawnRange), Mathf.Min(player_x + enemySpawnRange, board_Width - 1));
spawn_y = (int)Random.Range(Mathf.Max(1, player_y - enemySpawnRange), Mathf.Min(player_y + enemySpawnRange, board_Height - 1));
if (spawnableArea[spawn_x, spawn_y])
{
break;
}
}
Vector3 spawnPosition = new Vector3(spawn_x, spawn_y, 0);
GameObject newEnemy = Instantiate(enemy, spawnPosition, Quaternion.identity);
HeatController enemyHeatController = newEnemy.GetComponent <HeatController>();
enemyHeatController.setEnemyHealth(health);
}
void OnTriggerEnter2D(Collider2D collision)
{
//check if already contained
for (int i = 0; i < mTriggerContacts.Count; i++)
{
if (mTriggerContacts[i].coll == collision)
{
return;
}
}
//add
HeatController heat = collision.GetComponent <HeatController>();
if (heat)
{
if (mTriggerContacts.IsFull)
{
mTriggerContacts.Expand();
}
mTriggerContacts.Add(new Contact(collision, heat));
}
}
protected void Awake() {
_pHeatController = GameObject.FindGameObjectsWithTag("Player")[0].GetComponent<HeatController>();
_indicatorObject = transform.Find("Indicator").gameObject;
_indicatorTextMesh = _indicatorObject.transform.Find("TextMesh").gameObject.GetComponent<tk2dTextMesh>();
_indicatorBasePosition = _indicatorObject.transform.localPosition;
}
void InitGame()
{
boardController.SetupGameArea();
playerInstance = boardController.getPlayer();
playerInstanceHeat = playerInstance.GetComponent <HeatController>();
}
void Update()
{
//Game Time Check
if (Time.time > gameEndTime && !isGameOver)
{
isGameOver = true;
StartCoroutine(GameOver(false));
}
//Update Player Heat & Time
int remainingTime = (int)(gameEndTime - Time.time);
progressInfo.text = "Remaining Tiles: " + remaining_Tiles + "/" + total_Tiles;
playerInfo.text = "Remaining Heat: " + (playerInstanceHeat.getCurrentHeat()).ToString("#") + " J";
timeInfo.text = remainingTime / 60 + ":" + (remainingTime % 60).ToString("00");
//Performance Checks
float percentTilesUnfrozen = (float)(total_Tiles - remaining_Tiles) / (float)total_Tiles;
float percentTimePassed = (Time.time - startTime) / (gameEndTime - startTime);
float percentHeat = playerInstanceHeat.getPercentHeat();
//UI Updates
float rotationAngle = 360f - (percentTimePassed * 180f);
clockTransform.eulerAngles = new Vector3(0, 0, rotationAngle);
heatBarImage.fillAmount = percentHeat;
progressBarImage.fillAmount = percentTilesUnfrozen;
//Spawn Enemy
if (Time.time > enemySpawnTime && enemyCount < enemySpawnCount)
{
if (percentTilesUnfrozen > percentTimePassed)
{
enemyHealth += 25000;
}
else
{
enemyHealth = Mathf.Max(25000, enemyHealth - 25000);
}
boardController.SpawnEnemy(enemyHealth);
enemySpawnTime += enemySpawnDelay;
closeTutorials();
dialogueController.StartDialogue("enemy" + enemyCount);
enemyCount++;
}
//Start Storm
if (Time.time > stormSpawnTime)
{
if (showStormDialogue)
{
closeTutorials();
dialogueController.StartDialogue("storm");
showStormDialogue = false;
StartCoroutine(boardController.SnowStorm());
}
// Update storm intensity based on performance
if (percentTilesUnfrozen > percentTimePassed)
{
stormFrequency = Mathf.Max(0.25f, stormFrequency - 0.25f);
}
else
{
stormFrequency += 0.25f;
}
boardController.setHazardSpawnRate(stormFrequency);
stormSpawnTime += stormSpawnDelay;
}
//Mouse Over Information
Vector2 mousePosition = new Vector2(Camera.main.ScreenToWorldPoint(Input.mousePosition).x, Camera.main.ScreenToWorldPoint(Input.mousePosition).y);
RaycastHit2D hit = Physics2D.Raycast(mousePosition, Vector2.zero, 0f);
if (hit)
{
HeatController selectedObject = hit.transform.gameObject.GetComponent <HeatController>();
if (selectedObject != null)
{
selectorTransform.position = hit.transform.position;
if (hit.collider.CompareTag("Tile"))
{
tileInfo.text = "Mass: " + selectedObject.mass + " Kg\n"
+ "Heat Capacity: " + selectedObject.heatCapacity + " J/K\n"
+ "Current Temperature: " + (selectedObject.getTemperature(selectedObject.getCurrentHeat())).ToString("0.0") + " °C\n"
+ "Unfreezing Temperature: " + (selectedObject.unfreezeTemp).ToString("0.0") + " °C";
}
else if (hit.collider.CompareTag("Source"))
{
tileInfo.text = "Source Remaining Heat: " + (selectedObject.getCurrentHeat()).ToString("#") + " J";
}
else if (hit.collider.CompareTag("Enemy"))
{
tileInfo.text = "Heat Needed to Destroy: " + ((selectedObject.getUnfreezeThreshold() - selectedObject.getCurrentHeat())).ToString("#") + " J";
}
else if (hit.collider.CompareTag("Player"))
{
tileInfo.text = "You notice your fabulous looking character sprite";
}
} /* else {
* tileInfo.text = "If you notice this notice,\nyou will notice this notice\nis not worth notice.";
* }*/
}
}
void Awake()
{
mHeatCtrl = GetComponent <HeatController>();
mHeatCtrl.amountChangedCallback += OnHeatAmountUpdate;
}
void Start()
{
heat = GetComponent <HeatController>();
end_y = transform.position.y - fallDistance;
}
void Start()
{
heatController = GetComponent <HeatController>();
}
public Contact(Collider2D aColl, HeatController aHeat)
{
coll = aColl;
heat = aHeat;
}
public void TransferHeat(HeatController source, float amount)
{
heat.ReceiveHeat(source, amount);
}
/**
* Attempt to bring the target to its unfreeze threshold heat level
* using heat taken from the source HeatController.
**/
public void Unfreeze(HeatController target, HeatController heatSource)
{
float heatRequest = target.heatThreshold_unfreeze - target.currentHeat;
transferHeat(heatRequest, heatSource, target);
}
