private IEnumerator RunConversation(string conversationReference)
{
SetPromptVisible(false);
IsInConversation = true;
ConversationStarted.InvokeSafe(_currentFragment, _owner);
while (_currentFragment != null)
{
if (_currentFragment.IsPlayer)
{
yield return(ShowPlayerSpeech(_currentFragment.ToSay[0], _currentFragment.ToSay[1]));
}
else
{
yield return(ShowSpeech(_currentFragment.ToSay[0], false));
}
}
_talkingTo = null;
IsInConversation = false;
if (ConversationFunctionLibrary.ShouldRerun(App.AIBlackboard.GetConversation(conversationReference).ShouldRerun, _owner))
{
_availableConversations.Insert(0, conversationReference);
}
ConversationEnded.InvokeSafe(_owner);
if (_conversationTrigger.bounds.Contains(App.AIBlackboard.Player.transform.position))
{
SetPromptVisible(true);
}
_conversation = null;
}
//Starts specific conversation
private void StartConversation(string conversationReference, BaseCharacterController listener)
{
_currentFragment = App.AIBlackboard.GetConversation(conversationReference);
_talkingTo = listener;
_conversation = StartCoroutine(RunConversation(conversationReference));
}
public static void RunFunction(ConversationOutput toRun, Data parameters, BaseCharacterController speaker, BaseCharacterController listener)
{
switch (toRun)
{
case ConversationOutput.None:
break;
case ConversationOutput.TransferMoney:
TransferMoney(speaker, listener, parameters.iVal);
break;
case ConversationOutput.Heal:
HealListener(listener, parameters.iVal);
break;
case ConversationOutput.GiveAbility:
GiveAbility(listener, parameters.sVal);
break;
case ConversationOutput.BuyAbility:
GiveAbility(listener, parameters.sVal);
TransferMoney(speaker, listener, parameters.iVal);
break;
}
}
private static void HealListener(BaseCharacterController listener, int healBy)
{
if (healBy == 0)
{
listener.Health.FullHeal();
}
else
{
listener.Health.Heal((uint)healBy);
}
}
private static void TransferMoney(BaseCharacterController speaker, BaseCharacterController listener, int amount)
{
if (amount > 0)
{
speaker.Inventory.TransferCurrencyTo(listener.Inventory, amount);
}
else
{
listener.Inventory.TransferCurrencyTo(speaker.Inventory, -amount);
}
}
//Starts next conversation off stack
private void TryStartConversation(BaseCharacterController other)
{
int availableConversation = IsConversationAvailable();
if (availableConversation == -1 || IsInConversation || !_conversationTrigger.bounds.Contains(other.transform.position))
{
return;
}
StartConversation(_availableConversations[availableConversation], other);
_availableConversations.RemoveAt(availableConversation);
}
private static void GiveAbility(BaseCharacterController listener, string ability)
{
switch (ability)
{
case "DoubleJump":
{
if (listener.MaxJumps < 2)
{
listener.MaxJumps = 2;
}
break;
}
case "Melee":
{
PlayerController player = listener as PlayerController;
if (player != null)
{
player.UnlockAbility(Inventory.Ability.Square);
}
break;
}
case "Dash":
{
PlayerController player = listener as PlayerController;
if (player != null)
{
player.UnlockAbility(Inventory.Ability.Circle);
}
break;
}
case "Shoot":
{
PlayerController player = listener as PlayerController;
if (player != null)
{
player.UnlockAbility(Inventory.Ability.Triangle);
}
break;
}
default:
UnityEngine.Debug.LogErrorFormat("Can't unlock ability '{0}'", ability);
break;
}
}
public void Initialise(BaseCharacterController owner, InventoryContents initialContents, bool dropped = false)
{
Contents.Add(initialContents);
Owner = owner;
OnGround = dropped;
Debug.Assert(Contents != null);
if (!OnGround)
{
Owner.Health.OnDied += OnDie;
}
}
private void Start()
{
if (_spawnerType == CharacterFaction.Player && !_primaryPlayerSpawnPoint)
{
return;
}
BaseCharacterController spawned = Instantiate(_config.GetPrefab(_spawnerType), transform.position, Quaternion.identity).GetComponent <BaseCharacterController>();
spawned.OnSpawn(this, _characterConfig);
OnSpawn.InvokeSafe(spawned);
OnSpawnNonStatic.InvokeSafe(spawned);
}
public void Setup(BaseCharacterController owner, int damage, Vector3 velocity, PrefabPool owningPool, float lifetime = 5.0f)
{
base.Setup(owner, damage);
_image.localRotation = Quaternion.identity;
Debug.Assert(owningPool != null);
_owningPool = owningPool;
_velocity = velocity;
_destructionTime = Time.time + lifetime;
_active = true;
_spinMultiplier = _velocity.x > 0.0f ? -1.0f : 1.0f;
}
private void PickUp(BaseCharacterController picker)
{
picker.Inventory.Add(Contents);
_prompt.SetActive(false);
if (Owner != null && picker != Owner)
{
App.AIBlackboard.AddCriminal(picker);
}
if (_refillTime != 0.0f)
{
StartCoroutine(RefillContainer());
}
}
private IEnumerator TryPickUp(BaseCharacterController picker)
{
if (OnGround)
{
float stayDuration = 0.0f;
while (stayDuration < _pickDuration)
{
stayDuration = (Time.time - _pickerEnterTime);
_progressbar.fillAmount = (stayDuration / _pickDuration);
yield return(null);
}
PickUp(picker);
Destroy(gameObject);
}
}
private void OnTriggerExit2D(Collider2D collision)
{
if (IsConversationAvailable() != -1)
{
BaseCharacterController character = collision.gameObject.GetComponent <BaseCharacterController>();
if (character != null)
{
if (character.GetType() == typeof(PlayerController))
{
SetPromptVisible(false);
}
_potentialParticipants.Remove(character);
}
}
}
private void OnOwnerDie(BaseCharacterController obj)
{
_prompt.SetVisible(false);
if (_conversation != null)
{
StopCoroutine(_conversation);
_conversation = null;
if (_currentDialogue != null)
{
HUD.Instance.DestroyMenu(_currentDialogue);
}
if (_currentBubble != null)
{
HUD.Instance.DestroyMenu(_currentBubble);
}
}
}
protected virtual void OnTriggerEnter2D(Collider2D collision)
{
if (CollisionIsOwner(collision))
{
return;
}
BaseCharacterController characterHit = collision.gameObject.GetComponent <BaseCharacterController>();
if (characterHit != null)
{
OnHit.InvokeSafe(characterHit);
characterHit.Health.Damage(this);
}
Wall wall = collision.gameObject.GetComponent <Wall>();
if (wall != null)
{
wall.Damage(this);
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (OnGround && !Contents.IsEmpty())
{
BaseCharacterController controller = collision.gameObject.GetComponent <BaseCharacterController>();
if (controller != null && !_pickers.Contains(controller))
{
_pickers.Add(controller);
_pickerEnterTime = Time.time;
if (controller is Player.PlayerController)
{
_prompt.SetActive(true);
}
if (_pickDuration != 0)
{
_pickUp = StartCoroutine(TryPickUp(controller));
}
}
}
}
private void OnTriggerExit2D(Collider2D collision)
{
if (OnGround)
{
BaseCharacterController picker = _pickers.Find(p => p.gameObject == collision.gameObject);
if (picker != null)
{
_pickers.Remove(picker);
if (picker is Player.PlayerController)
{
_prompt.SetActive(false);
}
if (_pickUp != null)
{
StopCoroutine(_pickUp);
_pickUp = null;
}
}
}
}
public static bool ShouldRerun(RerunPredicate predicate, BaseCharacterController speaker)
{
switch (predicate)
{
case RerunPredicate.Never:
return(false);
case RerunPredicate.Always:
return(true);
case RerunPredicate.IfPlayerCantDoubleJump:
return(App.AIBlackboard.Player.MaxJumps == 1);
case RerunPredicate.IfPlayerDoesntHaveTriangleAbility:
return(!App.AIBlackboard.Player.FactionUnlocked(CharacterFaction.Triangle));
case RerunPredicate.IfPlayerDoesntHaveCircleAbility:
return(!App.AIBlackboard.Player.FactionUnlocked(CharacterFaction.Circle));
default:
Debug.LogErrorFormat("RerunPredicate {0} not implemented", predicate);
return(false);
}
}
public static bool IsAvailable(ConversationPredicate predicate, BaseCharacterController speaker)
{
switch (predicate)
{
case ConversationPredicate.PlayerIsHurt:
return(IsPlayerHurt());
case ConversationPredicate.NoDoubleJump:
return(App.AIBlackboard.Player.MaxJumps < 2);
case ConversationPredicate.PlayerIsSquare:
return(App.AIBlackboard.Player.CurrentShape == CharacterFaction.Square);
case ConversationPredicate.PlayerIsCircle:
return(App.AIBlackboard.Player.CurrentShape == CharacterFaction.Circle);
case ConversationPredicate.PlayerIsTriangle:
return(App.AIBlackboard.Player.CurrentShape == CharacterFaction.Triangle);
case ConversationPredicate.PlayerHasCashAndIsSquare:
return(App.AIBlackboard.Player.Inventory.Contents.Currency >= 1000 && App.AIBlackboard.Player.CurrentShape == CharacterFaction.Square);
case ConversationPredicate.PlayerHasCashAndIsTriangle:
return(App.AIBlackboard.Player.Inventory.Contents.Currency >= 1000 && App.AIBlackboard.Player.CurrentShape == CharacterFaction.Triangle);
case ConversationPredicate.NOTPlayerHasCashAndIsSquare:
return(!(App.AIBlackboard.Player.Inventory.Contents.Currency >= 1000 && App.AIBlackboard.Player.CurrentShape == CharacterFaction.Square));
case ConversationPredicate.NOTPlayerHasCashAndIsTriangle:
return(!(App.AIBlackboard.Player.Inventory.Contents.Currency >= 1000 && App.AIBlackboard.Player.CurrentShape == CharacterFaction.Triangle));
case ConversationPredicate.None:
default:
return(true);
}
}
private void OnSpawn(BaseCharacterController spawned)
{
Owner = spawned;
}
private void OnDie(BaseCharacterController died)
{
_deathLocation = Owner.transform.position;
DropInventory();
}
public virtual void Setup(BaseCharacterController owner, int damage)
{
Owner = owner;
_damage = damage;
}
private void Start()
{
_character = GetComponent <BaseCharacterController>();
CurrentHealth = _character.Config.MaxHealth;
App.WorldState.SetState(new Narrative.WorldProperty(_character.ID, Narrative.EProperty.IsDead, false));
}
private void OnRangedHit(BaseCharacterController hit)
{
Events.OnRangedAttackConnect.InvokeSafe(hit);
}
private void OnDashHit(BaseCharacterController obj)
{
Events.OnDashAttackConnect.InvokeSafe(obj);
}
