public void default_allows_nothing()
{
var condition = new CharacterCondition();
var actual = condition.IsMatch('h');
actual.Should().BeFalse();
}
protected bool HasCondition(CharacterCondition condtion)
{
if (conditionList == null)
{
return(false);
}
return(conditionList.Contains(condtion));
}
public void empty_string_produces_no_conditions()
{
var text = string.Empty;
var actual = CharacterCondition.Parse(text);
actual.Should().BeEmpty();
}
public void single_character_allows_exactly_that_character(char allowedLetter, char givenLetter, bool expected)
{
var condition = CharacterCondition.Create(allowedLetter, false);
var actual = condition.IsMatch(givenLetter);
actual.Should().Be(expected);
}
public void range_allows_only_specified_characters(char[] range, char givenLetter, bool expected)
{
var condition = CharacterCondition.Create(range, false);
var actual = condition.IsMatch(givenLetter);
actual.Should().Be(expected);
}
public void range_resricts_specified_characters(char[] range, char givenLetter, bool expected)
{
var condition = CharacterCondition.Create(range, true);
var actual = condition.IsMatch(givenLetter);
actual.Should().Be(expected);
}
public void invalid_condition_creates_empty_result()
{
var text = "[x";
var actual = CharacterCondition.Parse(text);
actual.Should().BeEmpty();
}
public void multiple_in_negated_range_allows_all_but_specified()
{
var text = "[^qwerty]";
var actual = CharacterCondition.Parse(text);
actual.Should().HaveCount(1);
actual[0].Characters.ShouldBeEquivalentTo("qwerty".ToCharArray());
actual[0].Restricted.Should().BeTrue();
}
public void single_in_negated_range_allows_all_but_one()
{
var text = "[^t]";
var actual = CharacterCondition.Parse(text);
actual.Should().HaveCount(1);
actual[0].Characters.ShouldBeEquivalentTo(new[] { 't' });
actual[0].Restricted.Should().BeTrue();
}
private void SetEffect(CharacterCondition characterCondition)
{
string path = string.Format("Animators/Effect/{0}", characterCondition.ToString());
RuntimeAnimatorController animController = Resources.Load <RuntimeAnimatorController>(path);
if (animator != null && animController != null)
{
animator.runtimeAnimatorController = animController;
}
}
// MISC State Changes -----------------------------------------
public void Respawn()
{
if (conditionState != CharacterCondition.dead)
{
return;
}
PlayerManager.Instance.SpawnPlayer(controller);
conditionState = CharacterCondition.alive;
}
public void double_caret_negated_range_allows_all_but_caret()
{
var text = "[^^]";
var actual = CharacterCondition.Parse(text);
actual.Should().HaveCount(1);
actual[0].Characters.ShouldBeEquivalentTo(new[] { '^' });
actual[0].Restricted.Should().BeTrue();
}
public void empty_negated_range_allows_any()
{
var text = "[^]";
var actual = CharacterCondition.Parse(text);
actual.Should().HaveCount(1);
actual[0].Characters.Should().BeEmpty();
actual[0].Restricted.Should().BeTrue();
}
public void single_letter_in_brackets_creates_single_char()
{
var text = "[b]";
var actual = CharacterCondition.Parse(text);
actual.Should().HaveCount(1);
actual[0].Characters.ShouldBeEquivalentTo(new[] { 'b' });
actual[0].Restricted.Should().BeFalse();
}
public void multiple_letter_in_brackets_creates_allowed_multiple()
{
var text = "[qwerty]";
var actual = CharacterCondition.Parse(text);
actual.Should().HaveCount(1);
actual[0].Characters.ShouldBeEquivalentTo("qwerty".ToCharArray());
actual[0].Restricted.Should().BeFalse();
}
public void single_dot_allows_anything()
{
var text = ".";
var actual = CharacterCondition.Parse(text);
actual.Should().HaveCount(1);
actual[0].Characters.Should().BeEmpty();
actual[0].Restricted.Should().BeTrue();
}
public void empty_brackets_creates_disallowed_condition()
{
var text = "[]";
var actual = CharacterCondition.Parse(text);
actual.Should().HaveCount(1);
actual[0].Characters.Should().BeEmpty();
actual[0].Restricted.Should().BeFalse();
}
public void Initialize(float lifeTime, float size, Transform target, CharacterCondition characterCondition, float alpha = 136f)
{
this.target = target;
this.lifeTime = lifeTime;
this.transform.localScale = Vector3.one * size;
if (spriteRenderer != null)
{
spriteRenderer.color = new Color(1f, 1f, 1f, alpha / 255f);
}
SetEffect(characterCondition);
}
public void two_mixed_ranges_makes_two__restricted_conditions()
{
var text = "[qwerty][^asdf]";
var actual = CharacterCondition.Parse(text);
actual.Should().HaveCount(2);
actual[0].Characters.ShouldBeEquivalentTo("qwerty".ToCharArray());
actual[0].Restricted.Should().BeFalse();
actual[1].Characters.ShouldBeEquivalentTo("asdf".ToCharArray());
actual[1].Restricted.Should().BeTrue();
}
protected void AddCondition(CharacterCondition condition)
{
if (conditionList == null)
{
return;
}
if (conditionList.Contains(condition) == true)
{
return;
}
conditionList.Add(condition);
}
protected void RemoveCondition(CharacterCondition condition)
{
if (conditionList == null)
{
return;
}
if (conditionList.Contains(condition) == false)
{
return;
}
conditionList.Remove(condition);
}
public void Initialize(Vector3 position, float pollutedTime, float size, CharacterCondition polluteType, BulletType bulletType)
{
this.pollutedTime = pollutedTime;
this.transform.localScale = Vector3.one * size;
this.transform.position = position;
this.polluteType = polluteType;
SetPollute(polluteType);
SetLayer(bulletType);
ChangeEffectsAnimation(polluteType);
RandomizeEffectsSpeed();
}
public void RemoveEffect(CharacterCondition condition)
{
if (effectDic == null)
{
return;
}
if (effectDic.ContainsKey(condition) == false)
{
return;
}
effectDic.Remove(condition);
}
private void SetEffect(float sustatinmentTime, CharacterCondition condition, float size = 3.5f)
{
CharacterStateEffect effect = ObjectManager.Instance.characterStatePool.GetItem();
if (effect != null)
{
effect.Initialize(sustatinmentTime, size, this.transform, condition);
effect.transform.localPosition = Vector3.zero;
effectDic.Add(condition, effect);
}
}
public void documentation_example_creates_correct_conditions()
{
var text = "[^aeiou]y";
var actual = CharacterCondition.Parse(text);
actual.Should().HaveCount(2);
actual[0].Characters.ShouldBeEquivalentTo("aeiou".ToCharArray());
actual[0].Restricted.Should().BeTrue();
actual[1].Characters.ShouldBeEquivalentTo(new[] { 'y' });
actual[1].Restricted.Should().BeFalse();
}
public void AddEffect(CharacterCondition condition, CharacterStateEffect effect)
{
if (effectDic == null)
{
return;
}
if (effectDic.ContainsKey(condition) == true)
{
return;
}
effectDic.Add(condition, effect);
}
public void Despawn()
{
if (conditionState == CharacterCondition.dead)
{
return;
}
movementState = CharacterMovement.stationary;
conditionState = CharacterCondition.dead;
puppet.SetHolding(false);
DeactivateAllEffects();
PlayerManager.Instance.DespawnPlayer(controller);
}
private void ChangeEffectsAnimation(CharacterCondition polluteType)
{
string path = string.Format("Animators/Effect/{0}", polluteType.ToString());
RuntimeAnimatorController animController = Resources.Load <RuntimeAnimatorController>(path);
if (effectList == null)
{
return;
}
for (int i = 0; i < effectList.Count; i++)
{
if (effectList[i] != null)
{
effectList[i].runtimeAnimatorController = animController;
}
}
}
private void SetPollute(CharacterCondition polluteType)
{
switch (polluteType)
{
case CharacterCondition.InFire:
{
SetColor(new Color(1f, 0f, 0f, 0.4f));
}
break;
case CharacterCondition.InPoison:
{
SetColor(new Color(0f, 1f, 0f, 0.4f));
}
break;
}
}
private void OnEnable()
{
thisTransform = this.transform;
physicsRigid = GetComponent <Rigidbody>();
physicsCollider = GetComponent <CapsuleCollider>();
puppet = visualModel.GetComponent <PlayerPuppet>();
puppet.SetOwner(this);
// Initialize skills
for (int index = 0; index < skills.Length; index++)
{
// Copy the scriptable object
skills[index] = Instantiate(skills[index]);
skills[index].RegisterTo(this);
}
previousTransformPosition = this.transform.position;
conditionState = CharacterCondition.alive;
}
