private void OnCollisionEnter(Collision collision)
{
//check if player
PlayerMovement Ply = collision.gameObject.GetComponent <PlayerMovement>();
if (!Ply)
{
return;
}
//activate visual effect, and detatch
if (DestroyFX)
{
DestroyFX.SetActive(true);
DestroyFX.transform.parent = null;
}
//destroy self
DestroyObject Dsty = GetComponent <DestroyObject>();
if (!Dsty)
{
Destroy(this.gameObject);
}
else
{
Dsty.enabled = true;
Destroy(this);
}
}
public void Death(Logic killer)
{
//DeathProcces
if (killer != null)
{
Helper.lstKiller = killer;
}
Helper.lstDeathEnemy = (Logic)Clone();
if (transform.GetComponent <UnitLogic>())
{
DestroyObject.Destroy(transform.gameObject);
if (BattleControll.battleControll.unitInfo == (Unit)transform.GetComponent <UnitLogic>())
{
BattleControll.battleControll.UnitInfoHide();
}
if (BattleControll.loadedLevel.enemySpawn == LevelObject.EnemySpawn.afterDead)
{
BattleControll.battleControll.StartCoroutine(BattleLogic.battleLogic.coroutines.actionAfterSomeSec(0.5f, BattleControll.battleControll.SpawnEnemies));
}
}
else
{
//heroDeath
}
if (unitEvents.AfterDead != null)
{
BattleLogic.battleLogic.addAction(() =>
{
unitEvents.AfterDead.Invoke();
}, null, 0);
}
}
/// <summary>
/// Initialises a new instance of the <see cref="SlimObjectPool{T}" /> class.
/// </summary>
/// <param name="create">
/// The delegate method to use to create new pooled object instances.
/// </param>
/// <param name="reset">
/// The delegate method to use to reset used pooled object instances.
/// </param>
/// <param name="destroy">
/// The delegate method to use to destroy pooled object instances that cannot be reused.
/// </param>
internal SlimObjectPool(CreateObject create, ResetObject reset, DestroyObject destroy)
{
createObject = create;
resetObject = reset;
destroyObject = destroy;
objectBuffer = new ConcurrentBag <T>();
}
private static void HandleDestroyObject(DestroyObject destroy)
{
if (destroy == null)
{
throw new WrongPacketTypeException();
}
World.Instance.DestroyObject(destroy.ObjectID);
}
void Start()
{
rb = GetComponent <Rigidbody2D>();
attackScript = GetComponentInChildren <Attack>();
cameraScript = Camera.main.GetComponent <CameraScript>();
destroyObjectScript = GetComponentInChildren <DestroyObject>();
healthbar = GameObject.FindGameObjectWithTag("Healthbar").GetComponent <HealthUI>();
playerHandScript = GetComponentInChildren <PlayerHand>();
}
void Start()
{
tileManager = GameObject.FindGameObjectWithTag("TileManager").GetComponent <TileManager>();
destroyObject = GetComponent <DestroyObject>();
player = GameObject.Find("Player").GetComponent <PlayerController>();
attackSpeed = 0.8f;
time = 0.0f;
character = player.GetComponentInChildren <Character4D>();
}
public static void OnPacket(Client client, object pack)
{
ReqDestroyObject req = pack as ReqDestroyObject;
Room room = RoomPool.me.GetByRoomId(client.roomid);
DestroyObject destroyObject = new DestroyObject();
destroyObject.RoomId = req.RoomId;
destroyObject.ObjectId = req.ObjectId;
room.clientA.Send(destroyObject);
room.clientB.Send(destroyObject);
}
void Awake()
{
destroyOther = true;
sr = GetComponent <SpriteRenderer>();
c2d = GetComponent <BoxCollider2D>();
rb2d = GetComponent <Rigidbody2D>();
if (randomSprite)
{
sr.sprite = spritePool[Random.Range(0, spritePool.Length)];
}
otherObject = GetComponent <DestroyObject>();
}
public void DestroyObject(int objectID)
{
GameObject obj = GetObject(objectID);
if (obj == null)
{
return;
}
_worldObjects.Remove(objectID);
Destroy(obj);
DestroyObject destroy = new DestroyObject
{
ObjectID = objectID,
};
Socket.Instance.SendPacket(destroy, Packets.DestroyObject);
}
void Update()
{
if (mBuildMenu && !mUiOpened)
{
OpenBuildMenu?.Invoke();
}
if (mBuildingMenu && !mUiOpened)
{
RaycastHit hitInfo;
if (Physics.Raycast(PlayerTransformation.position, PlayerTransformation.forward,
out hitInfo, float.MaxValue, LayerMask.GetMask("ProductionBuilding")))
{
var building = hitInfo.collider.GetComponentInParent <ProductionBuilding>();
if (building)
{
OpenBuildingInfoMenu?.Invoke(building);
}
}
}
if (mDestroyObjects && !mUiOpened)
{
DestroyObject?.Invoke();
}
if (!mUiOpened)
{
RaycastHit hitInfo;
if (Physics.Raycast(Camera.main.transform.position, Camera.main.transform.forward,
out hitInfo, float.MaxValue, LayerMask.GetMask("ProductionBuilding")))
{
var building = hitInfo.collider.GetComponentInParent <ProductionBuilding>();
if (building)
{
BuildingPointed?.Invoke(building);
}
}
else
{
BuildingNotPointed?.Invoke();
}
}
if (mCloseMenu && mUiOpened)
{
CloseMenu?.Invoke();
}
}
void Awake()
{
destroyOther = true;
sr = GetComponent <SpriteRenderer>();
c2d = GetComponent <BoxCollider2D>();
rb2d = GetComponent <Rigidbody2D>();
gc = FindObjectOfType <GameController>();
projectileLayer = LayerMask.NameToLayer("Ground");
noColLayer = LayerMask.NameToLayer("NoColLayer");
rockFilter.useLayerMask = true;
rockFilter.layerMask = ~LayerMask.GetMask("PlayerLayer", "NoColLayer");
if (randomSprite)
{
sr.sprite = spritePool[Random.Range(0, spritePool.Length)];
}
attachedObject = GetComponent <DestroyObject>();
}
public void Run()
{
plane.Print();
while (!settings.GameOver)
{
// adding chance to spawn @ 25%
int chanceToSpawn = rnd.Next(0, 100);
status.ClearStatus();
status.PrintStatus();
if (chanceToSpawn <= 80)
{
int objXPosition = 1;
int objYPosition = rnd.Next(0, settings.Width - 2);
destroyObject = new DestroyObject(new Point(objXPosition, objYPosition));
gameObjectsList.AddLast(destroyObject);
}
if (chanceToSpawn <= 15)
{
int objXPosition = 1;
int objYPosition = rnd.Next(0, settings.Width);
collectObject = new CollectedObject(new Point(objXPosition, objYPosition));
gameObjectsList.AddLast(collectObject);
}
while (gameObjectsList.Count > 0)
{
current = gameObjectsList.First;
gameObjectsList.RemoveFirst();
if (!current.Value.HaveCollision)
{
PrintGameObject.PrintObject(current.Value);
newGameObjectsList.AddLast(current.Value);
}
}
gameObjectsList = newGameObjectsList;
newGameObjectsList = new LinkedList<GameObject>();
while (Console.KeyAvailable)
{
ConsoleKeyInfo keyPressed = Console.ReadKey();
plane.Clear();
if (keyPressed.Key == ConsoleKey.UpArrow)
{
plane.Position.X--;
if (plane.Position.X < 1)
{
plane.Position.X = 1;
}
}
if (keyPressed.Key == ConsoleKey.DownArrow)
{
plane.Position.X++;
if (plane.Position.X > settings.Height - plane.PlaneHeight)
{
plane.Position.X = settings.Height - plane.PlaneHeight;
}
}
if (keyPressed.Key == ConsoleKey.LeftArrow)
{
plane.Position.Y--;
if (plane.Position.Y < 0)
{
plane.Position.Y = 0;
}
}
if (keyPressed.Key == ConsoleKey.RightArrow)
{
plane.Position.Y++;
if (plane.Position.Y > settings.Width - plane.PlaneWidth)
{
plane.Position.Y = settings.Width - plane.PlaneWidth;
}
}
if (keyPressed.Key == ConsoleKey.Spacebar)
{
projectile = new Projectile(new Point(plane.Position.X - 1, plane.Position.Y + plane.PlaneWidth / 2));
projectilesFired.AddLast(projectile);
PrintGameObject.PrintObject(projectile);
}
if (keyPressed.Key == ConsoleKey.P)
{
PauseScreenPage pause = new PauseScreenPage();
pause.PauseMain();
settings.Pause = !settings.Pause;
Console.ReadKey();
Console.Clear();
}
plane.Print();
}
while (projectilesFired.Count > 0)
{
Projectile current = (projectilesFired.First).Value;
projectilesFired.RemoveFirst();
PrintGameObject.ClearObject(current);
current.Move();
if (!current.HaveCollision)
{
PrintGameObject.PrintObject(current);
projectilesInAir.AddLast(current);
}
}
projectilesFired = projectilesInAir;
projectilesInAir = new LinkedList<Projectile>();
//foreach (var projectile in projectilesFired)
//{
// if (projectile.UpLeftCorner.X >= 0)
// {
// PrintGameObject.ClearObject(projectile);
// projectile.Move();
// if (projectile.UpLeftCorner.X > 0)
// {
// PrintGameObject.PrintObject(projectile);
// }
// }
//}
while (gameObjectsList.Count > 0)
{
current = gameObjectsList.First;
gameObjectsList.RemoveFirst();
PrintGameObject.ClearObject(current.Value);
current.Value.Move();
if (!current.Value.HaveCollision)
{
PrintGameObject.PrintObject(current.Value);
newGameObjectsList.AddLast(current);
}
}
gameObjectsList = newGameObjectsList;
newGameObjectsList = new LinkedList<GameObject>();
status.Score += 1;
Thread.Sleep(sleepTime);
}
Settings.PrintGameOver();
}
public void TakeImpact(Impact impact, Logic unitLogic, string property = "Hp")
{
if (transform == null || Hp <= 0)
{
return;
}
Helper.lstDamagedEnemy = this;
float damage = 0;
bool[] Avoided = new bool[Resources.Load <Transform>(GameManager.DamageIndicator[unitLogic.attackType != null ? unitLogic.attackType.damageIndicator : 0]).GetComponentsInChildren <Text>().Length];
if (property != null && property.Length > 0)
{
if (property == "Hp")
{
for (int i = 0; i < Avoided.Length; i++)
{
if (impact.value > 0)
{
if (Randomize.Random(MissChanse(unitLogic)))
{
Avoided[i] = true;
}
}
if (!Avoided[i])
{
if (!impact.isProcent)
{
damage = impact.value;
}
else
{
damage = (float)Math.Round(Hp / 100 * impact.value, 1);
}
damage /= Avoided.Length;
damage -= unitProperty.DamageResist;
if (unitProperty.Armor != 0)
{
BattleConstants.CalculateArmor(ref damage, unitProperty.Armor);
}
UnitProperty enemyProperty = unitLogic.unitProperty;
if (Randomize.Random(enemyProperty.AttackCritChanse))
{
damage += damage / 100 * enemyProperty.CriticalDamage;
}
if (Randomize.Random(unitProperty.BlockChanse))
{
if (!Randomize.Random(unitProperty.AbsoluteBlockChanse))
{
damage -= unitProperty.BlockDamage;
}
else
{
damage = 0;
}
}
if (Randomize.Random(unitProperty.ParryChanse))
{
damage /= 2;
if (!unitLogic.unitObject.IsRangeUnit)
{
unitLogic.TakeImpact(new Impact {
value = damage / 1.5f
}, this, "Hp");
}
}
if (damage < 0)
{
damage = 0;
}
Hp -= damage;
Helper.lstOffender.Stats.AddDamage(damage);
if (Hp > this.unitObject.unitProperty.Hp)
{
Hp = this.unitObject.unitProperty.Hp;
}
}
}
}
else
{
ChangeValue(impact, property);
Debug.Log(unitProperty.Armor);
}
}
UnitObject unitObject = unitLogic.unitObject;
UnitLogic MyLogic = transform.GetComponent <UnitLogic>();
if (property == "Hp")
{
DestroyObject des = unitImage.GetComponentInChildren <DestroyObject>();
Transform indicator = (des != null) ? des.transform : null;
Transform loadedIndicator = Resources.Load <Transform>(damage >= 0 ? (GameManager.DamageIndicator[unitLogic.attackType != null ? unitLogic.attackType.damageIndicator : 0]) : GameManager.HealIndicator);
if (des != null && des.name.StartsWith(loadedIndicator.name) && des.lifeTime > 0.2f)
{
indicator.GetComponent <Animation>().Stop();
indicator.GetComponent <Animation>().Play(des.stop.name);
}
else
{
indicator = null;
des = null;
}
for (int avd = 0; avd < Avoided.Length; avd++)
{
if (damage != 0 || damage == 0 && Avoided[avd])
{
if (!Avoided[avd])
{
if (!transform.GetComponent <HeroLogic>())
{
BattleLog.battleLog.addLog("<color=red>" + MyLogic.UnitName + "</color>"
+ " теряет " +
"<color=red>" + damage.ToString() + "</color>" +
" от " + "<color=green>" + (unitObject.UnitName) + "</color>");
}
else
{
BattleLog.battleLog.addLog("<color=green>" + this.unitObject.UnitName + "</color>" + " теряет " +
"<color=red>" + damage.ToString() + "</color>");
}
if (Hp <= 0)
{
BattleLog.battleLog.addLog("<color=red>" + ((MyLogic.UnitName != null) ? MyLogic.UnitName : this.unitObject.UnitName) + "</color>"
+ " умерает от " + "<color=green>" + (unitObject.UnitName) + "</color>");
Death(this);
}
}
if (indicator == null)
{
indicator = UnityEngine.Object.Instantiate <Transform>(loadedIndicator, unitImage);
}
if ((unitImage.localScale.x < 0))
{
indicator.GetChild(0).localScale = new Vector3(-1, 1, 1);
}
indicator.transform.localPosition = Vector3.zero;
Text[] txt = indicator.GetComponentsInChildren <Text>();
float val = (txt[avd].text == "Miss") ? 0 : float.Parse(txt[avd].text);
if (Avoided.Length == 1)
{
if (Avoided[0])
{
UnityEngine.Object.Instantiate <Transform>(Resources.Load <Transform>(GameManager.MissIndicator), indicator.transform);
}
txt[0].text = (val + Math.Abs(damage)).ToString();
}
else
{
if (Avoided[avd])
{
txt[avd].text = "Miss";
}
else
{
if (damage < 2)
{
txt[avd].text = Math.Round(val + damage, 1).ToString();
}
else
{
txt[avd].text = (Math.Round((avd != txt.Length - 1) ? val + Mathf.Floor(damage) : val + (damage * Avoided.Length - Mathf.Floor(damage) * (Avoided.Length - 1)), 1).ToString());
}
}
}
}
}
}
if (Hp <= this.unitObject.unitProperty.Hp / 3)
{
EnemyControll.enemyControll.NeedRefreshPos = true;
}
if (unitEvents.OnGetDamage != null)
{
unitEvents.OnGetDamage.Invoke();
}
}
public ObjectPool(int capacity, CreateObject <T> createFun, DestroyObject <T> destroyFun)
{
mCapacity = capacity;
mCreateFun = createFun;
mDestroyFun = destroyFun;
}
public void TakeImpact(Impact impact, Spell spell, Effect[] effects = null, string property = "Hp", bool zeroDuration = false, bool InstantAction = false)
{
if (transform == null)
{
return;
}
Helper.lstDamagedEnemy = this;
float damage = 0;
if (property != null && property.Length > 0)
{
if (property == "Hp")
{
if (!impact.isProcent)
{
damage = impact.value;
}
else
{
damage = (float)Math.Round(Hp / 100 * impact.value, 1);
}
if (unitProperty.MagicResist != 0)
{
BattleConstants.CalculateArmor(ref damage, unitProperty.MagicResist);
}
if (spell.unitEvents.MyUnit != null)
{
UnitProperty enemyProperty = spell.unitEvents.MyUnit.unitlogic.unitProperty;
if (Randomize.Random(enemyProperty.MagicCritChanse) && spell.splashType <= (Spell.SplashType) 9)
{
damage += damage / 100 * enemyProperty.CriticalDamage;
}
if (Randomize.Random(unitProperty.ParryChanse))
{
damage /= 2;
}
}
Hp -= damage;
if (Hp > unitObject.unitProperty.Hp)
{
Hp = unitObject.unitProperty.Hp;
}
}
else
{
ChangeValue(impact, property);
Debug.Log(unitProperty.Armor);
}
}
UnitLogic MyLogic = transform.GetComponent <UnitLogic>();
if (property == "Hp")
{
DestroyObject des = unitImage.GetComponentInChildren <DestroyObject>();
Transform indicator = (des != null) ? des.transform : null;
Transform loadedIndicator = Resources.Load <Transform>(damage >= 0 ? (GameManager.DamageIndicator[0]) : GameManager.HealIndicator);
if (des != null && des.name.StartsWith(loadedIndicator.name) && des.lifeTime > 0.2f)
{
indicator.GetComponent <Animation>().Stop();
indicator.GetComponent <Animation>().Play(des.stop.name);
}
else
{
indicator = null;
des = null;
}
if (damage != 0)
{
if (!transform.GetComponent <HeroLogic>())
{
BattleLog.battleLog.addLog("<color=red>" + MyLogic.UnitName + "</color>"
+ " теряет " +
"<color=red>" + damage.ToString() + "</color>" +
" от " + "<color=green>" + (spell.SpellName) + "</color>");
}
else
{
BattleLog.battleLog.addLog("<color=green>" + unitObject.UnitName + "</color>" + " теряет " +
"<color=red>" + damage.ToString() + "</color>");
}
if (Hp <= 0)
{
BattleLog.battleLog.addLog("<color=red>" + ((MyLogic.UnitName != null) ? MyLogic.UnitName : unitObject.UnitName) + "</color>"
+ " умерает от " + "<color=green>" + (spell.SpellName) + "</color>");
Death(this);
}
if (indicator == null)
{
indicator = UnityEngine.Object.Instantiate <Transform>(loadedIndicator, unitImage);
}
if ((unitImage.localScale.x < 0))
{
indicator.GetChild(0).localScale = new Vector3(-1, 1, 1);
}
indicator.transform.localPosition = Vector3.zero;
Text txt = indicator.GetComponentInChildren <Text>();
float val = (txt.text == "Miss") ? 0 : float.Parse(txt.text);
txt.text = (val + Math.Abs(damage)).ToString();
}
}
if (Hp <= unitObject.unitProperty.Hp / 3)
{
EnemyControll.enemyControll.NeedRefreshPos = true;
}
if (spell != null && effects != null)
{
if (spell.spellClass != classType.none)
{
SpecClassSpellPassive.spec.UseSpell(spell, myUnit, spell.unitEvents.MyUnit);
}
}
if (unitEvents.OnGetDamage != null)
{
unitEvents.OnGetDamage.Invoke();
}
bool PutEvents = true;
if (effects != null)
{
foreach (Effect effect in effects)
{
if (effect == null)
{
continue;
}
//effect.effectStacking == EffectStacking.none
bool stop = false;
Effect eff = (Effect)effect.Clone();
eff.spell = spell;
eff.EffectFunction();
for (int i = 0; i < unitEffects.Count; i++)
{
if (unitEffects[i].Name == eff.Name)
{
PutEvents = false;
switch (effect.effectStacking)
{
case EffectStacking.Refresh:
if (!zeroDuration)
{
unitEffects[i].Duration = eff.Duration;
}
stop = true;
break;
case EffectStacking.Prolong:
if (!zeroDuration)
{
unitEffects[i].Duration += eff.Duration;
}
stop = true;
break;
case EffectStacking.Stack:
if (unitEffects[i].stacks < eff.MaxImpact)
{
ChangeValue(eff.ImpactValue, eff.spellType);
unitEffects[i].stacks++;
unitEffects[i].ImpactValue.value += eff.ImpactValue.value;
}
unitEffects[i].Duration = Math.Max(unitEffects[i].Duration, eff.Duration);
stop = true;
break;
case EffectStacking.ImpactMult:
if (unitEffects[i].Duration == eff.Duration)
{
unitEffects[i].ImpactValue.value += eff.ImpactValue.value;
unitEffects[i].stacks++;
stop = true;
}
break;
}
if (stop)
{
if (unitEffects[i].refreshFunction)
{
unitEffects[i].EffectFunction();
}
break;
}
}
else
{
}
}
if (zeroDuration)
{
eff.Duration = 0;
}
if (!stop)
{
ChangeValue(eff.ImpactValue, eff.spellType);
unitEffects.Add(eff);
}
if (InstantAction)
{
eff.Duration++; eff.Execute((Unit)MyLogic);
}
if (myUnit.unitlogic == BattleControll.heroLogic.unitlogic)
{
BattleControll.battleControll.HeroEffectsRefresh();
}
}
}
if (PutEvents && spell.unitEvents.AfterDead != null && spell.unitEvents.AfterDead.GetPersistentEventCount() > 0 && !UnderLink(spell))
{
spell.linkedUnits.Add(this);
unitEvents.AfterDead.AddListener(() => { if (UnderSpell(spell))
{
spell.unitEvents.AfterDead.Invoke();
}
});
}
}
public void Run()
{
plane.Print();
if (FermiInTheAir.Utility.OpeningPage.playTutorial)
{
Settings.Tutorial(); // plays only one time when opening application
}
plane.Print();
FermiInTheAir.Utility.OpeningPage.playTutorial = false;
//set plane point coordinates to true
while (!settings.GameOver)
{
// chance to spawn objects, adjust below for collectables / destroyables
int chanceToSpawn = rnd.Next(0, 100);
status.ClearStatus();
status.PrintStatus();
if (Convert.ToInt32(difficultyTimer.ElapsedMilliseconds) > 30000)
{
destroyObjectSpawnFrequency = 40;
}
if (chanceToSpawn <= destroyObjectSpawnFrequency) // previously = 40
{
int objXPosition = 1;
int objYPosition = rnd.Next(11, settings.Width - 11); // previously = rnd.Next(0, settings.Width - 2);
destroyObject = new DestroyObject(new Point(objXPosition, objYPosition));
foreach (var point in destroyObject.PositionsCoordinates)
{
if (CheckCollisionWithPlane(destroyObject, plane))
{
destroyObject.HaveCollision = true;
plane.Lives--;
sounds.Crash();
break;
}
if (CheckCollisionWhitOtherObject(point))
{
destroyObject.HaveCollision = true;
}
}
if (!destroyObject.HaveCollision)
{
gameObjectsList.Add(destroyObject);
destroyObject.SetPositionsCoordinates();
}
}
if (chanceToSpawn <= 15)
{
int objXPosition = 1;
int objYPosition = rnd.Next(7, settings.Width - 7); // previously = rnd.Next(0, settings.Width);
collectObject = new CollectedObject(new Point(objXPosition, objYPosition));
if (CheckCollisionWithPlane(collectObject, plane))
{
collectObject.HaveCollision = true;
settings.Score += 5; //TODO : regulate score
}
if (CheckCollisionWhitOtherObject(collectObject.UpLeftCorner))
{
destroyObject.HaveCollision = true;
}
if (!destroyObject.HaveCollision)
{
gameObjectsList.Add(collectObject);
collectObject.SetPositionsCoordinates();
}
}
while (gameObjectsList.Count > 0)
{
current = gameObjectsList[gameObjectsList.Count - 1];
gameObjectsList.RemoveAt(gameObjectsList.Count - 1);
if (!current.HaveCollision)
{
PrintGameObject.PrintObject(current);
newGameObjectsList.Add(current);
}
}
if (plane.Lives < 0)
{
settings.GameOver = true;
sounds.GameOver();
break;
}
gameObjectsList = newGameObjectsList;
newGameObjectsList = new List<GameObject>();
while (Console.KeyAvailable)
{
plane.Clear();
ConsoleKeyInfo keyPressed = Console.ReadKey(true);
if (keyPressed.Key == ConsoleKey.UpArrow)
{
plane.Position.X--;
if (plane.Position.X < 1)
{
plane.Position.X = 1;
}
}
if (keyPressed.Key == ConsoleKey.DownArrow)
{
plane.Position.X++;
if (plane.Position.X > settings.Height - plane.PlaneHeight)
{
plane.Position.X = settings.Height - plane.PlaneHeight;
}
}
if (keyPressed.Key == ConsoleKey.LeftArrow)
{
plane.Position.Y--;
if (plane.Position.Y < 0)
{
plane.Position.Y = 0;
}
}
if (keyPressed.Key == ConsoleKey.RightArrow)
{
plane.Position.Y++;
if (plane.Position.Y > settings.Width - plane.PlaneWidth)
{
plane.Position.Y = settings.Width - plane.PlaneWidth;
}
}
if (keyPressed.Key == ConsoleKey.Spacebar)
{
projectile = new Projectile(new Point(plane.Position.X - 1, plane.Position.Y + plane.PlaneWidth / 2));
if (CheckCollisionWhitOtherObject(projectile.UpLeftCorner))
{
projectile.HaveCollision = true;
sounds.DestroyObject();
settings.Score += 5;
}
else
{
gameObjectsList.Add(projectile);
}
PrintGameObject.PrintObject(projectile);
}
if (keyPressed.Key == ConsoleKey.P)
{
PauseScreenPage pause = new PauseScreenPage();
pause.PauseMain();
settings.Pause = !settings.Pause;
Console.ReadKey();
Console.Clear();
}
plane.SetPlaneCoordinates();
bool haveCollision = CheckPlaneCollision();
if (haveCollision)
{
plane.Lives--;
sounds.Crash();
}
if (plane.Lives < 0)
{
settings.GameOver = true;
sounds.GameOver();
break;
}
plane.Print();
}
while (gameObjectsList.Count > 0)
{
current = gameObjectsList[gameObjectsList.Count - 1];
gameObjectsList.RemoveAt(gameObjectsList.Count - 1);
PrintGameObject.ClearObject(current);
current.Move();
current.SetPositionsCoordinates();
if (CheckCollisionWithPlane(current, plane))
{
current.HaveCollision = true;
if (current.Symbol != '$' && current.Symbol!= '^')
{
plane.Lives--;
}
else if (current.Symbol == '$')
{
settings.Score += 10;
}
sounds.Crash();
}
else if (CheckCollisionWhitOtherObject(current.UpLeftCorner))
{
current.HaveCollision = true;
sounds.DestroyObject();
settings.Score += 5;
}
else
{
PrintGameObject.PrintObject(current);
newGameObjectsList.Add(current);
}
}
gameObjectsList = newGameObjectsList;
newGameObjectsList = new List<GameObject>();
status.Score = settings.Score;
status.Lives = plane.Lives;
Thread.Sleep(sleepTime);
}
Settings.PrintGameOver(status.Score);
}
public void Start()
{
if (type == Type.FLOOR)
{
GameObject actualBlocker = GameObject.Instantiate(PrefabHolder.popQuakeFloorPrefab, transform.parent, true);
actualBlocker.SetActive(false);
actualBlocker.transform.position = transform.position;
actualBlocker.transform.localScale = transform.lossyScale;
actualBlocker.transform.eulerAngles = transform.eulerAngles;
var t = actualBlocker.Find("Active").transform;
var t2 = gameObject.Find("Active").transform;
for (int c = t2.childCount - 1; c >= 0; c--)
{
t2.GetChild(c).SetParent(t, true);
}
t = actualBlocker.Find("Inactive").transform;
t2 = gameObject.Find("Inactive").transform;
for (int c = t2.childCount - 1; c >= 0; c--)
{
t2.GetChild(c).SetParent(t, true);
}
actualBlocker.Find("Inactive").SetActive(false);
var blockerFsm = actualBlocker.LocateMyFSM("quake_floor");
if (blockerFsm.GetState("Init").Fsm == null)
{
blockerFsm.Preprocess();
}
blockerFsm.SetAttr("fsmTemplate", (FsmTemplate)null);
var blockerFsmVars = blockerFsm.FsmVariables;
blockerFsmVars.GetFsmBool("Glass").Value = false;
blockerFsmVars.GetFsmString("Playerdata Bool").Value = pdBool;
DestroyObject doAction = new DestroyObject
{
gameObject = blockerFsmVars.GetFsmGameObject("Inactive"),
delay = 0.0f,
detachChildren = true
};
var agoAction = new ActivateGameObject
{
gameObject = new FsmOwnerDefault
{
OwnerOption = OwnerDefaultOption.SpecifyGameObject,
GameObject = blockerFsmVars.GetFsmGameObject("Inactive")
},
activate = false,
recursive = false,
resetOnExit = false,
everyFrame = false
};
blockerFsm.AddAction("Destroy", agoAction);
blockerFsm.AddAction("Destroy", doAction);
blockerFsm.RemoveAction("Activate", 0);
blockerFsm.AddAction("Activate", new SetBoolValue()
{
boolVariable = blockerFsmVars.GetFsmBool("Activated"),
boolValue = true,
everyFrame = false
});
blockerFsm.AddAction("Activate", new ActivateGameObject()
{
gameObject = new FsmOwnerDefault()
{
OwnerOption = OwnerDefaultOption.SpecifyGameObject,
GameObject = blockerFsmVars.GetFsmGameObject("Active")
},
activate = false,
recursive = false,
resetOnExit = false,
everyFrame = false
});
blockerFsm.AddAction("Activate", new ActivateGameObject()
{
gameObject = new FsmOwnerDefault()
{
OwnerOption = OwnerDefaultOption.SpecifyGameObject,
GameObject = blockerFsmVars.GetFsmGameObject("Inactive")
},
activate = true,
recursive = false,
resetOnExit = false,
everyFrame = false
});
blockerFsm.AddAction("Activate", new SetCollider()
{
gameObject = new FsmOwnerDefault()
{
OwnerOption = OwnerDefaultOption.UseOwner
},
active = false
});
blockerFsm.AddAction("Init", new PlayerDataBoolTest()
{
gameObject = new FsmOwnerDefault()
{
OwnerOption = OwnerDefaultOption.SpecifyGameObject,
GameObject = GameManager.instance.gameObject
},
boolName = blockerFsmVars.GetFsmString("Playerdata Bool"),
isTrue = FsmEvent.GetFsmEvent("ACTIVATE"),
isFalse = FsmEvent.Finished
});
blockerFsm.RemoveAction("Init", 0);
blockerFsm.RemoveAction("PD Bool?", 0);
blockerFsm.SetState("Pause");
blockerFsm.MakeLog(true);
actualBlocker.SetActive(true);
Object.Destroy(gameObject);
}
else if (type == Type.WALL)
{
}
}
public static void ReadMessage(byte[] message)
{
Envelope envelope = SerializationHandler.Deserialize <Envelope>(message);
if (envelope == null)
{
throw new NotAnEnvelopeException();
}
switch (envelope.PacketType)
{
case Packets.None:
Debug.Log("None");
break;
case Packets.String:
string stringVal = SerializationHandler.Deserialize <string>(envelope.Packet);
Debug.Log(stringVal);
break;
case Packets.AckLogin:
AckLogin ackLogin = SerializationHandler.Deserialize <AckLogin>(envelope.Packet);
HandleAckLogin(ackLogin);
break;
case Packets.AckJoinTeam:
AckJoinTeam ackJoinTeam = SerializationHandler.Deserialize <AckJoinTeam>(envelope.Packet);
HandleAckJoinTeam(ackJoinTeam);
break;
case Packets.DestroyObject:
DestroyObject destroyObject = SerializationHandler.Deserialize <DestroyObject>(envelope.Packet);
HandleDestroyObject(destroyObject);
break;
case Packets.PlayerSync:
PlayerSync playerSync = SerializationHandler.Deserialize <PlayerSync>(envelope.Packet);
HandlePlayerSync(playerSync);
break;
case Packets.SnowballSync:
SnowballSync snowballSync = SerializationHandler.Deserialize <SnowballSync>(envelope.Packet);
HandleSnowballSync(snowballSync);
break;
case Packets.SnowPileSync:
SnowPileSync snowPileSync = SerializationHandler.Deserialize <SnowPileSync>(envelope.Packet);
HandleSnowPileSync(snowPileSync);
break;
case Packets.LeaderboardData:
LeaderboardDataEntry leaderboardDataResponse = SerializationHandler.Deserialize <LeaderboardDataEntry>(envelope.Packet);
HandleLeaderboardDataEntry(leaderboardDataResponse);
break;
case Packets.EndLeaderboardResponse:
HandleEndLeaderboardResponse();
break;
case Packets.AckConnection:
HandleAckConnection();
break;
default:
break;
}
}
void Start()
{
enemy = transform.root.GetComponent <DestroyObject>();
hpslider = transform.Find("Slider").GetComponent <Slider>();
}
