public MG_ClassUnit _getUnitFromID(int unitID)
{
MG_ClassUnit retVal = MG_Globals.I.units[0];
bool hasUnit = false;
foreach (MG_ClassUnit uL in MG_Globals.I.units)
{
if (uL.id == unitID)
{
retVal = uL; hasUnit = true;
break;
}
}
if (!hasUnit)
{
foreach (MG_ClassUnit uL in MG_Globals.I.unitsTemp)
{
if (uL.id == unitID)
{
retVal = uL;
break;
}
}
}
return(retVal);
}
public void _collisionHandler_UnitToMissile(GameObject unitObj, GameObject missileObj)
{
// Check the MG_ClassUnit owner of the GameObjects
MG_ClassUnit unit = MG_Globals.I.units[0]; bool hasUnit = false;
MG_ClassMissile missile = MG_Globals.I.missiles[0]; bool hasMissile = false;
foreach (MG_ClassUnit cL in MG_Globals.I.units)
{
if (cL.sprite == unitObj)
{
unit = cL; hasUnit = true; if (debug)
{
Debug.Log("Unit found...");
}
break;
}
}
foreach (MG_ClassMissile cL in MG_Globals.I.missiles)
{
if (cL.sprite == missileObj)
{
missile = cL; hasMissile = true; if (debug)
{
Debug.Log("Missile found...");
}
break;
}
}
// If one of the class does not exist, cancel the collision
if (!hasUnit || !hasMissile)
{
if (!hasUnit)
{
if (debug)
{
Debug.Log("Unit not found, returning...");
}
}
if (!hasMissile)
{
if (debug)
{
Debug.Log("Missile not found, returning...");
}
}
return;
}
// Mark this collision as already handled
string[] hC = new string[] { unitObj.name, missileObj.name };
handledCollisions.Add(hC);
if (debug)
{
Debug.Log("Collision between unit and missile success!" + Time.frameCount.ToString());
}
_collisionEvent_UnitToMissile(unit, missile);
}
/// <summary>
/// Returns true if damage can be dealt
/// </summary>
public bool _damageUnit_Conditions(MG_ClassUnit damager, MG_ClassUnit damaged)
{
if (damaged.isDead)
{
return(false);
}
return(true);
}
public void _useCard(string cardName, MG_ClassUnit caster)
{
switch (cardName)
{
case "test":
MG_ControlMissile.I._createMissile("testMissile", caster.posX, caster.posY, caster.owner, _getAngleFromFacing(caster.facing));
break;
}
}
/// <summary>
/// Returns true if collision can occur.
/// </summary>
public bool _collisionCondition_UnitToMissile_Enemies(MG_ClassUnit unit, MG_ClassMissile missile)
{
bool retVal = true;
// Confirm the existence of missile's owner
if (!MG_GetUnit.I._doesUnitExist(missile.ownerID))
{
return(false);
}
return(retVal);
}
public void _createUnit(string newUnitType, float newPosX, float newPosY, int newOwner)
{
MG_Globals.I.unitsTemp.Add(new MG_ClassUnit(MG_DB_Unit.I._getSprite(newUnitType), newUnitType, unitCnt, newPosX, newPosY, newOwner));
unitCnt++;
// SPECIALS
/*Get created unit*/ MG_ClassUnit lastCreatedUnit = MG_GetUnit.I._getLastCreatedUnit();
/*Assigning entrance ID*/ if (newUnitType == "entrance")
{
_assignEntranceID(lastCreatedUnit);
}
}
public MG_ClassUnit _getUnitFromPoint(int posX, int posY)
{
MG_ClassUnit retUnit = MG_Globals.I.units [0];
foreach (MG_ClassUnit unit in MG_Globals.I.units)
{
if (unit.posX == posX && unit.posY == posY)
{
retUnit = unit;
break;
}
}
return(retUnit);
}
public void _collisionEvent_UnitToMissile(MG_ClassUnit unit, MG_ClassMissile missile)
{
switch (missile.type)
{
case "test":
bool isHit = false;
if (MG_ControlPlayer.I._getIsEnemy(missile.playerOwner, unit.owner))
{
isHit = _collisionCondition_UnitToMissile_Enemies(unit, missile);
}
if (isHit)
{
MG_ClassUnit missileOwner = MG_GetUnit.I._getUnitFromID(missile.ownerID);
MG_CalcDamage.I._damageUnit(missileOwner, unit, 1);
MG_ControlMissile.I._addToDestroyList(missile);
}
break;
}
}
public void _damageUnit(MG_ClassUnit damager, MG_ClassUnit damaged, int damageAmt)
{
if (!_damageUnit_Conditions(damager, damaged))
{
return;
}
damaged.HP -= damageAmt;
// Kill
bool kill = true;
if (damaged.HP <= 0)
{
if (kill)
{
damaged._kill();
}
}
}
public void _updateSpritePosition()
{
if (!hasSprite)
{
return;
}
MG_ClassUnit uOwner = MG_GetUnit.I._getUnitFromID(unitOwnerID);
if (uOwner == null)
{
return;
}
if (uOwner.sprite == null)
{
return;
}
sprite.transform.position = new Vector3(uOwner.sprite.transform.position.x + spr_offsetX,
uOwner.sprite.transform.position.y + spr_offsetY,
uOwner.sprite.transform.position.z + spr_offsetY - 2);
}
public void _useWeapon(MG_ClassUnit user, string weaponType)
{
switch (weaponType)
{
#region "Hero Weapons"
case "testWeapon":
string ammoType = "inHandgun";
// Ammo check
if (!_getPlayerHasEnoughAmmo(1, ammoType))
{
_reloadWeapon(ammoType);
return;
}
MG_ControlMissile.I._createMissile("test", MG_ControlHero.I.hero.posX, MG_ControlHero.I.hero.posY, MG_ControlHero.I.hero.id, MG_ControlHero.I.hero.facingAngle);
_reduceAmmo(1, ammoType); // Ammo reduction
break;
#endregion
}
}
public void _start()
{
// Get Profile and entrance to be used
int prof = ZPlayerPrefs.GetInt("Profile"),
entranceUsed = PlayerPrefs.GetInt("EntranceUsed");
MG_ClassUnit entrance = MG_Globals.I.unitsTemp [0];
foreach (MG_ClassUnit uL in MG_Globals.I.unitsTemp)
{
if (uL.type == "entrance" && uL.entranceId == entranceUsed)
{
entrance = uL;
break;
}
}
int posX = (int)entrance.posX, posY = (int)entrance.posY;
/////////////////////// PLAYER SPAWN /////////////////////////////////
MG_ControlUnit.I._createUnit("testYou", posX, posY, 1);
hero = MG_GetUnit.I._getLastCreatedUnit();
hero.facing = PlayerPrefs.GetString("PlayerFacing");
MG_ControlCamera.I._reposition(hero.sprite.transform.position.x, hero.sprite.transform.position.y);
/////////////////////// PLAYER SPAWN /////////////////////////////////
// Hero stats
hero.moveType = "land";
/////// Misc ////////
// Set the hero's gameobject name to MainHero
hero.sprite.name = "MainHero";
// Reload weapon if ammo is 0
if (MG_HeroWeapons.I.selectedNum == 0 || MG_HeroWeapons.I.selectedNum == 1)
{
if (!MG_ControlWeapon.I._getPlayerHasEnoughAmmo(1, MG_HeroWeapons.I.selectedWeapon))
{
MG_ControlWeapon.I._reloadWeapon(MG_HeroWeapons.I.selectedWeapon);
}
}
}
public void _collisionHandler_UnitToUnit(GameObject hitterObj, GameObject hittedObj)
{
// Check the MG_ClassUnit owner of the GameObjects
MG_ClassUnit hitter = MG_Globals.I.units[0]; bool hasHitter = false;
MG_ClassUnit hitted = MG_Globals.I.units[0]; bool hasHitted = false;
foreach (MG_ClassUnit cL in MG_Globals.I.units)
{
if (cL.sprite == hittedObj)
{
hitted = cL; hasHitted = true;
}
else if (cL.sprite == hitterObj)
{
hitter = cL; hasHitter = true;
}
if (hasHitter && hasHitted)
{
break;
}
}
// If one of the class does not exist, cancel the collision
if (!hasHitter || !hasHitted)
{
return;
}
// Mark this collision as already handled
string[] hC = new string[] { hitterObj.name, hittedObj.name };
handledCollisions.Add(hC);
if (debug)
{
Debug.Log("Collision between units success!");
}
}
void Update()
{
if (!editorMode)
{
return;
}
try{
Vector3 gamePoint = MG_ControlCamera.I._getGamePoint(new Vector3(Input.mousePosition.x, Input.mousePosition.y));
int actPosX = (int)gamePoint.x, actPosY = (int)gamePoint.y;
// Doodad and tail rotation
float zRotation = 0;
if (rotateDood)
{
float.TryParse(doodRotation, out zRotation);
}
#region "Mouse Click"
if (Input.GetMouseButton(0))
{
#region "Terrain Brush"
if (brushMode == "Terrain")
{
MG_ClassTerrain targetTile = MG_GetTerrain.I._getTerrain(actPosX, actPosY);
targetTile._changeTerrain(MG_DB_Terrain.I._getSprite(terType), terType);
targetTile.sprite.name = targetTile.sprite.name.Replace("(Clone)", "");
targetTile.sprite.transform.SetParent(GameObject.Find("_MG_TERRAIN").transform);
}
#endregion
#region "Unit Brush"
else if (brushMode == "Unit")
{
// Remove existing unit if present
bool hasUnit = MG_GetUnit.I._pointHasUnit(actPosX, actPosY);
if (hasUnit)
{
MG_ControlUnit.I._addToDestroyList(MG_GetUnit.I._getUnitFromPoint(actPosX, actPosY));
}
// Create Unit
int uOwner = 0;
int.TryParse(unitOwner, out uOwner);
MG_ControlUnit.I._createUnit(unitType, actPosX, actPosY, uOwner);
// Specials
MG_ClassUnit createdUnit = MG_GetUnit.I._getLastCreatedUnit();
switch (createdUnit.type)
{
case "pathBlocker":
// Switch pathBlocker sprite
createdUnit._changeSprite("pathBlocker_Editor");
createdUnit.sprite.transform.SetParent(GameObject.Find("_MG_UNITS").transform);
break;
}
// Finalize creation
createdUnit.sprite.name = createdUnit.sprite.name.Replace("(Clone)", "");
createdUnit.sprite.transform.SetParent(GameObject.Find("_MG_UNITS").transform);
}
#endregion
#region "Doodad Brush (Per Tile)"
else if (brushMode == "Doodad")
{
// Remove existing doodad if present
bool hasDood = MG_GetDoodad.I._pointHasDood(actPosX, actPosY);
if (hasDood)
{
MG_ControlDoodad.I._addToDestroyList(MG_GetDoodad.I._getDoodFromPoint(actPosX, actPosY));
}
// Create Doodad
if (rotateDood)
{
MG_ControlDoodad.I._createDoodad(doodType, actPosX, actPosY, zRotation, true);
}
else
{
MG_ControlDoodad.I._createDoodad(doodType, actPosX, actPosY, true);
}
// Specials
MG_ClassDoodad createdDood = MG_GetDoodad.I._getLastCreatedDood();
///*Create tail*/ if(createTail) MG_ControlDoodad.I._createTails(createdDood, isTailTree, zRotation);
/// Create tail is disabled since there is no need for this in main game
// Finalize creation
createdDood.sprite.name = createdDood.sprite.name.Replace("(Clone)", "");
createdDood.sprite.transform.SetParent(GameObject.Find("_MG_DOODADS").transform);
}
#endregion
#region "Corner Brush"
else if (brushMode == "Corner")
{
// Remove existing corner if present
bool hasDood = MG_GetDoodad.I._pointHasDood(actPosX, actPosY, "Corner");
if (hasDood)
{
MG_ControlDoodad.I._addToDestroyList(MG_GetDoodad.I._getDoodFromPoint(actPosX, actPosY, "Corner"));
}
// Create Doodad
string cornerType_orig = cornerType;
if (cornerBase == "Line")
{
}
else
{
if (cornerBase == "Outward")
{
cornerType += "Corner3";
}
else if (cornerBase == "Inward")
{
cornerType += "Corner2";
}
float zRot = 0;
float.TryParse(cornerLine, out zRot);
MG_ControlDoodad.I._createDoodad(cornerType, actPosX, actPosY, zRot);
}
// Specials
MG_ClassDoodad createdDood = MG_GetDoodad.I._getLastCreatedDood();
/*Return original cornerBase*/ cornerType = cornerType_orig;
// Finalize creation
createdDood.sprite.name = createdDood.sprite.name.Replace("(Clone)", "");
createdDood.sprite.transform.SetParent(GameObject.Find("_MG_DOODADS").transform);
}
#endregion
#region "Unit Eraser"
else if (brushMode == "Unit Eraser")
{
// Remove existing unit if present
bool hasUnit = MG_GetUnit.I._pointHasUnit(actPosX, actPosY);
if (hasUnit)
{
MG_ControlUnit.I._addToDestroyList(MG_GetUnit.I._getUnitFromPoint(actPosX, actPosY));
Debug.Log("Unit erased!");
}
}
#endregion
#region "Doodad Eraser"
else if (brushMode == "Doodad Eraser")
{
// Remove existing unit if present
bool hasDood = MG_GetDoodad.I._pointHasDood(actPosX, actPosY);
if (hasDood)
{
MG_ControlDoodad.I._addToDestroyList(MG_GetDoodad.I._getDoodFromPoint(actPosX, actPosY));
Debug.Log("Doodad erased!");
// Remove tails
for (float x = -0.5f; x < 1; x += 0.25f)
{
for (float y = -0.5f; y < 1; y += 0.25f)
{
hasDood = MG_GetDoodad.I._pointHasDood(actPosX + x, actPosY + y);
if (hasDood)
{
MG_ControlDoodad.I._addToDestroyList(MG_GetDoodad.I._getDoodFromPoint(actPosX + x, actPosY + y));
}
}
}
}
}
#endregion
}
#endregion
#region "Keyboard Keys"
if (Input.GetKey(KeyCode.E) && !telePressed)
{
MG_ControlHero.I._instantMove(actPosX, actPosY);
Debug.Log("Teleported to " + actPosX + ", " + actPosY + ", " + telePressed);
telePressed = true;
}
else if (!Input.GetKey(KeyCode.E) && telePressed)
{
telePressed = false;
}
#endregion
#region "Bursh control"
brush.transform.position = new Vector3(actPosX, actPosY, 0);
#endregion
}catch (Exception ex) {
Debug.Log("Turning off editor mode. Reason: " + ex.Message);
_turnOffEditor(true);
}
}
public void _createHero(float newPosX, float newPosY, float newAngle)
{
MG_ControlUnit.I._createUnit(heroType, newPosX, newPosY, newAngle, playerNum);
hero = MG_GetUnit.I._getLastCreatedUnit();
}
public void _addToDestroyList(MG_ClassUnit targetUnit)
{
toDestroy.Add(targetUnit.id);
}
private void _assignEntranceID(MG_ClassUnit targetEnt)
{
entrances++;
targetEnt.entranceId = entrances;
}
// After being passed through to determine the collision's properties,
// colliding objects will now go through these event calculators
// to figure out the outcome of the collision.
#region "Collision Event Calculator"
public void _collisionEvent_UnitToUnit(MG_ClassUnit hitter, MG_ClassUnit hitted)
{
}
// Includes
// - _polarizeHeroPosition - Switch hero position when switching maps
// - (10, 0) becomes (-10, 0)
#region "Misc"
/// <summary>
/// Switch hero position when switching maps, i.e. (10, 0) becomes (-10, 0).
/// Only use this when the player reaches the edge of an overworld map.
/// </summary>
private void _polarizeHeroPosition(string facing)
{
int profile = ZPlayerPrefs.GetInt("Profile");
MG_ClassUnit hero = MG_ControlHero.I.hero;
}
