// Use this for initialization
public override bool Perform (PartyMember originator, GameObject target) {
EventQueue.AddMessage (originator.beingName + " done used taunt!");
EventQueue.AddLambda (() => {
target.GetComponent<Being>().buffs.Add (new BuffTaunt());
});
return(true);
}
public static int AddShowCombatMenu(PartyMember partyMember, int index){
ActionEvent actionEvent = new ActionEvent ();
actionEvent.combatMenu = true;
actionEvent.partyMember = partyMember;
instance.actionEvents.Insert(index, actionEvent);
return(instance.actionEvents.Count - 1);
}
// Use this for initialization
public override bool Perform (PartyMember originator, GameObject target) {
EventQueue.AddMessage (originator.beingName + " done used riposte!");
EventQueue.AddLambda (() => {
originator.buffs.Add (new BuffRiposte());
});
return(true);
}
// Use this for initialization
public override bool Perform (PartyMember originator, GameObject target) {
int damage = Random.Range (1 + originator.Strength(), 5 + originator.Strength());
EventQueue.AddMessage (originator.beingName + " attacks!");
EventQueue.AddEvent (originator.gameObject, target, damage, DamageTypes.Physical);
return(true);
}
public override void Start()
{
if (isEnemy)
thinkAction.Target = Think.ChooseTargetForEnemyPartyMember(Battle);
else
{
partyBattleLayout = null;
if (thinkAction.Type == ThinkActionType.Attack)
{
WeaponData weaponData = ResourceManager.GetWeaponData(thinkAction.OptionName);
if (weaponData != null && weaponData.WeaponUseAgainst == WeaponUseAgainst.Enemy)
{
partyBattleLayout = Battle.EnemyPartyLayout;
PotentialTarget = Battle.EnemyParty[0];
}
}
if (partyBattleLayout == null)
{
partyBattleLayout = Battle.PlayerPartyLayout;
PotentialTarget = Battle.PlayerParty[0];
}
BattleStateRenderer = new SelectTargetRenderer(this);
}
}
// Use this for initialization
public override bool Perform (PartyMember originator, GameObject target) {
EventQueue.AddMessage (originator.beingName + " done used power break!");
EventQueue.AddLambda (() => {
target.GetComponent<Being>().strengthOffset -= 5;
});
return(true);
}
public void EncounterToggleNewSelectedMember(PartyMember newMember)
{
if (selectedMember!=newMember)
OpenScreen(newMember);
else
CloseScreen();
}
// Use this for initialization
void Start () {
instance = this;
selectedPartyMember = null;
canvas = GetComponent<Canvas> ();
confirmButtonPosition = instance.transform.Find ("ConfirmLevelUp").position;
instance.transform.Find ("ConfirmLevelUp").position = new Vector3(9999, 9999, 0);
buttonList = new List<GameObject> ();
}
public void Reset(PartyMember partyMember)
{
ShudderCounter = 0;
ShudderTimer = 0.0f;
Finished = false;
if (partyMember != null)
PartyMemberStartPosition = partyMember.BattleEntity.Position;
}
public Doom(PartyMember inflictor)
{
Inflictor = inflictor;
turns = 0;
TextureData = ResourceManager.GetTextureData("particles/doom");
shudderManager = new ShudderManager(shudderCount, shudderTime);
doomParticleManager = new ParticleManager(particleTime, TextureData);
textParticleManager = null;
}
public void AddMemberToken(PartyMember member)
{
MemberMapToken newToken=Instantiate(memberTokenPrefab);
//MapRegion memberRegion=GetRegion(member.worldCoords);
//newToken.transform.SetParent(memberRegion.transform,false);
//newToken.transform.position=memberRegion.transform.position;
newToken.AssignPartyMember(member);
memberTokens.Add(member,newToken);
}
public AssignedTask(PartyMember member, AssignedTaskTypes type, System.Func<bool> check, System.Action mainAction)
{
taskType=type;
preconditionCheck=check;
actionToPerform=mainAction;
performingMember=member;
startTaskAction=null;
endTaskAction=null;
}
private void updateCurrentlySelectedPartyMember()
{
if (currentlySelectedPartyMember != battleState.PotentialTarget)
{
currentlySelectedPartyMember = battleState.PotentialTarget;
currentlySelectedPartyMember.BattleEntity.Tint = Color.White;
tintOtherPartyMembers(new Color(Color.White.ToVector3() * 0.5f));
}
}
public void AssignPartyMember(PartyMember assigned)
{
assignedMember=assigned;
nameText.text=assigned.name;
GetComponent<Image>().color=assigned.color;
MoveToken(assignedMember.currentRegion.transform);
GetComponent<Canvas>().overrideSorting=true;
GetComponent<Canvas>().sortingOrder=mySortOrder;
}
public void CloseScreen()
{
selectedMember=null;
GetComponent<Canvas>().enabled=false;
inventoryShown=false;
RecipeMakeButton.EItemMade -= RefreshInventoryItems;
InventorySlot.EItemDropped -= RefreshInventoryItems;
InventorySlot.EItemUsed -= RefreshInventoryItems;
}
// Use this for initialization
public override int Perform (PartyMember owner, GameObject attacker, int damage) {
if (UnityEngine.Random.value < 25f) {
EventQueue.AddMessage (owner.beingName + " ripostes!");
EventQueue.AddLambda (() => {
EventQueue.AddEvent (owner.gameObject, attacker, 10, DamageTypes.Physical);
});
}
return(0);
}
public HandleStatusEffects(Battle battle, StatusEffectEvent statusEffectEvent, ThinkAction thinkAction = null, PartyMember partyMember = null)
: base(battle)
{
if (thinkAction == null && partyMember == null)
throw new Exception("Either ThinkAction or PartyMember must not be null");
this.thinkAction = thinkAction;
this.partyMember = partyMember ?? thinkAction.Actor;
this.statusEffectEvent = statusEffectEvent;
}
public Task DeleteAsync(PartyMember partyMember)
{
var foundPartyMember = _context.PartyMembers.Find(partyMember.PartyId, partyMember.UserId);
if (foundPartyMember != null)
{
_context.PartyMembers.Remove(foundPartyMember);
_context.SaveChanges();
}
return Task.FromResult(0);
}
// Use this for initialization
void Start () {
instance = this;
selectedPartyMember = null;
buttonList = new List<GameObject> ();
itemList = new List<GameObject> ();
buyButton = transform.Find ("Buy").gameObject;
cancelButton = transform.Find ("Cancel").gameObject;
buyButton.SetActive (false);
cancelButton.SetActive (false);
}
public Fear(PartyMember inflictor)
{
Inflictor = inflictor;
turns = 0;
TextureData = ResourceManager.GetTextureData("particles/fear");
shudderManager = new ShudderManager(shudderCount, shudderTime);
particleManager = new ParticleManager(particleTime, TextureData);
beforeActFinished = false;
endTurnFinishedEarly = false;
}
public ActionResult Edit([Bind(Include = "FirstName,LastName,EmailAddress,PersonalBudget,ApplicationUserId")] PartyMember partyMember)
{
if (ModelState.IsValid)
{
db.Entry(partyMember).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index", "PartyMembers"));
}
return(View(partyMember));
}
//Deletes a provided PartyMember and Entity
public void deletePartyMember(PartyMember partyMember)
{
string query = "spDeletePartyMember";
SqlParameter[] parameters = new SqlParameter[2]; //Add 1 sql parameter
parameters[0] = new SqlParameter("entityID", partyMember.EntityID);
parameters[1] = new SqlParameter("partyMemberID", partyMember.PartyMemberID);
database.uploadCommand(query, parameters);
}
public ActionResult Edit(PartyMember character)
{
var editedCharacter = _characterService.EditCharacter(character);
if (editedCharacter == null)
{
return(RedirectToAction("NotFound", "ErrorHandler"));
}
return(RedirectToAction("Details", new { id = character.Id }));
}
/// <summary>
/// Initialize all the bars of the active partyMember
/// </summary>
/// <param name="pm"></param>
public void DisplayPartyMember(PartyMember pm)
{
if (this.pm != null)
{
this.pm.UnsetHPAndMPBar(GetPanelName());
}
pm.SetHPAndMPBar(GetPanelName(), HPBar, MPBar);
this.pm = pm;
}
private void OnEnable()
{
member = GameManager.party[battle.GetPlayerIndex()];
page = 0;
skillIndex = 0;
indexToMove = -1;
axisInUse = false;
ChangePointerLocation();
ChangePage();
}
/// <summary>
/// Sets the displayed candles of a partyMember
/// </summary>
/// <param name="pm"> PartyMember who's equipped gear should be displayed </param>
public void Init(PartyMember pm)
{
if (this.pmvc != null) // will be null on first open
{
if (this.pmvc.activeCandles[0] != null)
{
activeCandles[0].HideItem();
}
if (this.pmvc.activeCandles[1] != null)
{
activeCandles[1].HideItem();
}
if (this.pmvc.activeCandles[2] != null)
{
activeCandles[2].HideItem();
}
}
pmvc = pm.pmvc;
if (pmvc.activeCandles[0] != null)
{
activeCandles[0].ShowItem(pmvc.activeCandles[0]);
}
else
{
activeCandles[0].PlaceItemInstant(pm.activeCandles[0]);
}
if (pmvc.activeCandles[1] != null)
{
activeCandles[1].ShowItem(pmvc.activeCandles[1]);
}
else
{
activeCandles[1].PlaceItemInstant(pm.activeCandles[1]);
}
if (pmvc.activeCandles[2] != null)
{
activeCandles[2].ShowItem(pmvc.activeCandles[2]);
}
else
{
activeCandles[2].PlaceItemInstant(pm.activeCandles[2]);
}
if (activeCandles[0].b.interactable == true) // if the panel is not interactable, don't set the use buttons (which will be set when interactability is true)
{
SetUsables();
}
activeCandles[0].SetColour(pmvc.partyMemberColour);
activeCandles[1].SetColour(pmvc.partyMemberColour);
activeCandles[2].SetColour(pmvc.partyMemberColour);
}
/// <summary>
/// Adds a partyMember to the dead list and removes them from the alive list
/// </summary>
/// <param name="pm"> partyMember object </param>
public void RegisterPartyMemberDead(PartyMember pm)
{
if (partyMembersAlive.Contains(pm))
{
partyMembersAlive.Remove(pm);
partyMembersDead.Add(pm);
pm.RemoveAllStatusEffects();
CalculateMultipliers();
}
}
public HandleStatusEffects(Battle battle, StatusEffectEvent statusEffectEvent, ThinkAction thinkAction = null, PartyMember partyMember = null)
: base(battle)
{
if (thinkAction == null && partyMember == null)
{
throw new Exception("Either ThinkAction or PartyMember must not be null");
}
this.thinkAction = thinkAction;
this.partyMember = partyMember ?? thinkAction.Actor;
this.statusEffectEvent = statusEffectEvent;
}
public Task DeleteAsync(PartyMember partyMember)
{
var foundPartyMember = _context.PartyMembers.Find(partyMember.PartyId, partyMember.UserId);
if (foundPartyMember != null)
{
_context.PartyMembers.Remove(foundPartyMember);
_context.SaveChanges();
}
return(Task.FromResult(0));
}
void ShowCharacterInfo(PartyMember character)
{
_name.text = character.Name;
_level.text = "Lv. " + character.Level;
_strength.text = character.Strength.ToString();
_accuracy.text = character.Accuracy.ToString();
_vitality.text = character.Vitality.ToString();
_stamina.text = character.Stamina.ToString();
_speed.text = character.Speed.ToString();
_xpValues.text = "XP : " + character.CurrentXP + " / " + character.RequiredXP;
}
/// <summary>
/// Change CMP of a specific partyMember
/// </summary>
/// <param name="amount"> Positive int amount to be added </param>
public void ChangeMPSingle(PartyMember pm, int amount)
{
if (amount >= 0)
{
pm.AddMP(amount);
}
else
{
pm.LoseMP(amount);
}
}
public static void SkillActivation(Function servantNpFunction, PartyMember partyMember, List <PartyMember> party, List <EnemyMob> enemies, int enemyPosition)
{
if (IsPartyFunction(servantNpFunction)) // Target party members for buffs/debuffs
{
ApplyServantStatus.ApplyFuncTargetType(partyMember, servantNpFunction, party);
}
else if (IsEnemyFunction(servantNpFunction)) // Target enemies for buffs/debuffs
{
ApplyEnemyStatus.ApplyFuncTargetType(enemyPosition, servantNpFunction, partyMember.Servant.NpLevel, enemies);
}
}
/// <summary>
/// Similar to a revive, except for summons, it always restore the summon
/// to full health and mana, purging status effects, and may be used while the summon
/// is alive (hence not always needing to register the partyMember alive again)
/// </summary>
/// <param name="summon"></param>
public void RestoreSummon(PartyMember summon)
{
if (summon.CheckDeath() == true)
{
RegisterPartyMemberAlive(summon);
}
summon.AddHP((int)(summon.HP));
summon.AddMP((int)(summon.MP));
summon.RemoveAllStatusEffects();
summon.GetSummonBuff();
}
public bool PartyMemberHasCompletedThinkAction(PartyMember partyMember)
{
foreach (ThinkAction action in Actions)
{
if (action.Actor == partyMember)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Load the summoned partyMembers (so they don't need to be fetched from the database at runtime)
/// </summary>
public void LoadSummons()
{
foreach (string summonName in summonNames)
{
GameObject summon = Instantiate(partyMember, new Vector3(0f, 0f, 0f), Quaternion.identity);
PartyMember pmComponent = summon.GetComponent <PartyMember>();
GameManager.instance.DB.GetPartyMemberByClass(summonName, summon.GetComponent <PartyMember>());
summon.gameObject.transform.SetParent(gameObject.transform, false);
summons.Add(pmComponent);
}
}
public ActionResult Edit([Bind(Include = "Id,FirstName,LastName,EmailAddress,PersonalBudget,ApplicationUserId")] PartyMember partyMember)
{
if (ModelState.IsValid)
{
db.Entry(partyMember).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
//ViewBag.ApplicationUserId = new SelectList(db.ApplicationUsers, "Id", "Email", partyMember.ApplicationUserId);
return(View(partyMember));
}
/// <summary>
/// Adjust the NP gain to 100% if the charge reached 99% or cap the NP charge to 300%
/// </summary>
/// <param name="partyMemberTarget">Affected party member</param>
private static void PityNpGain(PartyMember partyMemberTarget)
{
if (partyMemberTarget.NpCharge == 99.0f)
{
partyMemberTarget.NpCharge++; // pity NP gain
}
else if (partyMemberTarget.NpCharge > 300.0f)
{
partyMemberTarget.NpCharge = 300.0f; // set max charge
}
}
private void OnEnable()
{
sound = Camera.main.GetComponent <SoundController>();
if (member == null)
{
member = GameManager.party[0];
}
axisInUse = false;
XpStats();
ShowMemberStats();
PopulateEquipment();
}
public void Candidate(Party party, PartyMember member)
{
var voting = party.PartyPresidentVotings.Last();
PartyPresidentCandidate candidate = new PartyPresidentCandidate()
{
Citizen = member.Citizen,
PartyPresidentVoting = voting
};
partyRepository.AddPresidentCandidate(candidate);
partyRepository.SaveChanges();
}
public async Task <IActionResult> PostPartyMember([FromBody] PartyMember partyMember)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.PartyMember.Add(partyMember);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetPartyMember", new { id = partyMember.Id }, partyMember));
}
public Character(PartyMember member)
{
foreach (Ability ability in Globals.Abilities.Where(a => a.Character == (byte)PartyMember.All))
{
Abilities.Add(ability);
}
foreach (Ability ability in Globals.Abilities.Where(a => a.Character == (byte)member))
{
Abilities.Add(ability);
}
}
public Task UpdateAsync(PartyMember partyMember)
{
var foundPartyMember = _context.PartyMembers.Find(partyMember.PartyId, partyMember.UserId);
if (foundPartyMember != null)
{
foundPartyMember.SessionId = partyMember.SessionId;
foundPartyMember.IsOwner = partyMember.IsOwner;
_context.SaveChanges();
}
return(Task.FromResult(0));
}
// Use this as your constructor
//Pass in the card object loaded from the JSON file
public void Initialise(PartyMember member)
{
//Assign all the passed-in information
cardCanvas = this.GetComponent <Canvas>();
faction = member.faction;
cardName = member.cardName;
unflippedImage = (Sprite)Resources.Load(member.unflippedSprite);
flippedImage = (Sprite)Resources.Load(member.flippedSprite);
woundsBox = (Sprite)Resources.Load(member.woundsCardSprite);
ResetCardStats(member);
}
public PartyListEntry(int memeberIndex)
{
Height = 20;
PartyMemeberIndex = memeberIndex;
PartyMember member = World.Party.Members[memeberIndex];
if (member == null || member.Serial == 0)
{
Dispose();
return;
}
//======================================================
//Name = new Label(member.Name, true, 1153, font:3);
//Name.X = 80;
string name = string.IsNullOrEmpty(member.Name) ? "<Not seen>" : member.Name;
Label name1 = World.Party.Leader == member.Serial
? new Label(name + "(L)", true, 1161, font: 3)
{
X = 80
}
: new Label(name, true, 1153, font: 3)
{
X = 80
};
Add(name1);
Mobile mobile = World.Mobiles.Get(member.Serial);
//======================================================
Add(_status = new GumpPic(240, 0, 0x29F6, (Hue)(mobile != null && mobile.IsDead ? 0 : 0x43)));
//======================================================
Button pmButton = new Button((int)Buttons.GetBar, 0xFAE, 0xFAF, 0xFB0)
{
X = 10,
ButtonAction = ButtonAction.Activate
};
Add(pmButton);
//======================================================
Button kickButton = new Button((int)Buttons.Kick, 0xFB1, 0xFB2, 0xFB3)
{
X = 40,
ButtonAction = ButtonAction.Activate
};
Add(kickButton);
}
public void AddMember(PartyMember member)
{
m_members.Add(member);
m_numMembers.Text = string.Format("{0}", m_members.Count);
m_scrollBar.UpdateDimensions(m_members.Count);
_addRemoveButtonForMember(member);
((EOGame)Game).Hud.SetStatusLabel(DATCONST2.STATUS_LABEL_TYPE_INFORMATION, member.Name, DATCONST2.STATUS_LABEL_PARTY_JOINED_YOUR);
((EOGame)Game).Hud.AddChat(ChatTabs.System, "", member.Name + " " + World.GetString(DATCONST2.STATUS_LABEL_PARTY_JOINED_YOUR), ChatType.PlayerParty, ChatColor.PM);
}
public void AddMember(PartyMember member)
{
m_members.Add(member);
m_numMembers.Text = $"{m_members.Count}";
m_scrollBar.UpdateDimensions(m_members.Count);
_addRemoveButtonForMember(member);
((EOGame)Game).Hud.SetStatusLabel(EOResourceID.STATUS_LABEL_TYPE_INFORMATION, member.Name, EOResourceID.STATUS_LABEL_PARTY_JOINED_YOUR);
((EOGame)Game).Hud.AddChat(ChatTab.System, "", member.Name + " " + OldWorld.GetString(EOResourceID.STATUS_LABEL_PARTY_JOINED_YOUR), ChatIcon.PlayerParty, ChatColor.PM);
}
/// <summary>
/// Changes the displayed text to show that a partyMember was healed by a healing attack
/// </summary>
/// <param name="pm"> PartyMember that was healed </param>
/// <param name="amount"> Amount that was healed for </param>
public void SetPMHealCritText(PartyMember pm, int amount)
{
string healedText = critHealText + " " + pm.pmName + " " + wasHealedForText + " <color=#EA323C>" + amount.ToString() + " " + HPText;
eventText.SetText(healedText);
displayedAttack = null;
if (this.colour != "normal")
{
SetColour("normal");
}
}
/// <summary>
/// Changes the displayed text to show that a partyMember recovered MP by a focus attack
/// </summary>
/// <param name="pm"> PartyMember that was healed </param>
/// <param name="amount"> Amount of MP recovered </param>
public void SetPMFocusCritText(PartyMember pm, int amount)
{
string focusText = critHealText + " " + pm.pmName + " " + restoredText + " <color=#502BFF>" + amount.ToString() + " " + MPText;
eventText.SetText(focusText);
displayedAttack = null;
if (this.colour != "normal")
{
SetColour("normal");
}
}
public void Save(PartyMember obj)
{
if (obj.Id == 0)
{
context.Entry(obj).State = System.Data.Entity.EntityState.Added;
}
else
{
context.Entry(obj).State = System.Data.Entity.EntityState.Modified;
}
context.SaveChanges();
}
// Use this for initialization
public override bool Perform (PartyMember originator, GameObject target) {
if (originator.magicPoints > 0) {
originator.magicPoints -= 1;
int damage = Random.Range (10, 20);
EventQueue.AddMessage (originator.beingName + " casts heal!");
EventQueue.AddEvent (originator.gameObject, target, -damage, DamageTypes.Physical);
return(true);
} else {
EventQueue.AddMessage ("need more mp");
return(false);
}
}
void AddExperienceOverTime(PartyMember character, float experienceToAdd)
{
if (character.Level < 20) //Sets the max level at 20
{
_xpTween.Append(DOTween.To(() => character.CurrentXP, x => character.CurrentXP = x, character.CurrentXP + experienceToAdd, 3).SetOptions(true));
//if (character.CurrentXP >= character.RequiredXP)
//{
// LevelUp(character);
//}
}
}
public AssignedTask(PartyMember member, AssignedTaskTypes type, System.Func<bool> check
, System.Action mainAction, System.Action startAction, System.Action endAction)
{
taskType=type;
preconditionCheck=check;
actionToPerform=mainAction;
performingMember=member;
if (startAction!=null) startTaskAction=startAction;
else startTaskAction=null;
if (endAction!=null) endTaskAction=endAction;
else endTaskAction=null;
}
public override void EndTurnStart(PartyMember partyMember)
{
base.EndTurnStart(partyMember);
textParticleManager = new ParticleManager(particleTime, (durationInTurns - turns).ToString(), Color.LightBlue);
if (!Inflictor.Alive)
Inflictor = null;
shudderManager.Reset(partyMember);
doomParticleManager.Reset();
textParticleManager.Reset();
}
public Task CreateAsync(PartyMember partyMember)
{
var newPartyMember = new Model.PartyMember
{
UserId = partyMember.UserId,
PartyId = partyMember.PartyId,
SessionId = partyMember.SessionId,
IsOwner = partyMember.IsOwner
};
_context.PartyMembers.Add(newPartyMember);
_context.SaveChanges();
return Task.FromResult(0);
}
public PartyMemberClass(string name, string nick, PartyMemberType type, PartyMember _enum, int health, float DR, float dps)
{
Name = name;
NickName = nick;
Type = type;
MemberEnum = _enum;
MaxHealth = health;
BaseMaxHealth = health;
Health = health;
DamageReduction = DR;
BaseDamageReduction = DR;
DPS = dps;
BaseDPS = dps;
}
public void Update(PartyMember partyMember, Delta delta)
{
particleTimer += delta.Time;
if (particleTimer >= particleTime)
{
particleTimer = 0.0f;
Rectangle boundingBox = partyMember.BattleEntity.GetBoundingBox();
float x = boundingBox.X + (boundingBox.Width / 2) + Game1.Random.Next(boundingBox.Width / 2) - (boundingBox.Width / 4);
float y = boundingBox.Y + (boundingBox.Height / 2) + (Game1.Random.Next(boundingBox.Height / 4) - (boundingBox.Height / 8));
if (textureData != null)
Scene.AddEntity(new FloatingParticle(new Vector2(x, y), new Vector2(0.0f, -200.0f), new Vector2(0.3f), 1.4f, textureData));
else if (text != null)
Scene.AddEntity(new FloatingText(text, textColor, new Vector2(x, y), 3.0f, true));
}
}
public void Update(PartyMember partyMember, Delta delta)
{
if (Finished)
return;
ShudderTimer += delta.Time;
if (ShudderTimer >= ShudderTime)
{
ShudderTimer = 0.0f;
if (++ShudderCounter > ShudderCount)
{
partyMember.BattleEntity.Position = PartyMemberStartPosition;
Finished = true;
}
}
}
public override void EndTurnUpdate(PartyMember partyMember, Delta delta)
{
base.EndTurnUpdate(partyMember, delta);
Fear.UpdateShudder(partyMember, Color.DarkRed, shudderManager, delta);
doomParticleManager.Update(Inflictor, delta);
textParticleManager.Update(partyMember, delta);
if (Inflictor.Alive && shudderManager.Finished)
{
if (++turns > durationInTurns)
{
partyMember.DoDamage(partyMember.Health, true);
Inflictor = null;
}
}
}
public void OpenScreen(Encounter newEncounter, PartyMember[] team)
{
missionOngoing = true;
GetComponent<Canvas>().enabled = true;
playedEncounter=newEncounter;
rewardDisplayer.EnableDisplayer(this,newEncounter);
roomChoiceDisplayer.EnableDisplayer(this, newEncounter);
characterManager.EnableCharacterManager(combatManager);
characterManager.SpawnMercsOnMissionStart(team);
prepManager.EnablePrepDisplayer(combatManager, characterManager, uiToggler, modeTextDisplayer);
combatCardTargeter.EnableCombatCardTargeter(combatManager, characterManager, uiToggler, modeTextDisplayer);
aiCardSelector.EnableCombatCardSelector(combatManager);
uiToggler.EnableUIToggler(this,combatManager);
combatManager.EnableCombatManager(this, characterManager, uiToggler, prepManager, modeTextDisplayer, combatCardTargeter, aiCardSelector);
ProgressThroughEncounter();
}
public static void UpdateShudder(PartyMember partyMember, Color tint, ShudderManager shudderManager, Delta delta)
{
shudderManager.Update(partyMember, delta);
if (shudderManager.Finished)
{
partyMember.BattleEntity.Tint = Color.White;
partyMember.BattleEntity.PauseAnimation = false;
}
else
{
float shudderPercentage = shudderManager.ShudderTimer / shudderManager.ShudderTime;
if (shudderManager.ShudderCounter % 2 != 0)
shudderPercentage = 1.0f - shudderPercentage;
partyMember.BattleEntity.Position = shudderManager.PartyMemberStartPosition + new Vector2(shudderPercentage * shudderDistance, 0.0f);
partyMember.BattleEntity.Tint = tint;
partyMember.BattleEntity.PauseAnimation = true;
}
}
