private static void LoadCharacter()
{
NWPlayer player = GetEnteringObject();
if (!player.IsPlayer)
{
return;
}
Player entity = GetPlayerEntity(player.GlobalID);
if (entity == null)
{
return;
}
int hp = player.CurrentHP;
int damage;
if (entity.HitPoints < 0)
{
damage = hp + Math.Abs(entity.HitPoints);
}
else
{
damage = hp - entity.HitPoints;
}
if (damage != 0)
{
ApplyEffectToObject(DurationType.Instant, EffectDamage(damage), player);
}
// Handle item stats
for (int itemSlot = 0; itemSlot < NumberOfInventorySlots; itemSlot++)
{
NWItem item = _.GetItemInSlot((InventorySlot)itemSlot, player);
PlayerStatService.CalculateEffectiveStats(player, item);
}
PlayerStatService.ApplyStatChanges(player, null);
player.IsBusy = false; // Just in case player logged out in the middle of an action.
// Cleanup code in case people log out as spaceships.
var appearance = (AppearanceType)player.Chest.GetLocalInt("APPEARANCE");
if (appearance > 0 && appearance != GetAppearanceType(player))
{
SetCreatureAppearanceType(player, appearance);
SetObjectVisualTransform(player, ObjectVisualTransform.Scale, 1.0f);
}
}
private static void OnModuleUnequipItem()
{
NWPlayer oPC = _.GetPCItemLastUnequippedBy();
if (oPC.GetLocalInt("IS_CUSTOMIZING_ITEM") == _.TRUE)
{
return; // Don't run heavy code when customizing equipment.
}
NWItem oItem = _.GetPCItemLastUnequipped();
HandleGlovesUnequipEvent();
PlayerStatService.ApplyStatChanges(oPC, oItem);
RemoveWeaponPenalties(oItem);
RemoveEquipmentPenalties(oItem);
}
private static void OnModuleEquipItem()
{
NWPlayer oPC = _.GetPCItemLastEquippedBy();
if (oPC.GetLocalInt("IS_CUSTOMIZING_ITEM") == _.TRUE)
{
return; // Don't run heavy code when customizing equipment.
}
if (!oPC.IsInitializedAsPlayer)
{
return; // Players who log in for the first time don't have an ID yet.
}
if (oPC.GetLocalInt("LOGGED_IN_ONCE") <= 0)
{
return; // Don't fire heavy calculations if this is the player's first log in after a restart.
}
NWItem oItem = _.GetPCItemLastEquipped();
PlayerStatService.ApplyStatChanges(oPC, null);
ApplyWeaponPenalties(oPC, oItem);
ApplyEquipmentPenalties(oPC, oItem);
}
public static void GiveSkillXP(NWPlayer oPC, int skillID, int xp, bool enableResidencyBonus = true)
{
if (skillID <= 0 || xp <= 0 || !oPC.IsPlayer)
{
return;
}
if (enableResidencyBonus)
{
xp = (int)(xp + xp * PlayerStatService.EffectiveResidencyBonus(oPC));
}
Player player = DataService.Get <Player>(oPC.GlobalID);
Skill skill = GetSkill(skillID);
// Check if the player has any undistributed skill ranks for this skill category.
// If they haven't been distributed yet, the player CANNOT gain XP for this skill.
var pool = DataService.SingleOrDefault <PCSkillPool>(x => x.PlayerID == oPC.GlobalID &&
x.SkillCategoryID == skill.SkillCategoryID &&
x.Levels > 0);
if (pool != null)
{
oPC.FloatingText("You must distribute all pooled skill ranks before you can gain any new XP in the '" + skill.Name + "' skill. Access this menu from the 'View Skills' section of your rest menu.");
return;
}
PCSkill pcSkill = GetPCSkill(oPC, skillID);
SkillXPRequirement req = DataService.Single <SkillXPRequirement>(x => x.SkillID == skillID && x.Rank == pcSkill.Rank);
int maxRank = skill.MaxRank;
int originalRank = pcSkill.Rank;
float xpBonusModifier = player.XPBonus * 0.01f;
// Guard against XP bonuses being too high.
if (xpBonusModifier > 0.25)
{
xpBonusModifier = 0.25f;
}
xp = CalculateTotalSkillPointsPenalty(player.TotalSPAcquired, xp);
xp = xp + (int)(xp * xpBonusModifier);
// Run the skill decay rules.
// If the method returns false, that means all skills are locked.
// So we can't give the player any XP.
if (!ApplySkillDecay(oPC, pcSkill, xp))
{
return;
}
pcSkill.XP = pcSkill.XP + xp;
oPC.SendMessage("You earned " + skill.Name + " skill experience. (" + xp + ")");
// Skill is at cap and player would level up.
// Reduce XP to required amount minus 1 XP
if (pcSkill.Rank >= maxRank && pcSkill.XP > req.XP)
{
pcSkill.XP = req.XP - 1;
}
while (pcSkill.XP >= req.XP)
{
pcSkill.XP = pcSkill.XP - req.XP;
if (player.TotalSPAcquired < SkillCap && skill.ContributesToSkillCap)
{
player.UnallocatedSP++;
player.TotalSPAcquired++;
}
pcSkill.Rank++;
oPC.FloatingText("Your " + skill.Name + " skill level increased to rank " + pcSkill.Rank + "!");
req = DataService.Single <SkillXPRequirement>(x => x.SkillID == skillID && x.Rank == pcSkill.Rank);
// Reapply skill penalties on a skill level up.
for (int slot = 0; slot < NUM_INVENTORY_SLOTS; slot++)
{
NWItem item = _.GetItemInSlot(slot, oPC.Object);
RemoveWeaponPenalties(item);
ApplyWeaponPenalties(oPC, item);
RemoveEquipmentPenalties(item);
ApplyEquipmentPenalties(oPC, item);
}
MessageHub.Instance.Publish(new SkillGainedMessage(oPC, skillID));
}
DataService.SubmitDataChange(pcSkill, DatabaseActionType.Update);
// Update player and apply stat changes only if a level up occurred.
if (originalRank != pcSkill.Rank)
{
PlayerStatService.ApplyStatChanges(oPC, null);
}
}
private static bool ApplySkillDecay(NWPlayer oPC, PCSkill levelingSkill, int xp)
{
int totalSkillRanks = GetPCTotalSkillCount(oPC);
if (totalSkillRanks < SkillCap)
{
return(true);
}
// Find out if we have enough XP to remove. If we don't, make no changes and return false signifying no XP could be removed.
var pcSkills = DataService.Where <PCSkill>(x => x.PlayerID == oPC.GlobalID && x.SkillID != levelingSkill.SkillID);
var totalXPs = pcSkills.Select(s =>
{
var reqXP = DataService.Where <SkillXPRequirement>(x => x.SkillID == s.SkillID && (x.Rank < s.Rank || x.Rank == 0 && s.XP > 0));
var totalXP = reqXP.Sum(x => x.XP);
return(new { s.SkillID, TotalSkillXP = totalXP });
}).ToList();
int aggregateXP = 0;
foreach (var p in totalXPs)
{
aggregateXP += p.TotalSkillXP;
}
if (aggregateXP < xp)
{
return(false);
}
// We have enough XP to remove. Reduce XP, picking random skills each time we reduce.
var skillsPossibleToDecay = GetAllPCSkills(oPC)
.Where(x =>
{
var skill = DataService.Get <Skill>(x.SkillID);
return(!x.IsLocked &&
skill.ContributesToSkillCap &&
x.SkillID != levelingSkill.SkillID &&
(x.XP > 0 || x.Rank > 0));
}).ToList();
// There's an edge case where players can be at the cap, but we're unable to find a skill to decay.
// In this scenario we can't go any further. Return false which will cause the GiveSkillXP method to
// bail out with no changes to XP or decayed skills.
if (skillsPossibleToDecay.Count <= 0)
{
return(false);
}
while (xp > 0)
{
int skillIndex = RandomService.Random(skillsPossibleToDecay.Count);
PCSkill decaySkill = skillsPossibleToDecay[skillIndex];
int totalDecaySkillXP = totalXPs.Find(x => x.SkillID == decaySkill.SkillID).TotalSkillXP;
int oldRank = decaySkill.Rank;
if (totalDecaySkillXP >= xp)
{
totalDecaySkillXP = totalDecaySkillXP - xp;
xp = 0;
}
else if (totalDecaySkillXP < xp)
{
totalDecaySkillXP = 0;
xp = xp - totalDecaySkillXP;
}
// If skill drops to 0 total XP, remove it from the possible list of skills
if (totalDecaySkillXP <= 0)
{
skillsPossibleToDecay.Remove(decaySkill);
decaySkill.XP = 0;
decaySkill.Rank = 0;
}
// Otherwise calculate what rank and XP value the skill should now be.
else
{
// Get the XP amounts required per level, in ascending order, so we can see how many levels we're now meant to have.
List <SkillXPRequirement> reqs = DataService.Where <SkillXPRequirement>(x => x.SkillID == decaySkill.SkillID && x.Rank <= decaySkill.Rank).OrderBy(o => o.Rank).ToList();
// The first entry in the database is for rank 0, and if passed, will raise us to 1. So start our count at 0.
int newDecaySkillRank = 0;
foreach (SkillXPRequirement req in reqs)
{
if (totalDecaySkillXP >= req.XP)
{
totalDecaySkillXP = totalDecaySkillXP - req.XP;
newDecaySkillRank++;
}
else if (totalDecaySkillXP < req.XP)
{
break;
}
}
decaySkill.Rank = newDecaySkillRank;
decaySkill.XP = totalDecaySkillXP;
}
PCSkill dbDecaySkill = new PCSkill
{
SkillID = decaySkill.SkillID,
IsLocked = decaySkill.IsLocked,
ID = decaySkill.ID,
PlayerID = decaySkill.PlayerID,
Rank = decaySkill.Rank,
XP = decaySkill.XP
};
DataService.SubmitDataChange(dbDecaySkill, DatabaseActionType.Update);
MessageHub.Instance.Publish(new SkillDecayedMessage(oPC, decaySkill.SkillID, oldRank, decaySkill.Rank));
}
PlayerStatService.ApplyStatChanges(oPC, null);
return(true);
}
public static void InitializePlayer(NWPlayer player)
{
if (player == null)
{
throw new ArgumentNullException(nameof(player));
}
if (!player.IsPlayer)
{
return;
}
// Player is initialized but not in the DB. Wipe the tag and rerun them through initialization - something went wrong before.
if (player.IsInitializedAsPlayer)
{
if (!DataService.Player.ExistsByID(player.GlobalID))
{
SetTag(player, string.Empty);
}
}
if (!player.IsInitializedAsPlayer)
{
player.DestroyAllInventoryItems();
player.InitializePlayer();
AssignCommand(player, () => _.TakeGoldFromCreature(GetGold(player), player, true));
DelayCommand(0.5f, () =>
{
GiveGoldToCreature(player, 100);
});
// Capture original stats before we level up the player.
int str = NWNXCreature.GetRawAbilityScore(player, AbilityType.Strength);
int con = NWNXCreature.GetRawAbilityScore(player, AbilityType.Constitution);
int dex = NWNXCreature.GetRawAbilityScore(player, AbilityType.Dexterity);
int @int = NWNXCreature.GetRawAbilityScore(player, AbilityType.Intelligence);
int wis = NWNXCreature.GetRawAbilityScore(player, AbilityType.Wisdom);
int cha = NWNXCreature.GetRawAbilityScore(player, AbilityType.Charisma);
// Take player to level 5 in NWN levels so that we have access to more HP slots
GiveXPToCreature(player, 10000);
for (int level = 1; level <= 5; level++)
{
LevelUpHenchman(player, player.Class1);
}
// Set stats back to how they were on entry.
NWNXCreature.SetRawAbilityScore(player, AbilityType.Strength, str);
NWNXCreature.SetRawAbilityScore(player, AbilityType.Constitution, con);
NWNXCreature.SetRawAbilityScore(player, AbilityType.Dexterity, dex);
NWNXCreature.SetRawAbilityScore(player, AbilityType.Intelligence, @int);
NWNXCreature.SetRawAbilityScore(player, AbilityType.Wisdom, wis);
NWNXCreature.SetRawAbilityScore(player, AbilityType.Charisma, cha);
NWItem knife = (CreateItemOnObject("survival_knife", player));
knife.Name = player.Name + "'s Survival Knife";
knife.IsCursed = true;
DurabilityService.SetMaxDurability(knife, 5);
DurabilityService.SetDurability(knife, 5);
NWItem book = (CreateItemOnObject("player_guide", player));
book.Name = player.Name + "'s Player Guide";
book.IsCursed = true;
NWItem dyeKit = (CreateItemOnObject("tk_omnidye", player));
dyeKit.IsCursed = true;
int numberOfFeats = NWNXCreature.GetFeatCount(player);
for (int currentFeat = numberOfFeats; currentFeat >= 0; currentFeat--)
{
NWNXCreature.RemoveFeat(player, NWNXCreature.GetFeatByIndex(player, currentFeat - 1));
}
NWNXCreature.AddFeatByLevel(player, Feat.ArmorProficiencyLight, 1);
NWNXCreature.AddFeatByLevel(player, Feat.ArmorProficiencyMedium, 1);
NWNXCreature.AddFeatByLevel(player, Feat.ArmorProficiencyHeavy, 1);
NWNXCreature.AddFeatByLevel(player, Feat.ShieldProficiency, 1);
NWNXCreature.AddFeatByLevel(player, Feat.WeaponProficiencyExotic, 1);
NWNXCreature.AddFeatByLevel(player, Feat.WeaponProficiencyMartial, 1);
NWNXCreature.AddFeatByLevel(player, Feat.WeaponProficiencySimple, 1);
NWNXCreature.AddFeatByLevel(player, Feat.UncannyDodge1, 1);
NWNXCreature.AddFeatByLevel(player, Feat.StructureManagementTool, 1);
NWNXCreature.AddFeatByLevel(player, Feat.OpenRestMenu, 1);
NWNXCreature.AddFeatByLevel(player, Feat.RenameCraftedItem, 1);
NWNXCreature.AddFeatByLevel(player, Feat.ChatCommandTargeter, 1);
foreach (var skillType in Enum.GetValues(typeof(Skill)))
{
var skill = (Skill)skillType;
if (skill == Skill.Invalid || skill == Skill.AllSkills)
{
continue;
}
NWNXCreature.SetSkillRank(player, skill, 0);
}
SetFortitudeSavingThrow(player, 0);
SetReflexSavingThrow(player, 0);
SetWillSavingThrow(player, 0);
var classType = GetClassByPosition(1, player);
for (int index = 0; index <= 255; index++)
{
NWNXCreature.RemoveKnownSpell(player, classType, 0, index);
}
Player entity = CreateDBPCEntity(player);
DataService.SubmitDataChange(entity, DatabaseActionType.Insert);
var skills = DataService.Skill.GetAll();
foreach (var skill in skills)
{
var pcSkill = new PCSkill
{
IsLocked = false,
SkillID = skill.ID,
PlayerID = entity.ID,
Rank = 0,
XP = 0
};
DataService.SubmitDataChange(pcSkill, DatabaseActionType.Insert);
}
RaceService.ApplyDefaultAppearance(player);
NWNXCreature.SetAlignmentLawChaos(player, 50);
NWNXCreature.SetAlignmentGoodEvil(player, 50);
BackgroundService.ApplyBackgroundBonuses(player);
PlayerStatService.ApplyStatChanges(player, null, true);
LanguageService.InitializePlayerLanguages(player);
DelayCommand(1.0f, () => ApplyEffectToObject(DurationType.Instant, EffectHeal(999), player));
InitializeHotBar(player);
}
}
public static void InitializePlayer(NWPlayer player)
{
if (player == null)
{
throw new ArgumentNullException(nameof(player));
}
if (player.Object == null)
{
throw new ArgumentNullException(nameof(player.Object));
}
if (!player.IsPlayer)
{
return;
}
// Player is initialized but not in the DB. Wipe the tag and rerun them through initialization - something went wrong before.
if (player.IsInitializedAsPlayer)
{
if (DataService.GetAll <Player>().SingleOrDefault(x => x.ID == player.GlobalID) == null)
{
_.SetTag(player, string.Empty);
}
}
if (!player.IsInitializedAsPlayer)
{
player.DestroyAllInventoryItems();
player.InitializePlayer();
_.AssignCommand(player, () => _.TakeGoldFromCreature(_.GetGold(player), player, 1));
_.DelayCommand(0.5f, () =>
{
_.GiveGoldToCreature(player, 100);
});
// Capture original stats before we level up the player.
int str = NWNXCreature.GetRawAbilityScore(player, ABILITY_STRENGTH);
int con = NWNXCreature.GetRawAbilityScore(player, ABILITY_CONSTITUTION);
int dex = NWNXCreature.GetRawAbilityScore(player, ABILITY_DEXTERITY);
int @int = NWNXCreature.GetRawAbilityScore(player, ABILITY_INTELLIGENCE);
int wis = NWNXCreature.GetRawAbilityScore(player, ABILITY_WISDOM);
int cha = NWNXCreature.GetRawAbilityScore(player, ABILITY_CHARISMA);
// Take player to level 5 in NWN levels so that we have access to more HP slots
_.GiveXPToCreature(player, 10000);
for (int level = 1; level <= 5; level++)
{
_.LevelUpHenchman(player, player.Class1);
}
// Set stats back to how they were on entry.
NWNXCreature.SetRawAbilityScore(player, ABILITY_STRENGTH, str);
NWNXCreature.SetRawAbilityScore(player, ABILITY_CONSTITUTION, con);
NWNXCreature.SetRawAbilityScore(player, ABILITY_DEXTERITY, dex);
NWNXCreature.SetRawAbilityScore(player, ABILITY_INTELLIGENCE, @int);
NWNXCreature.SetRawAbilityScore(player, ABILITY_WISDOM, wis);
NWNXCreature.SetRawAbilityScore(player, ABILITY_CHARISMA, cha);
NWItem knife = (_.CreateItemOnObject("survival_knife", player));
knife.Name = player.Name + "'s Survival Knife";
knife.IsCursed = true;
DurabilityService.SetMaxDurability(knife, 5);
DurabilityService.SetDurability(knife, 5);
NWItem book = (_.CreateItemOnObject("player_guide", player));
book.Name = player.Name + "'s Player Guide";
book.IsCursed = true;
NWItem dyeKit = (_.CreateItemOnObject("tk_omnidye", player));
dyeKit.IsCursed = true;
int numberOfFeats = NWNXCreature.GetFeatCount(player);
for (int currentFeat = numberOfFeats; currentFeat >= 0; currentFeat--)
{
NWNXCreature.RemoveFeat(player, NWNXCreature.GetFeatByIndex(player, currentFeat - 1));
}
NWNXCreature.AddFeatByLevel(player, FEAT_ARMOR_PROFICIENCY_LIGHT, 1);
NWNXCreature.AddFeatByLevel(player, FEAT_ARMOR_PROFICIENCY_MEDIUM, 1);
NWNXCreature.AddFeatByLevel(player, FEAT_ARMOR_PROFICIENCY_HEAVY, 1);
NWNXCreature.AddFeatByLevel(player, FEAT_SHIELD_PROFICIENCY, 1);
NWNXCreature.AddFeatByLevel(player, FEAT_WEAPON_PROFICIENCY_EXOTIC, 1);
NWNXCreature.AddFeatByLevel(player, FEAT_WEAPON_PROFICIENCY_MARTIAL, 1);
NWNXCreature.AddFeatByLevel(player, FEAT_WEAPON_PROFICIENCY_SIMPLE, 1);
NWNXCreature.AddFeatByLevel(player, FEAT_UNCANNY_DODGE_1, 1);
NWNXCreature.AddFeatByLevel(player, (int)CustomFeatType.StructureManagementTool, 1);
NWNXCreature.AddFeatByLevel(player, (int)CustomFeatType.OpenRestMenu, 1);
NWNXCreature.AddFeatByLevel(player, (int)CustomFeatType.RenameCraftedItem, 1);
NWNXCreature.AddFeatByLevel(player, (int)CustomFeatType.ChatCommandTargeter, 1);
for (int iCurSkill = 1; iCurSkill <= 27; iCurSkill++)
{
NWNXCreature.SetSkillRank(player, iCurSkill - 1, 0);
}
_.SetFortitudeSavingThrow(player, 0);
_.SetReflexSavingThrow(player, 0);
_.SetWillSavingThrow(player, 0);
int classID = _.GetClassByPosition(1, player);
for (int index = 0; index <= 255; index++)
{
NWNXCreature.RemoveKnownSpell(player, classID, 0, index);
}
Player entity = CreateDBPCEntity(player);
DataService.SubmitDataChange(entity, DatabaseActionType.Insert);
var skills = DataService.GetAll <Skill>();
foreach (var skill in skills)
{
var pcSkill = new PCSkill
{
IsLocked = false,
SkillID = skill.ID,
PlayerID = entity.ID,
Rank = 0,
XP = 0
};
DataService.SubmitDataChange(pcSkill, DatabaseActionType.Insert);
}
RaceService.ApplyDefaultAppearance(player);
NWNXCreature.SetAlignmentLawChaos(player, 50);
NWNXCreature.SetAlignmentGoodEvil(player, 50);
BackgroundService.ApplyBackgroundBonuses(player);
PlayerStatService.ApplyStatChanges(player, null, true);
LanguageService.InitializePlayerLanguages(player);
_.DelayCommand(1.0f, () => _.ApplyEffectToObject(DURATION_TYPE_INSTANT, _.EffectHeal(999), player));
InitializeHotBar(player);
}
}