public void MainLogicThread()
{
for (uint i = 1; i < 5; ++i)
{
MonsterCharacter monster = new MonsterCharacter();
monster.UniqueID = i;
dicMonsters.Add(i,monster);
}
while (true)
{
Time.Update();
Parse();
Update();
}
}
private void Awake()
{
Messaging.GUI.ActiveSlot.Invoke(-1);
character = GetComponent <MonsterCharacter>();
character.OnInputRequest = FillInputFrame;
character.OnDeath.AddListener(() => { OnDeath(); });
character.OnDamage.AddListener((_) => { Messaging.GUI.Painflash.Invoke(.25f); });
character.OnWeaponChange.AddListener((i) =>
{
PlayerInfo.CurrentLocal.LastPlayerWeaponSwap = i;
Messaging.GUI.ActiveSlot.Invoke(i);
if (i >= 0 && i < character.weapons.Length && character.weapons[i] != null)
{
Messaging.GUI.LeftAbilityIcon.Invoke(character.weapons[i].LeftAbilitySprite);
Messaging.GUI.RightAbilityIcon.Invoke(character.weapons[i].RightAbilitySprite);
}
else
{
Messaging.GUI.LeftAbilityIcon.Invoke(null);
Messaging.GUI.RightAbilityIcon.Invoke(null);
}
});
GetComponent <ThingController>().GridPosChanged.AddListener((p) =>
{
Messaging.Player.PlayerGridPosition.Invoke(p);
int r = Room.GetRoomIndex(p);
if (r != -1)
{
Messaging.Player.PlayerEnterRoom.Invoke(r);
}
});
PlayerInfo.CurrentLocal.PlayerHasBeenInitialized = true;
character.OnDeserialize.AddListener(() =>
{
Messaging.CameraControl.Spectator.Invoke(false);
Messaging.CameraControl.RemoveShake.Invoke();
Messaging.CameraControl.TargetPosition.Invoke(transform.position);
Messaging.CameraControl.TargetRotation.Invoke(0);
Messaging.CameraControl.SpeedMultiplier.Invoke(1f);
Messaging.CameraControl.Teleport.Invoke();
});
Messaging.Player.EquipPlayerItems.AddListener(() =>
{
for (int w = 0; w < Mathf.Min(PlayerInfo.CurrentLocal.PlayerWeapons.Length, character.weapons.Length); w++)
{
if (PlayerInfo.CurrentLocal.PlayerWeapons == null)
{
character.weapons[w] = null;
continue;
}
character.weapons[w] = PlayerInfo.CurrentLocal.PlayerWeapons[w];
}
for (int s = 0; s < Mathf.Min(PlayerInfo.CurrentLocal.PlayerSkills.Length, character.Skills.Length); s++)
{
if (PlayerInfo.CurrentLocal.PlayerSkills == null)
{
character.Skills[s] = null;
continue;
}
character.Skills[s] = PlayerInfo.CurrentLocal.PlayerSkills[s];
}
SetActionBarIcons();
});
Messaging.Player.ForceHolster.AddListener(() => { character.UnEquip(); });
Messaging.Player.DeActivateSkill.AddListener((i) =>
{
character.Skills[i]?.DeActivate(character, i);
});
Messaging.Player.ActivateAccessory.AddListener((i) =>
{
if (i >= 0 && i < PlayerInfo.CurrentLocal.PlayerAccessories.Length)
{
PlayerInfo.CurrentLocal.PlayerAccessories[i]?.Activate(character);
}
});
Messaging.Player.DeActivateAccessory.AddListener((i) =>
{
if (i >= 0 && i < PlayerInfo.CurrentLocal.PlayerAccessories.Length)
{
PlayerInfo.CurrentLocal.PlayerAccessories[i]?.DeActivate(character);
}
});
Messaging.Player.AddTalent.AddListener((talent) =>
{
if (PlayerInfo.CurrentLocal.TalentPoints <= 0)
{
Messaging.GUI.ScreenMessage.Invoke("NOT ENOUGH TALENT POINTS!", Color.red);
return;
}
PlayerInfo.CurrentLocal.Talents.Add(talent);
talent.Activate(character);
PlayerInfo.CurrentLocal.TalentPoints--;
Messaging.Player.TalentPoints.Invoke(PlayerInfo.CurrentLocal.TalentPoints);
});
Messaging.Player.RemoveTalent.AddListener((talent) =>
{
if (!PlayerInfo.CurrentLocal.Talents.Contains(talent))
{
Debug.LogError("PlayerControls: RemoveTalent: talent \"" + talent.name + "\" not found in PlayerInfo.CurrentLocal.Talents");
return;
}
talent.DeActivate(character);
PlayerInfo.CurrentLocal.Talents.Remove(talent);
PlayerInfo.CurrentLocal.TalentPoints++;
Messaging.Player.TalentPoints.Invoke(PlayerInfo.CurrentLocal.TalentPoints);
});
Messaging.Player.GetLocalPlayerStats = () =>
{
MonsterCharacter.ChargeRegenFrame frame = new MonsterCharacter.ChargeRegenFrame
{
RechargeAmount = character.ChargeRegenPerTick
};
character.OnChargeRegen.Invoke(frame);
return(new PlayerStats()
{
MaxHealth = character.MaxHitPoints / 1000,
MaxCharge = character.MaxChargePoints / 1000,
Armor = character.Armor,
MovementSpeed = character.walkSpeed,
ChargeRegen = (float)frame.RechargeAmount * 50f / 1000f,
DamageDecay = (float)character.SoftDamageDecayPerTick * 50f / 1000f,
});
};
Messaging.Player.Invulnerable.AddListener((b) =>
{
character.Invulnerable = b;
});
Messaging.GUI.OpenCanvas.Invoke("GameCanvas");
}
public void LifeTargetEnable(MonsterCharacter target)
{
this._healthTargetObject.gameObject.SetActive(true);
this.healthBarTargetInfo(target);
if (!target.possessed)
this._targetName.text = target.monsterName;
else
this._targetName.text = UIManager.instance.player.playerName;
}
public virtual void DeActivate(MonsterCharacter character, int index)
{
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (!Active)
{
return;
}
MonsterCharacter m = collision.GetComponent <MonsterCharacter>();
if (m == null)
{
return;
}
if (m.GetComponent <PlayerControls>() == null)
{
return;
}
OnPlayerTouch.Invoke();
//stop the player and make him invulnerable
m.physicsBody.velocity = Vector2.zero;
m.impulseVector = Vector2.zero;
m.Invulnerable = true;
m.enabled = false;
//to avoid division by zero just change level instantly
if (FadeoutTime == 0)
{
Messaging.GUI.Blackout.Invoke(0f);
Messaging.System.ChangeLevel.Invoke(TargetLevel, EntryPoint);
return;
}
GameObject fadeout = new GameObject("fadeout levelchange");
float timer = 0;
UpdateCallHook u = fadeout.AddComponent <UpdateCallHook>();
u.OnUpdateCall.AddListener(() =>
{
timer += Time.unscaledDeltaTime;
float fade = timer / FadeoutTime;
Messaging.GUI.Blackout.Invoke(Mathf.Clamp01(fade));
});
DestroyAfterTime d = fadeout.AddComponent <DestroyAfterTime>();
d.LifeTime = FadeoutTime + .1f; //small addition to let screen turn to fully black
d.UseUnscaledTime = true;
d.OnDestroy.AddListener(() =>
{
/*Messaging.GUI.LoadingWindow.Invoke(() =>
* {
* Messaging.System.ChangeLevel.Invoke(TargetLevel, EntryPoint);
* });*/
Messaging.System.ChangeLevel.Invoke(TargetLevel, EntryPoint);
});
if (TeleportEffect != null)
{
Instantiate(TeleportEffect, collision.transform.position, Quaternion.identity, LevelLoader.TemporaryObjects);
Destroy(collision.gameObject);
}
}
public override void DeActivate(MonsterCharacter character)
{
character.OnCombineMove -= Character_OnCombineMove;
owner = null;
}
public override void Activate(MonsterCharacter character)
{
owner = character;
character.GenerateSoftDamage.AddListener(SoftDamageMod);
character.OnDealDamage.AddListener(DealDamageMod);
}
IEnumerator ReleaseMonsterProcess(Vector3 targetVec)
{
//transform.Translate(Vector3.up * 10);
possessedMonster.EnableAI();
possessedMonster.monsterCollider.enabled = true;
possessedMonster.possessed = false;
possessedMonster = null;
isPossessingMonster = false;
playerRenderer.SetActive(true);
totalMaxHP = playerMaxHP;
totalHP = playerHP;
totalStr = playerStr;
totalInt = playerInt;
totalDef = playerDef;
totalRes = playerRes;
//UI
UIManager.instance.HidePossessButton();
UIManager.instance.HideReleaseButton();
yield return null;
}
void TakeSpellDamages(int amount, MonsterCharacter attacker = null)
{
monsterHP -= amount - (monsterRes / 3);
if (monsterHP <= 0)
{
DisableAI();
isAlive = false;
//mainMeshRenderer.enabled = false;
mainCollider.enabled = false;
}
if (attacker != null)
{
attackTarget = attacker;
isAttacked = true;
}
}
public void TakeDamages(int amount, MonsterCharacter attacker=null)
{
if (possessed)
{
UIManager.instance.UpdateStatusUI();
UIManager.instance.player.TakeDamages(amount);
}
else
{
monsterHP -= amount - (monsterDef / 3);
//Prendre le cas où le monstre est possédé pour actualiser la vie du joueur
if (monsterHP <= 0)
{
DisableAI();
isAlive = false;
//mainMeshRenderer.enabled = false;
mainCollider.enabled = false;
}
if (attacker != null)
{
attackTarget = possessed == true ? null : attacker;
isAttacked = true;
}
}
}
public void AttackTarget(MonsterCharacter target, int strength)
{
target.TakeDamages(strength, this);
//cooldown
simpleAttackCurrentCoolDownLevel = 0;
isReadyToAttack = false;
}
void Respawn()
{
isAlive = true;
//mainMeshRenderer.enabled = true;
mainCollider.enabled = true;
EnableAI();
if (IA.EstAgresse)
IA.changeStat();
monsterHP = monsterMaxHP;
transform.position = startPos;
attackTarget = null;
}
public override void DeActivate(MonsterCharacter character)
{
character.walkSpeed -= MoveBonus;
character.OnChargeRegen.RemoveListener(ChargeBoost);
owner = null;
}
public override void Activate(MonsterCharacter character)
{
owner = character;
character.walkSpeed += MoveBonus;
character.OnChargeRegen.AddListener(ChargeBoost);
}
public abstract void VisitMonsterCharacter(
MonsterCharacter monsterCharacter);
public void Init(Weapon weapon, MonsterCharacter character)
{
weapon.OnFire.AddListener(() => { recoilAmount = 1f; });
character.OnDeath.AddListener(() => { Destroy(this); });
}
public void Possess()
{
attackTarget = null;
}
public override void DeActivate(MonsterCharacter character)
{
character.GenerateSoftDamage.RemoveListener(SoftDamageMod);
character.OnDealDamage.RemoveListener(DealDamageMod);
owner = null;
}
public override void DeActivate(MonsterCharacter character)
{
character.OnAmmoPickup.RemoveListener(AmmoPickupBonus);
owner = null;
}
public override void DeActivate(MonsterCharacter character) => character.AnimationSpeedMultiplier = 1f;
public override void Activate(MonsterCharacter character)
{
owner = character;
character.OnAmmoPickup.AddListener(AmmoPickupBonus);
}
public override void Activate(MonsterCharacter character)
{
owner = character;
character.OnCombineMove += Character_OnCombineMove;
}
public void UpdateStatusTarget(MonsterCharacter target) { mainUI.healthBarTargetInfo(target); }
public override void Activate(MonsterCharacter character, int index)
{
//would result in illegal normalization, need a direction to dash into
if (character.physicsBody.velocity == Vector2.zero)
{
return;
}
//need 65% of full power at minimum
if (character.ChargePoints < (ChargeCost * .65f))
{
Sounds.CreateSound(FailSound);
Messaging.GUI.ScreenMessage.Invoke("NOT ENOUGH CHARGE", Color.red);
return;
}
if (character.SkillCooldowns[index] > 0)
{
Sounds.CreateSound(FailSound);
return;
}
Sounds.CreateSound(ActivationSound);
character.SkillCooldowns[index] = Cooldown;
float strength = Strength;
if (character.ChargePoints < ChargeCost)
{
strength *= (float)character.ChargePoints / ChargeCost;
character.ChargePoints = 0;
}
else
{
character.ChargePoints -= ChargeCost;
}
DashSkill d = Instantiate(this, LevelLoader.DynamicObjects);
d.Strength = strength;
d.direction = character.physicsBody.velocity.normalized;
d.targetCharacter = character;
d.timer = ActiveTime;
if (AttachmentEffect != null)
{
foreach (string attachPoint in AttachmentPoints)
{
GameObject effect = Instantiate(AttachmentEffect);
GenericTimer e = effect.AddComponent <GenericTimer>();
e.LifeTime = ActiveTime * 5;
e.OnTimer.AddListener(() =>
{
TrailRenderer tr = effect.GetComponentInChildren <TrailRenderer>();
if (tr != null)
{
tr.emitting = false;
}
});
DestroyAfterTime t = effect.AddComponent <DestroyAfterTime>();
t.LifeTime = ActiveTime * 10;
effect.transform.SetParent(character.GetAttachmentPoint(attachPoint), false);
}
}
}
public void DisplayTargetStatus(MonsterCharacter target) { mainUI.LifeTargetEnable(target); }
public DotFrame(int TotalDamage, int DamagePerApplication, DamageType DamageType, MonsterCharacter Attacker)
{
totalDamage = TotalDamage;
damagePerApplication = DamagePerApplication;
damageType = DamageType;
attacker = Attacker;
}
public override void DeActivate(MonsterCharacter character)
{
character.MaxChargePoints *= 2;
character.OnChargeRegen.RemoveListener(TalentBonus);
}
public void healthBarTargetInfo(MonsterCharacter target)
{
this._healthTargetText.text = target.monsterMaxHP.ToString();
float itlife = (float)target.monsterHP / (float)target.monsterMaxHP; //<== valeur entre 0 et 1
_healthTargetBar.fillAmount = Mathf.Lerp(_healthTargetBar.fillAmount, itlife, 5 * Time.deltaTime);
//this._healthTargetBar.transform.localScale = new Vector3(Mathf.Clamp(itlife, 0f, 1f), this._healthTargetBar.transform.localScale.y, this._healthTargetBar.transform.localScale.z);
}
void PossessionProcess()
{
//On Click Events---------------------------------------------------------
if(Input.GetMouseButtonDown(0))
{
//ray = cam.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out hit, 100.0f, monsterLayerMask))
{
if (isPossessingMonster) //Case where we are possessing a monster
{
possessedMonster.attackTarget = hit.collider.GetComponent<MonsterCharacter>();
possessedMonster.attackTarget.GetComponent<Renderer>().material.color = Color.red;
UIManager.instance.DisplayAttackButton();
//Display And Update Target Monster Status
// -- Display Status
UIManager.instance.DisplayTargetStatus(possessedMonster.attackTarget);
}
else //Case where we are not possessing any monster
{
targetMonster = hit.collider.GetComponent<MonsterCharacter>();
if (targetMonster != null && targetMonster != possessedMonster)
{
UIManager.instance.DisplayPossessButton();
//Update and display information about targeted monster
//UIManager.instance.UpdateStatusTarget();
//UIManager.instance.DisplayTargetStatus();
}
}
}
else if(Physics.Raycast(ray, out hit, questerLayerMask))
{
Quester q = hit.collider.GetComponent<Quester>();
if (quester != null && quester.QuestId == 2)
{
quester.Talk();
}
}
else
{
targetMonster = null;
}
}
//-----------------------------------------------------------------------
if (isPossessingMonster)
{
possessedMonster.transform.position = transform.position;
possessedMonster.transform.rotation = transform.rotation;
UIManager.instance.UpdateAttackButton(possessedMonster.simpleAttackCurrentCoolDownLevel / possessedMonster.simpleAttackCoolDown);
if (possessedMonster.attackTarget != possessedMonster && possessedMonster.attackTarget != null)
{
rangeProjector.orthographicSize = Mathf.Lerp(rangeProjector.orthographicSize, possessedMonster.simpleAttackRange, 10 * Time.deltaTime);
}
else
{
rangeProjector.orthographicSize = Mathf.Lerp(rangeProjector.orthographicSize, 0, 10 * Time.deltaTime);
}
}
}
private void Awake() => mc = GetComponent <MonsterCharacter>();
public void PossessMonster()
{
if(Vector3.Distance(transform.position, targetMonster.transform.position) < 6)
{
if(playerLevel >= targetMonster.monsterLevel)
{
possessedMonster = targetMonster;
targetMonster = null;
isPossessingMonster = true;
possessedMonster.possessed = true;
possessedMonster.monsterCollider.enabled = false;
possessedMonster.DisableAI();
possessedMonster.transform.rotation = transform.rotation;
StartCoroutine("PossessMonsterProcess", transform.position);
}
else
{
UIManager.instance.UpdateInfoText("Niveau du monstre trop élevé");
}
}
}
public virtual void DeActivate(MonsterCharacter character)
{
}
public virtual void Equip(MonsterCharacter caller)
{
character = caller;
RaiseTimer = raiseTime / character.AnimationSpeedMultiplier;
}
