private Sprite CalcIcon(IPerk perk)
{
Debug.Log(perk.Scheme.Sid);
var iconSprite = Resources.Load <Sprite>($"Icons/perks/{perk.Scheme.Sid}");
return(iconSprite);
}
public void AddPerk(IPerk perk)
{
foreach (var employee in _Employees)
{
employee.Accept(perk);
}
}
public void OnModuleItemUnequipped()
{
NWPlayer oPC = NWPlayer.Wrap(_.GetPCItemLastUnequippedBy());
NWItem oItem = NWItem.Wrap(_.GetPCItemLastUnequipped());
if (!oPC.IsPlayer)
{
return;
}
List <PCPerk> perks = _db.StoredProcedure <PCPerk>("GetPCPerksByExecutionType",
new SqlParameter("PlayerID", oPC.GlobalID),
new SqlParameter("ExecutionTypeID", (int)PerkExecutionType.EquipmentBased));
foreach (PCPerk pcPerk in perks)
{
pcPerk.Perk = _db.Perks.Single(x => x.PerkID == pcPerk.PerkID);
string jsName = pcPerk.Perk.JavaScriptName;
if (string.IsNullOrWhiteSpace(jsName))
{
continue;
}
IPerk perkAction = App.ResolveByInterface <IPerk>("Perk." + jsName);
perkAction?.OnItemUnequipped(oPC, oItem);
}
}
public void OnHitCastSpell(NWPlayer oPC)
{
NWObject oTarget = NWObject.Wrap(_.GetSpellTargetObject());
int activeWeaponSkillID = oPC.GetLocalInt("ACTIVE_WEAPON_SKILL");
if (activeWeaponSkillID <= 0)
{
return;
}
Data.Entities.Perk entity = _db.Perks.Single(x => x.PerkID == activeWeaponSkillID);
IPerk perk = App.ResolveByInterface <IPerk>("Perk." + entity.JavaScriptName);
if (perk.CanCastSpell(oPC, oTarget))
{
perk.OnImpact(oPC, oTarget);
if (oTarget.IsNPC)
{
ApplyEnmity(oPC, NWCreature.Wrap(oTarget.Object), entity);
}
}
else
{
oPC.SendMessage(perk.CannotCastSpellMessage(oPC, oTarget) ?? "That ability cannot be used at this time.");
}
oPC.DeleteLocalString("ACTIVE_WEAPON_SKILL_UUID");
oPC.DeleteLocalInt("ACTIVE_WEAPON_SKILL");
}
private bool CheckLevelCap(IPerk perk)
{
var currentLevel = perk.CurrentLevel;
if (currentLevel == null)
{
return(false);
}
var nextLevel = PerkHelper.GetNextLevel(perk.Scheme, currentLevel);
var maxLevel = perk.Scheme.Levels.Length - 1;
var nextLevelOutOfRange = nextLevel.Primary > maxLevel;
if (nextLevelOutOfRange)
{
return(true);
}
else
{
var currentSubLevelIsMax = currentLevel.Sub >= perk.Scheme.Levels[currentLevel.Primary].MaxValue;
if (currentSubLevelIsMax)
{
return(true);
}
else
{
return(false);
}
}
}
public void OnHitCastSpell(NWPlayer oPC)
{
if (!oPC.IsPlayer)
{
return;
}
NWItem oItem = NWItem.Wrap(_.GetSpellCastItem());
int type = oItem.BaseItemType;
List <PCPerk> pcPerks = _db.StoredProcedure <PCPerk>("GetPCPerksWithExecutionType",
new SqlParameter("PlayerID", oPC.GlobalID));
foreach (PCPerk pcPerk in pcPerks)
{
pcPerk.Perk = GetPerkByID(pcPerk.PerkID);
if (string.IsNullOrWhiteSpace(pcPerk.Perk.JavaScriptName) || pcPerk.Perk.ExecutionTypeID == (int)PerkExecutionType.None)
{
continue;
}
IPerk perkAction = App.ResolveByInterface <IPerk>("Perk." + pcPerk.Perk.JavaScriptName);
if (perkAction == null)
{
continue;
}
if (pcPerk.Perk.ExecutionTypeID == (int)PerkExecutionType.ShieldOnHit)
{
if (type == BASE_ITEM_SMALLSHIELD || type == BASE_ITEM_LARGESHIELD || type == BASE_ITEM_TOWERSHIELD)
{
perkAction.OnImpact(oPC, oItem);
}
}
}
}
private static Rectangle GetPerkIcon(IPerk perk)
{
if (perk.Scheme.IsBuildIn)
{
return(new Rectangle(0, 64, 32, 32));
}
return(new Rectangle(32, 64, 32, 32));
}
private static PerkLevel GetFirstOrNextLevel(IPerk perk)
{
if (perk.CurrentLevel is null)
{
// Perk is not leveled yet
return(new PerkLevel(1, 1));
}
return(PerkHelper.GetNextLevel(perk.Scheme, perk.CurrentLevel));
}
public MockHiddenTerritory(Character _character, IPerk _requiredPerk, ITile startTile)
{
character = _character;
requiredPerk = _requiredPerk;
connectedTerritories = new List <ITerritory>()
{
startTile
};
creatures = new List <ICreature>();
}
private Sprite CalcIcon(IPerk perk)
{
var iconSprite = Resources.Load <Sprite>($"Icons/perks/{perk.Scheme.Sid}");
if (iconSprite is null)
{
iconSprite = Resources.Load <Sprite>($"Icons/perks/default");
}
return(iconSprite);
}
private void ApplyCooldown(NWPlayer pc, CooldownCategory cooldown, IPerk ability)
{
float finalCooldown = ability.CooldownTime(pc, (float)cooldown.BaseCooldownTime);
int cooldownSeconds = (int)finalCooldown;
int cooldownMillis = (int)((finalCooldown - cooldownSeconds) * 100);
PCCooldown pcCooldown = _db.PCCooldowns.Single(x => x.PlayerID == pc.GlobalID && x.CooldownCategoryID == cooldown.CooldownCategoryID);
pcCooldown.DateUnlocked = DateTime.UtcNow.AddSeconds(cooldownSeconds).AddMilliseconds(cooldownMillis);
_db.SaveChanges();
}
public void ApplyCooldown(NWPlayer pc, CooldownCategory cooldown, IPerk ability)
{
float finalCooldown = ability.CooldownTime(pc, (float)cooldown.BaseCooldownTime);
int cooldownSeconds = (int)finalCooldown;
int cooldownMillis = (int)((finalCooldown - cooldownSeconds) * 100);
PCCooldown pcCooldown = _data.GetAll <PCCooldown>().Single(x => x.PlayerID == pc.GlobalID && x.CooldownCategoryID == cooldown.ID);
pcCooldown.DateUnlocked = DateTime.UtcNow.AddSeconds(cooldownSeconds).AddMilliseconds(cooldownMillis);
_data.SubmitDataChange(pcCooldown, DatabaseActionType.Update);
}
private IEnumerable <IPerk> GetPerksSafe()
{
var perks = EvolutionData?.GetArchievedPerks();
if (perks == null)
{
perks = new IPerk[0];
}
return(perks);
}
private static bool CheckLevelCap(IPerk perk)
{
var currentLevel = perk.CurrentLevel;
if (currentLevel == null)
{
return(false);
}
return(!PerkHelper.HasNextLevel(perk.Scheme, currentLevel));
}
public static string GetPerkHintText(IPerk perk)
{
var title = GetPropTitle(perk);
var description = GetPerkDescription(perk);
if (!string.IsNullOrWhiteSpace(description))
{
return($"{title}\n{new string('-', 8)}\n{description}");
}
return(title);
}
private void Update()
{
if (InputController.ConfirmAction)
{
if (inSpawningMode && currentPerkToSpawn != null)
{
IPerk perk = currentPerkToSpawn.GetComponent <IPerk>();
if (perk.Cost <= PlayerStats.Singleton.PlayerMoney)
{
PlayerStats.Singleton.DecreasePlayerMoney(perk.Cost);
Destroy(currentPerkHologram);
perk.Enable();
currentPerkToSpawn.SetActive(true);
currentPerkToSpawn.transform.parent = null;
currentPerkToSpawn = null;
inSpawningMode = false;
}
else
{
UIManager.Singleton.ShowMessage("Not enough money!!, Press [E] to cancel", 2f);
}
}
}
if (!inSpawningMode && Perks.Length > 0)
{
foreach (var perk in Perks)
{
if (Input.GetKeyDown((KeyCode)perk.PerkKey))
{
inSpawningMode = true;
currentPerkHologram = perk.HologramPrefab;
currentPerkToSpawn = perk.OriginalPrefab;
SpawnPerk(currentPerkToSpawn, false, false);
SpawnPerk(currentPerkHologram, true, true);
}
}
}
if (inSpawningMode && InputController.CancelAction)
{
inSpawningMode = false;
currentPerkToSpawn.transform.parent = null;
currentPerkHologram.transform.parent = null;
Destroy(currentPerkToSpawn);
Destroy(currentPerkHologram);
}
}
private static PerkStorageData CreatePerkStorageData(IPerk x)
{
return(new PerkStorageData
{
Sid = x.Scheme.Sid,
Level = x.CurrentLevel?.Primary,
SubLevel = x.CurrentLevel?.Sub,
Jobs = x.CurrentJobs.Select(job => new PerkJobStorageData
{
Type = job.Scheme.Type,
Scope = job.Scheme.Scope,
Progress = job.Progress,
IsComplete = job.IsComplete
}).ToArray()
});
}
/// <summary>
/// Возвращает все развитиые перки персонажа.
/// </summary>
/// <param name="evolutionData"> Модуль эволюции. </param>
/// <returns> Коллекция прокаченных перков или пустая коллекция, если перки модуля эволюции равны null. </returns>
/// <remarks>
/// Полученными перками считаются перки, которые прокачены хотя бы на один уровень.
/// </remarks>
public static IEnumerable <IPerk> GetArchievedPerks([NotNull] this IEvolutionData evolutionData)
{
if (evolutionData == null)
{
throw new ArgumentNullException(nameof(evolutionData));
}
var archievedPerks = evolutionData.Perks?.Where(x => x.CurrentLevel != null);
if (archievedPerks == null)
{
archievedPerks = new IPerk[0];
}
return(archievedPerks);
}
public void Init(IPerk perk)
{
var iconSprite = CalcIcon(perk);
IconImage.sprite = iconSprite;
if (perk.CurrentLevel != null)
{
LevelText.gameObject.SetActive(true);
LevelText.text = $"{perk.CurrentLevel.Primary} +{perk.CurrentLevel.Sub}";
}
else
{
LevelText.gameObject.SetActive(false);
}
}
public void PerkLevelUp(IPerk perk)
{
var activePerkIsValid = Perks.Contains(perk);
if (!activePerkIsValid)
{
throw new InvalidOperationException("Указанный перк не является активным для текущего актёра.");
}
var nextLevel = PerkHelper.GetNextLevel(perk.Scheme, perk.CurrentLevel);
perk.CurrentLevel = nextLevel;
UpdatePerks();
DoPerkArchieved(perk);
}
public void Run()
{
foreach (var s in spawnEvent)
{
IPerk[] perks = new IPerk[] { new Perk1(), new Perk2(), new Perk3() };
var player = spawnEvent.Get1(s).player;
if (player.perks == null)
{
player.perks = perks;
if (!player.photonView.IsMine)
{
spawnEvent.Get1(s).player.PerkEvent += PerkEvent;
}
}
}
}
public static EventCode AddPerkToEntity(this IPerk perk, ref EcsEntity entity)
{
if (perk is Perk1)
{
entity.Get <Perk1>();
return(EventCode.Perk1);
}
if (perk is Perk2)
{
entity.Get <Perk2>();
return(EventCode.Perk2);
}
if (perk is Perk3)
{
entity.Get <Perk3>();
return(EventCode.Perk3);
}
return(default);
public void OnHitCastSpell(NWPlayer oPC)
{
NWObject oTarget = NWObject.Wrap(_.GetSpellTargetObject());
int activeWeaponSkillID = oPC.GetLocalInt("ACTIVE_WEAPON_SKILL");
if (activeWeaponSkillID <= 0)
{
return;
}
Data.Entities.Perk entity = _db.Perks.Single(x => x.PerkID == activeWeaponSkillID);
IPerk perk = App.ResolveByInterface <IPerk>("Perk." + entity.JavaScriptName);
perk?.OnImpact(oPC, oTarget);
oPC.DeleteLocalString("ACTIVE_WEAPON_SKILL_UUID");
oPC.DeleteLocalInt("ACTIVE_WEAPON_SKILL");
}
private void HandleQueueWeaponSkill(NWPlayer pc, Data.Entities.Perk entity, IPerk ability)
{
string queueUUID = Guid.NewGuid().ToString();
pc.SetLocalInt("ACTIVE_WEAPON_SKILL", entity.PerkID);
pc.SetLocalString("ACTIVE_WEAPON_SKILL_UUID", queueUUID);
pc.SendMessage("Weapon skill '" + entity.Name + "' queued for next attack.");
ApplyCooldown(pc, entity.CooldownCategory, ability);
// Player must attack within 30 seconds after queueing or else it wears off.
pc.DelayCommand(() =>
{
if (pc.GetLocalString("ACTIVE_WEAPON_SKILL_UUID") == queueUUID)
{
pc.DeleteLocalInt("ACTIVE_WEAPON_SKILL");
pc.DeleteLocalString("ACTIVE_WEAPON_SKILL_UUID");
pc.SendMessage("Your weapon skill '" + entity.Name + "' is no longer queued.");
}
}, 30.0f);
}
private void ApplyEnmity(NWPlayer pc, NWCreature target, Data.Entities.Perk perk)
{
switch ((EnmityAdjustmentRuleType)perk.EnmityAdjustmentRuleID)
{
case EnmityAdjustmentRuleType.AllTaggedTargets:
_enmity.AdjustEnmityOnAllTaggedCreatures(pc, perk.Enmity);
break;
case EnmityAdjustmentRuleType.TargetOnly:
if (target.IsValid)
{
_enmity.AdjustEnmity(target, pc, perk.Enmity);
}
break;
case EnmityAdjustmentRuleType.Custom:
IPerk perkAction = App.ResolveByInterface <IPerk>("Perk." + perk.JavaScriptName);
perkAction?.OnCustomEnmityRule(pc, perk.Enmity);
break;
}
}
/// <inheritdoc />
public void PerkLevelUp(IPerk perk)
{
if (perk is null)
{
throw new ArgumentNullException(nameof(perk));
}
var activePerkIsValid = Perks.Contains(perk);
if (!activePerkIsValid)
{
throw new InvalidOperationException("Указанный перк не является активным для текущего актёра.");
}
var nextLevel = GetFirstOrNextLevel(perk);
perk.CurrentLevel = nextLevel;
UpdatePerks();
DoPerkArchieved(perk);
}
public static string GetPropTitle(IPerk perk)
{
var text = perk.Scheme.Name?.En;
var currentLanguage = Thread.CurrentThread.CurrentUICulture;
var langName = currentLanguage.TwoLetterISOLanguageName;
if (string.Equals(langName, "en", StringComparison.InvariantCultureIgnoreCase))
{
text = perk.Scheme.Name?.En;
}
else if (string.Equals(langName, "ru", StringComparison.InvariantCultureIgnoreCase))
{
text = perk.Scheme.Name?.Ru;
}
else
{
Debug.Fail(
$"Unknown language {langName} is selected. All available language must be supported in the client.");
}
return(text ?? "<Undef>");
}
public PerkEventArgs(IPerk perk)
{
Perk = perk;
}
private void DoPerkArchieved(IPerk perk)
{
var eventArgs = new PerkEventArgs(perk);
PerkLeveledUp?.Invoke(this, eventArgs);
}
protected BasePerk(IPerk <AlchemySkill> perk)
{
Perk = perk;
}
int NextPerkLevel(IPerk perk)
{
var thisKindOfPerk = perksApplied.Where(x => x.GetType() == perk.GetType());
if (thisKindOfPerk.Any())
{
return thisKindOfPerk.Max(x => x.level) + 1;
}
return 1;
}
