public static short GetHitPointsMax(NWN2CreatureTemplate creature)
 {
     int newHP = CalcMaxHitpointsFromHitDice(creature);
     newHP += creature.GetStatsCore().CalcHitPointModsFromFeats(1);
     newHP += CalcHitPointModsFromStats(creature);
     return (short)newHP;
 }
        public void setFocus(NWN2CreatureTemplate creature)
        {
            if (creature == null)
            {
                Text = "ACR Creature Editor";
                propMain.SelectedObject = null;
                selection.SetSelection(null);
                propMain.Refresh();
                propACR.Refresh();
            }

            // Update main property sheet.
            if (creature.GetType() == typeof(NWN2CreatureBlueprint))
            {
                Text = "ACR Creature Editor: " + ((NWN2CreatureBlueprint)creature).ResourceName.Value;
                propMain.SelectedObject = (NWN2CreatureBlueprint)creature;
            }
            else if (creature.GetType() == typeof(NWN2CreatureInstance))
            {
                Text = "ACR Creature Editor: " + ((NWN2CreatureInstance)creature).Template.ResRef.Value + " (instance)";
                propMain.SelectedObject = (NWN2CreatureInstance)creature;
            }
            else
            {
                propMain.SelectedObject = creature;
            }

            // Update ACR property sheet.
            selection.SetSelection(creature);

            propMain.Refresh();
            propACR.Refresh();
        }
 public static bool GetIsUndead(NWN2CreatureTemplate creature)
 {
     if (creature.Variables.GetVariable("ACR_CRE_ISUNDEAD").ValueInt == 1) return true;
     if (creature.Variables.GetVariable("ACR_CRE_ISUNDEAD").ValueInt == 2) return false;
     if (creature.Race.Row == 24) return true;
     if (creature.GetStatsCore().GetHasClass(19) == 1) return true;
     return false;
 }
 public static bool GetIsConstruct(NWN2CreatureTemplate creature)
 {
     if (creature.Variables.GetVariable("ACR_CRE_ISCONSTRUCT").ValueInt == 1) return true;
     if (creature.Variables.GetVariable("ACR_CRE_ISCONSTRUCT").ValueInt == 2) return false;
     if (creature.Race.Row == 10) return true;
     if (creature.GetStatsCore().GetHasClass(13) == 1) return true;
     return false;
 }
        public static short GetHitPointsPNP(NWN2CreatureTemplate creature)
        {
            int maxHP = CalcMaxHitpointsFromHitDice(creature) / 2;

            int newHP = (int)((float)maxHP / (float)creature.GetStatsCore().GetLevel() / 2);
            newHP += creature.GetStatsCore().CalcHitPointModsFromFeats(1);
            newHP += CalcHitPointModsFromStats(creature);
            return (short)newHP;
        }
        public static void SetCreatureHitPoints(NWN2CreatureTemplate creature, HPType hpType)
        {
            // Check for blacklisting.
            if (creature.Variables.GetVariable("ABP_SETHP_OVERRIDE").ValueInt > 0) hpType = (CreatureHelper.HPType)creature.Variables.GetVariable("ABP_SETHP_OVERRIDE").ValueInt;
            if (hpType == CreatureHelper.HPType.Ignore) return;

            // Find the new HP.
            short newHP = 0;
            switch (hpType)
            {
                case CreatureHelper.HPType.PenAndPaper: newHP = CreatureHelper.GetHitPointsPNP(creature); break;
                case CreatureHelper.HPType.Maximum: newHP = CreatureHelper.GetHitPointsMax(creature); break;
                default: return;
            }

            // And set it.
            creature.BaseHitPoints = newHP;
            creature.CurrentHitPoints = newHP;
            creature.CharsheetHitPoints = newHP;
        }
 public void SetSelection(NWN2CreatureTemplate cre)
 {
     creature = cre;
 }
Example #8
0
//		/ <summary>
//		/ Creates an ObjectBlock representing a given instance.
//		/ </summary>
//		/ <param name="instance">The instance to represent.</param>
//		/ <param name="instance">The area holding this instance.</param>
//		/ <returns>An ObjectBlock representing the given instance.</returns>
//		/ <remarks>The Area property of an instance is sometimes null, even if
//		/ the area has not actually been disposed. For this reason, CreateInstanceBlock
//		/ has an overload which allows you to pass in the holding area directly.</remarks>


        protected string GetDisplayName(INWN2Template template)
        {
            if (template == null)
            {
                throw new ArgumentNullException("template");
            }

            string displayName = null;

            if (template is NWN2CreatureTemplate)
            {
                NWN2CreatureTemplate creature = (NWN2CreatureTemplate)template;

                string firstName = creature.FirstName.GetSafeString(OEIShared.Utils.BWLanguages.CurrentLanguage).Value;
                string lastName  = creature.LastName.GetSafeString(OEIShared.Utils.BWLanguages.CurrentLanguage).Value;

                if (String.IsNullOrEmpty(lastName))
                {
                    displayName = firstName;
                }
                else
                {
                    displayName = String.Format("{0} {1}", firstName, lastName);
                }
            }

            else
            {
                // Everything else uses LocalizedName, but this isn't defined on a superclass.
                PropertyInfo property = template.GetType().GetProperty("LocalizedName", BindingFlags.Public | BindingFlags.Instance);

                if (property != null)
                {
                    object obj = property.GetValue(template, null);

                    if (obj != null)
                    {
                        displayName = obj.ToString();

                        if (!String.IsNullOrEmpty(displayName))
                        {
                            // Remove surrounding curly brackets from (almost all) doors:
                            if (displayName.StartsWith("{") && displayName.EndsWith("}"))
                            {
                                displayName = displayName.Substring(1, displayName.Length - 2);
                            }
                            // Remove surrounding quotes and commas from placed effects:
                            if (displayName.StartsWith("\"") && displayName.EndsWith("\", "))
                            {
                                displayName = displayName.Substring(1, displayName.Length - 4);
                            }
                        }
                    }
                }
            }

            if (displayName != null)
            {
                return(displayName);
            }
            else
            {
                return(String.Empty);
            }
        }
 public static int CalcHitPointModsFromStats(NWN2CreatureTemplate creature)
 {
     if (GetIsUndead(creature)) return 0;
     if (GetIsConstruct(creature)) return 0;
     return creature.GetStatsCore().CalcHitPointModsFromStats();
 }
 public static int CalcMaxHitpointsFromHitDice(NWN2CreatureTemplate creature)
 {
     if (GetIsUndead(creature)) return creature.GetStatsCore().GetLevel() * 12;
     return creature.GetStatsCore().CalcMaxHitpointsFromHitDice();
 }
 public static void SetCreatureBehaviorType(NWN2CreatureTemplate creature, string behavior)
 {
     creature.Variables.GetVariable("ACR_CREATURE_BEHAVIOR").ValueString = behavior;
 }
        private void Validate(NWN2CreatureTemplate creature, string reference)
        {
            try
            {
                // Check for invalid factions.
                if (creature.FactionID == NWN2Faction.INVALID_FACTION_ID)
                {
                    log.WriteLine("ERROR: Creature \"{0}\" has an invalid faction.", reference);
                }

                // Check for common perception range problems.
                if (creature.PerceptionRange.Row != 17 && creature.PerceptionRange.Row != 18)
                {
                    log.WriteLine("WARNING: Creature \"{0}\" has a non-standard perception range. Use a suggested value of Player-5 or Player-10.", reference);
                }

                // Check for a walk rate equal to players.
                if (creature.WalkRate.Row == 0 || creature.WalkRate.Row == 19)
                {
                    log.WriteLine("WARNING: Creature \"{0}\" has a walk rate equal to players. This creature will have infinite attacks of opportunity against retreating PCs.", reference);
                }

                // Check default scripts.
                EnforceNonDefaultScript(reference, creature.OnBlocked, "acf_cre_onblocked", new string[] { "", "nw_c2_defaulte" });
                EnforceNonDefaultScript(reference, creature.OnConversation, "acf_cre_onconversation", new string[] { "", "nw_c2_default4" });
                EnforceNonDefaultScript(reference, creature.OnDamaged, "acf_cre_ondamaged", new string[] { "", "nw_c2_default6" });
                EnforceNonDefaultScript(reference, creature.OnDeath, "acf_cre_ondeath", new string[] { "", "nw_c2_default7" });
                EnforceNonDefaultScript(reference, creature.OnEndCombatRound, "acf_cre_onendcombatround", new string[] { "", "nw_c2_default3" });
                EnforceNonDefaultScript(reference, creature.OnHeartbeat, "acf_cre_onheartbeat", new string[] { "", "nw_c2_default1" });
                EnforceNonDefaultScript(reference, creature.OnInventoryDisturbed, "acf_cre_onheartbeat", new string[] { "", "nw_c2_default8" });
                EnforceNonDefaultScript(reference, creature.OnPerception, "acf_cre_onperception", new string[] { "", "nw_c2_default2" });
                EnforceNonDefaultScript(reference, creature.OnPhysicalAttacked, "acf_cre_onphysicallyattacked", new string[] { "", "nw_c2_default5" });
                EnforceNonDefaultScript(reference, creature.OnRested, "acf_cre_onrested", new string[] { "", "nw_c2_defaulta" });
                EnforceNonDefaultScript(reference, creature.OnSpawnIn, "acf_cre_onspawnin", new string[] { "", "nw_c2_default9" });
                EnforceNonDefaultScript(reference, creature.OnSpellCastAt, "acf_cre_onspellcastat", new string[] { "", "nw_c2_defaultb" });
                EnforceNonDefaultScript(reference, creature.OnUserDefined, "acf_cre_onuserdefined", new string[] { "", "nw_c2_defaultd" });
            }
            catch (Exception exception)
            {
                log.WriteLine("EXCEPTION: Error while handling \"{0}\":\n{1}", reference, exception.Message);
            }
        }