protected override void OnTick()
{
if (m_Attacker.HarmfulCheck(m_Defender))
{
double damage;
if (Core.AOS)
{
damage = m_Spell.GetNewAosDamage(40, 1, 5, m_Defender);
}
else
{
damage = SpellController.GetDamage(SpellController.ExplosionDamage);
if (m_Spell.CheckResisted(m_Target))
{
damage *= 0.75;
m_Target.SendLocalizedMessage(501783); // You feel yourself resisting magical energy.
}
damage *= m_Spell.GetDamageScalar(m_Target);
}
m_Target.FixedParticles(0x36BD, 20, 10, 5044, EffectLayer.Head);
m_Target.PlaySound(0x307);
SpellHelper.Damage(m_Spell, m_Target, damage, 0, 100, 0, 0, 0);
if (m_Spell != null)
{
m_Spell.RemoveDelayedDamageContext(m_Attacker);
}
}
}
void OnSpellSwitched(SpellController newSpell)
{
if (newSpell != null)
{
newSpell.ShowSpell(true);
}
}
void Start()
{
spellController = GameObject.FindGameObjectWithTag("Player").GetComponent <SpellController>();
heatBarImage = GetComponentsInChildren <Image>()[1];
spellController.OnHeatChange = OnHeatChange;
}
new private void Start()
{
count = spellCount;
Player = GameObject.Find("Player");
animation = Player.GetComponent <Animator>();
spellController = Player.GetComponent <SpellController>();
}
public async Task CallFilterSpellsAsync_WhenCalled()
{
// Arrange
Mock <ISpellService> spellServiceMock = new Mock <ISpellService>();
Mock <IPDFService> pDFServiceMock = new Mock <IPDFService>();
Mock <IMemoryCache> memoryCacheMock = new Mock <IMemoryCache>();
string validSortOrder = string.Empty;
string validFilter = string.Empty;
int validPageNumber = 1;
int validPageSize = 10;
IPagedList <Spell> spells = new PagedList <Spell>(new List <Spell>().AsQueryable(), validPageNumber, validPageSize);
spellServiceMock.Setup(mock => mock.FilterSpellsAsync(validSortOrder, validFilter, validPageNumber, validPageSize))
.Returns(Task.FromResult(spells));
SpellController SUT = new SpellController(
spellServiceMock.Object,
pDFServiceMock.Object,
memoryCacheMock.Object);
// Act
await SUT.Filter(validSortOrder, validFilter, validPageNumber, validPageSize);
// Assert
spellServiceMock
.Verify(mock => mock.FilterSpellsAsync(validSortOrder, validFilter, validPageNumber, validPageSize),
Times.Once);
}
public async Task CallFindAsync_WhenCalled()
{
// Arrange
Mock <ISpellService> spellServiceMock = new Mock <ISpellService>();
Mock <IPDFService> pDFServiceMock = new Mock <IPDFService>();
Mock <IMemoryCache> memoryCacheMock = new Mock <IMemoryCache>();
string validId = string.Empty;
Spell validSpellResult = new Spell();
spellServiceMock.Setup(mock => mock.FindAsync(validId))
.Returns(Task.FromResult(validSpellResult));
SpellController SUT = new SpellController(
spellServiceMock.Object,
pDFServiceMock.Object,
memoryCacheMock.Object);
// Act
await SUT.Details(validId);
// Assert
spellServiceMock.Verify(mock => mock.FindAsync(validId), Times.Once);
}
public async Task ReturnCorrectViewModel_WhenCalled()
{
// Arrange
Mock <ISpellService> spellServiceMock = new Mock <ISpellService>();
Mock <IPDFService> pDFServiceMock = new Mock <IPDFService>();
Mock <IMemoryCache> memoryCacheMock = new Mock <IMemoryCache>();
string validSortOrder = string.Empty;
string validFilter = string.Empty;
int validPageNumber = 1;
int validPageSize = 10;
IPagedList <Spell> spells = new PagedList <Spell>(new List <Spell>().AsQueryable(), validPageNumber, validPageSize);
spellServiceMock.Setup(mock => mock.FilterSpellsAsync(validSortOrder, validFilter, validPageNumber, validPageSize))
.Returns(Task.FromResult(spells));
SpellController SUT = new SpellController(
spellServiceMock.Object,
pDFServiceMock.Object,
memoryCacheMock.Object);
// Act
var result = await SUT.Filter(validSortOrder, validFilter, validPageNumber, validPageSize) as PartialViewResult;
// Assert
Assert.IsInstanceOfType(result.Model, typeof(TableViewModel <SpellViewModel>));
}
public async Task ThrowApplicationException_WhenSpellsIsNull()
{
// Arrange
Mock <ISpellService> spellServiceMock = new Mock <ISpellService>();
Mock <IPDFService> pDFServiceMock = new Mock <IPDFService>();
Mock <IMemoryCache> memoryCacheMock = new Mock <IMemoryCache>();
string validSortOrder = string.Empty;
string validFilter = string.Empty;
int validPageNumber = 1;
int validPageSize = 10;
IPagedList <Spell> spells = null;
spellServiceMock.Setup(mock => mock.FilterSpellsAsync(validSortOrder, validFilter, validPageNumber, validPageSize))
.Returns(Task.FromResult(spells));
SpellController SUT = new SpellController(
spellServiceMock.Object,
pDFServiceMock.Object,
memoryCacheMock.Object);
// Act & Assert
await Assert.ThrowsExceptionAsync <ApplicationException>(() =>
SUT.Download(validSortOrder, validFilter, validPageNumber, validPageSize));
}
// Start is called before the first frame update
void Start()
{
cam = Camera.main;
motor = GetComponent <PlayerMotor>();
spellController = GetComponent <SpellController>();
stats = GetComponent <PlayerStats>();
}
// Use this for initialization
void Start () {
rb = gameObject.GetComponent<Rigidbody2D>();
moveCharacter = gameObject.GetComponent<MoveCharacter>();
weaponController = gameObject.GetComponent<WeaponController>();
spellController = gameObject.GetComponent<SpellController>();
gameObject.GetComponent<Health>().OnDeath += onDeath;
}
public void Bind()
{
if (PlayerController.instance == null)
{
return;
}
CharacterController playerInfo = PlayerController.instance?.characterController;
SpellController playerSpell = PlayerController.instance?.GetComponent <SpellController>();
WeaponController playerWeapon = PlayerController.instance?.GetComponent <WeaponController>();
if (powerBar != null)
{
powerBar.bindPowerBar(playerInfo?.energy);
}
if (healthBar != null)
{
healthBar.bindHealthBar(playerInfo?.health);
}
if (spellUI != null && playerSpell != null)
{
spellUI.bindSpellSlot(playerSpell);
}
if (weaponUI != null && playerWeapon != null)
{
weaponUI.bindWeaponSlot(playerWeapon);
}
}
public async Task ReturnCorrectViewModel_WhenCalled()
{
// Arrange
Mock <ISpellService> spellServiceMock = new Mock <ISpellService>();
Mock <IPDFService> pDFServiceMock = new Mock <IPDFService>();
Mock <IMemoryCache> memoryCacheMock = new Mock <IMemoryCache>();
string validId = string.Empty;
Spell validSpellResult = new Spell();
spellServiceMock.Setup(mock => mock.FindAsync(validId))
.Returns(Task.FromResult(validSpellResult));
SpellController SUT = new SpellController(
spellServiceMock.Object,
pDFServiceMock.Object,
memoryCacheMock.Object);
// Act
var result = await SUT.Details(validId) as ViewResult;
// Assert
Assert.IsInstanceOfType(result.Model, typeof(SpellDetailsViewModel));
}
// Switches to the given Spell index in Spell slots if the new index is a valid Spell that is different from our current one
public void SwitchToSpellIndex(SpellController SpellPrefab, int newSpellIndex)
{
if (newSpellIndex <= m_SpellSlots.Length && newSpellIndex >= 0)
{
SpellController SpellInstance = ReadySpell(SpellPrefab);
m_SpellSlots[newSpellIndex] = SpellInstance;
}
}
private void OnSpellControllerFinishedTaskList(SpellController spellController)
{
spellController.DetachPowerTaskList();
if (this.m_currentTaskList != null)
{
this.DoCurrentTaskList();
}
}
public void Start()
{
_helper = new Mock <IApiHelper>();
_helper.Setup(x => x.GetSpellData(It.IsAny <string>())).ReturnsAsync(new Models.Spell());
_classController = new ClassController(_helper.Object);
_spellController = new SpellController(_helper.Object);
_homeController = new HomeController();
}
// Use this for initialization
void Start ()
{
gameController = GameController.current;
sfx = SoundFX.current;
this.spell = "";
eventController = this.gameObject.GetComponent<EventController> ();
spellController = this.gameObject.GetComponent<SpellController> ();
}
public void Spells()
{
SpellController controller = new SpellController();
var x = controller.Details(1);
Assert.IsNotNull(x);
}
private void Awake()
{
rend = Skin.GetComponent <Renderer>();
curMats = Skin.GetComponent <Renderer>().materials;
curColor = rend.material.color;
controller = GameObject.FindGameObjectWithTag("Player").GetComponent <SpellController>();
body = GetComponent <Rigidbody>();
}
public void Target(Mobile m)
{
if (!Caster.CanSee(m))
{
Caster.SendLocalizedMessage(500237); // Target can not be seen.
}
else if (CheckHSequence(m))
{
SpellHelper.Turn(Caster, m);
SpellHelper.CheckReflect((int)this.Circle, Caster, ref m);
double damage;
if (Core.AOS)
{
damage = GetNewAosDamage(17, 1, 5, m);
}
else
{
damage = SpellController.GetDamage(SpellController.HarmDamage);
if (CheckResisted(m))
{
damage *= 0.75;
m.SendLocalizedMessage(501783); // You feel yourself resisting magical energy.
}
damage *= GetDamageScalar(m);
}
if (!m.InRange(Caster, 2))
{
damage *= 0.25; // 1/4 damage at > 2 tile range
}
else if (!m.InRange(Caster, 1))
{
damage *= 0.50; // 1/2 damage at 2 tile range
}
if (Core.AOS)
{
m.FixedParticles(0x374A, 10, 30, 5013, 1153, 2, EffectLayer.Waist);
m.PlaySound(0x0FC);
}
else
{
m.FixedParticles(0x374A, 10, 15, 5013, EffectLayer.Waist);
m.PlaySound(0x1F1);
}
SpellHelper.Damage(this, m, damage, 0, 0, 100, 0, 0);
}
FinishSequence();
}
public async Task CallFilterSpellsAsync_WhenCalled()
{
// Arrange
Mock <ISpellService> spellServiceMock = new Mock <ISpellService>();
Mock <IPDFService> pDFServiceMock = new Mock <IPDFService>();
Mock <IMemoryCache> memoryCacheMock = new Mock <IMemoryCache>();
IList <string> validFileParameters = typeof(SpellDownloadViewModel).GetProperties().Select(p => p.Name.ToString()).ToList();
string validCollection = "spells";
string validSortOrder = string.Empty;
string validFilter = string.Empty;
int validPageNumber = 1;
int validPageSize = 10;
string validFileName = string.Empty;
byte[] validFileBytes = new byte[0];
IPagedList <Spell> spells = new PagedList <Spell>(
new List <Spell>().AsQueryable(),
validPageNumber,
validPageSize);
IPagedList <SpellDownloadViewModel> spellDownloadViewModels = new PagedList <SpellDownloadViewModel>(
new List <SpellDownloadViewModel>().AsQueryable(),
validPageNumber,
validPageSize);
spellServiceMock.Setup(mock => mock.FilterSpellsAsync(validSortOrder, validFilter, validPageNumber, validPageSize))
.Returns(Task.FromResult(spells));
pDFServiceMock
.Setup(mock => mock.CreatePDF(spellDownloadViewModels, validFileParameters, validCollection))
.Returns(validFileName);
pDFServiceMock
.Setup(mock => mock.GetFileBytesAsync(validFileName))
.Returns(Task.FromResult(validFileBytes));
pDFServiceMock
.Setup(mock => mock.DeleteFile(validFileName));
SpellController SUT = new SpellController(
spellServiceMock.Object,
pDFServiceMock.Object,
memoryCacheMock.Object);
// Act
await SUT.Download(validSortOrder, validFilter, validPageNumber, validPageSize);
// Assert
spellServiceMock.Verify(mock =>
mock.FilterSpellsAsync(validSortOrder, validFilter, validPageNumber, validPageSize),
Times.Once);
}
// Use this for initialization
void Start()
{
movPhysics = this.GetComponent<DirectMovementPhysics>();
spellController = this.GetComponent<SpellController>();
stats = this.GetComponent<Stats>();
controlScheme = ControlManager.GetControlScheme(1);
//Spells = new List<ISpellBase>();
//Actions = new List<Action>();
}
private void CmdSpawnSpell(string effectName, string spellName)
{
GameObject go = Instantiate(Resources.Load <GameObject>(spellName), SpellSpawn.transform.position, gameObject.transform.rotation);
SpellController sc = go.GetComponent <SpellController>();
sc.damage = 20;
sc.effectName = effectName;
NetworkServer.Spawn(go);
Destroy(go, 5.0f);
}
public float CastableShots(int spellIndex)
{
SpellController spell = m_SpellSlots[spellIndex];
if (spell.CanShoot())
{
return(spell.GetCurrentAmmo());
}
return(0);
}
// Use this for initialization
void Start()
{
movPhysics = this.GetComponent <DirectMovementPhysics>();
spellController = this.GetComponent <SpellController>();
stats = this.GetComponent <Stats>();
controlScheme = ControlManager.GetControlScheme(1);
//Spells = new List<ISpellBase>();
//Actions = new List<Action>();
}
void CastSpell()
{
spellClone = Instantiate(selectedSpell, transform.position, Quaternion.identity) as GameObject;
SpellController spellController = spellClone.GetComponent <SpellController>();
spellController.startPosition = new Vector3(transform.position.x, transform.position.y, transform.position.z + 0.4f);
spellController.startDirection = transform.up;
spellClone.SetActive(true);
}
public bool CastSpell(int spellIndex)
{
print(string.Format("casting spell : {0}", spellIndex));
SpellController spell = m_SpellSlots[spellIndex];
return(spell.HandleShootInputs(
true, // down
true, // hold
true)); //release
}
void CmdShootSpell()
{
GameObject go = Instantiate(spell);
SpellController sc = go.GetComponent <SpellController>();
sc.damage = 20;
go.transform.position = spellSpawn.transform.position;
NetworkServer.Spawn(go);
Destroy(go, 5.0f);
}
private Animator anim; //!< Animator controller
/*!
* Instantiates member values
*/
void Start()
{
anim = GetComponent <Animator>();
gamecontroller = GameObject.FindGameObjectWithTag("GameController").GetComponent <GameController>();
//cursor = GameObject.FindGameObjectWithTag("Cursor");
mainCam = GameObject.FindGameObjectWithTag("MainCamera").GetComponent <Camera>();
spellUI = GameObject.FindGameObjectWithTag("SpellController").GetComponent <SpellController>();
uic = GameObject.FindGameObjectWithTag("UIController").GetComponent <UIController>();
timeHeld = 0.0;
}
void Start()
{
agent = GetComponent <NavMeshAgent>();
anim = transform.GetComponentInChildren <Animator>();
attackspeed = (1 / hero.attackSpeed);
rb = GetComponent <Rigidbody>();
spellController = GetComponent <SpellController>();
GameObject go = GameObject.Find("MainCanvas");
HUD = go.GetComponent <MainHUDScreen>();
}
// Switches to the given Spell index in Spell slots if the new index is a valid Spell that is different from our current one
public void SwitchToSpellIndex(SpellController SpellPrefab, int newSpellIndex)
{
if (newSpellIndex <= 4 && newSpellIndex >= 0)
{
SpellController SpellInstance = ReadySpell(SpellPrefab);
m_SpellSlots[newSpellIndex] = SpellInstance;
if (onSwitchedToSpell != null)
{
onSwitchedToSpell.Invoke(SpellInstance);
}
}
}
private void Awake()
{
anim = GameObject.FindGameObjectWithTag("Hand").GetComponent <Animator>();
if (instance == null)
{
instance = this;
}
else
{
Destroy(gameObject);
}
}
public void Target(Mobile m)
{
if (!Caster.CanSee(m))
{
Caster.SendLocalizedMessage(500237); // Target can not be seen.
}
else if (m.IsDeadBondedPet)
{
Caster.SendLocalizedMessage(1060177); // You cannot heal a creature that is already dead!
}
else if (m is BaseCreature && ((BaseCreature)m).IsAnimatedDead)
{
Caster.SendLocalizedMessage(1061654); // You cannot heal that which is not alive.
}
else if (m is Golem)
{
Caster.LocalOverheadMessage(MessageType.Regular, 0x3B2, 500951); // You cannot heal that.
}
else if (m.Poisoned || Server.Items.MortalStrike.IsWounded(m))
{
Caster.LocalOverheadMessage(MessageType.Regular, 0x22, (Caster == m) ? 1005000 : 1010398);
}
else if (CheckBSequence(m))
{
SpellHelper.Turn(Caster, m);
int toHeal;
if (Core.AOS)
{
toHeal = Caster.Skills.Magery.Fixed / 120;
toHeal += Utility.RandomMinMax(1, 4);
if (Core.SE && Caster != m)
{
toHeal = (int)(toHeal * 1.5);
}
}
else
{
toHeal = (int)(Caster.Skills[SkillName.Magery].Value * 0.1);
toHeal += SpellController.GetDamage(SpellController.HealDamage);
}
m.Heal(toHeal);
m.FixedParticles(0x376A, 9, 32, 5005, EffectLayer.Waist);
m.PlaySound(0x1F2);
}
FinishSequence();
}
public bool HasSpell(SpellController SpellPrefab)
{
// Checks if we already have a Spell coming from the specified prefab
foreach (var w in m_SpellSlots)
{
if (w != null && w.sourcePrefab == SpellPrefab.gameObject)
{
return(true);
}
}
return(false);
}