static void add_templates(ICreature creature)
{
// Can't add a template to a minion
if (creature.Role is Minion)
{
return;
}
// Can't add a template to a solo
ComplexRole role = creature.Role as ComplexRole;
if (role.Flag == RoleFlag.Solo)
{
return;
}
foreach (Library lib in Session.Libraries)
{
foreach (CreatureTemplate tmpl in lib.Templates)
{
EncounterCard card = new EncounterCard();
card.CreatureID = creature.ID;
card.TemplateIDs.Add(tmpl.ID);
}
}
}
public RoleForm(IRole r, ThreatType type)
{
this.InitializeComponent();
List <RoleType> roleTypes = new List <RoleType>();
switch (type)
{
case ThreatType.Creature:
{
roleTypes.Add(RoleType.Artillery);
roleTypes.Add(RoleType.Brute);
roleTypes.Add(RoleType.Controller);
roleTypes.Add(RoleType.Lurker);
roleTypes.Add(RoleType.Skirmisher);
roleTypes.Add(RoleType.Soldier);
break;
}
case ThreatType.Trap:
{
roleTypes.Add(RoleType.Blaster);
roleTypes.Add(RoleType.Lurker);
roleTypes.Add(RoleType.Obstacle);
roleTypes.Add(RoleType.Warder);
this.LeaderBox.Text = "This trap is a leader";
break;
}
}
foreach (RoleType roleType in roleTypes)
{
this.RoleBox.Items.Add(roleType);
this.MinionRoleBox.Items.Add(roleType);
}
foreach (RoleFlag value in Enum.GetValues(typeof(RoleFlag)))
{
this.ModBox.Items.Add(value);
}
Application.Idle += new EventHandler(this.Application_Idle);
this.fRole = r.Copy();
if (this.fRole is ComplexRole)
{
this.StandardBtn.Checked = true;
ComplexRole complexRole = this.fRole as ComplexRole;
this.RoleBox.SelectedItem = complexRole.Type;
this.MinionRoleBox.SelectedItem = complexRole.Type;
this.ModBox.SelectedItem = complexRole.Flag;
this.LeaderBox.Checked = complexRole.Leader;
this.HasRoleBox.Checked = false;
}
if (this.fRole is Minion)
{
this.MinionBtn.Checked = true;
Minion minion = this.fRole as Minion;
this.RoleBox.SelectedItem = minion.Type;
this.MinionRoleBox.SelectedItem = minion.Type;
this.ModBox.SelectedItem = RoleFlag.Standard;
this.LeaderBox.Checked = false;
this.HasRoleBox.Checked = minion.HasRole;
}
}
bool role_matches(IRole role_a, IRole role_b)
{
if ((role_a is ComplexRole) && (role_b is ComplexRole))
{
ComplexRole cr_a = role_a as ComplexRole;
ComplexRole cr_b = role_b as ComplexRole;
return(cr_a.Type == cr_b.Type);
}
if ((role_a is Minion) && (role_b is Minion))
{
Minion minion_a = role_a as Minion;
Minion minion_b = role_b as Minion;
if ((minion_a.HasRole == false) && (minion_b.HasRole == false))
{
return(true);
}
if ((minion_a.HasRole) && (minion_b.HasRole))
{
return(minion_a.Type == minion_b.Type);
}
return(false);
}
return(false);
}
protected override bool FoundInLibrary(Library lib, SearchResult searchResult)
{
bool duplicate = false;
SearchResultMonster srm = searchResult as SearchResultMonster;
Creature c = lib.FindCreatureCaseInsensitive(srm.Name, Convert.ToInt32(srm.Level));
if (c != null)
{
if (c.HP == 1)
{
Minion m = c.Role as Minion;
if (m.HasRole)
{
duplicate = m.Type.ToString() == srm.CombatRole;
}
}
else
{
ComplexRole cr = c.Role as ComplexRole;
duplicate = srm.CombatRole.StartsWith(cr.Type.ToString()) &&
(cr.Leader == srm.CombatRole.Contains("Leader")) &&
(cr.Flag.ToString() == srm.GroupRole);
}
}
return(duplicate);
}
private static List <Creature> get_creatures(List <Creature> creatures, int level, bool is_minion, bool is_leader, RoleType role, RoleFlag flag)
{
List <Creature> list = new List <Creature>();
foreach (Creature c in creatures)
{
if (c.Level != level)
{
continue;
}
ComplexRole cr = c.Role as ComplexRole;
Minion m = c.Role as Minion;
if ((m != null) && (!m.HasRole))
{
continue;
}
bool minion = m != null;
if (minion != is_minion)
{
continue;
}
bool leader = ((cr != null) && (cr.Leader));
if (leader != is_leader)
{
continue;
}
RoleType rt = RoleType.Blaster;
RoleFlag rf = RoleFlag.Standard;
if (cr != null)
{
rt = cr.Type;
rf = cr.Flag;
}
if (m != null)
{
rt = m.Type;
rf = RoleFlag.Standard;
}
if (rt != role)
{
continue;
}
if (rf != flag)
{
continue;
}
list.Add(c);
}
return(list);
}
private void analyse_role(IRole role)
{
ComplexRole complexRole = role as ComplexRole;
if (complexRole != null)
{
switch (this.fMode)
{
case DemographicsMode.Role:
{
this.@add(complexRole.Type.ToString());
break;
}
case DemographicsMode.Status:
{
this.@add(complexRole.Flag.ToString());
if (!complexRole.Leader)
{
break;
}
this.@add("Leader");
break;
}
}
}
Minion minion = role as Minion;
if (minion != null)
{
switch (this.fMode)
{
case DemographicsMode.Role:
{
if (!minion.HasRole)
{
break;
}
this.@add(minion.Type.ToString());
return;
}
case DemographicsMode.Status:
{
this.@add("Minion");
break;
}
default:
{
return;
}
}
}
}
void analyse_role(IRole role)
{
ComplexRole cr = role as ComplexRole;
if (cr != null)
{
switch (fMode)
{
case DemographicsMode.Role:
{
add(cr.Type.ToString());
}
break;
case DemographicsMode.Status:
{
add(cr.Flag.ToString());
if (cr.Leader)
{
add("Leader");
}
}
break;
}
}
Minion m = role as Minion;
if (m != null)
{
switch (fMode)
{
case DemographicsMode.Role:
{
if (m.HasRole)
{
add(m.Type.ToString());
}
}
break;
case DemographicsMode.Status:
{
add("Minion");
}
break;
}
}
}
public IRole GetLevelAndRoleFrom(string temp, out int level)
{
RoleType rt;
string[] tempArray = temp.Replace("Level", "").Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
level = Convert.ToInt32(tempArray[0]);
//c.Role = new ComplexRole(Enum.Parse(typeof(RoleType), Upper1(temp[1]));
IRole role;
if (temp.Contains("Minion"))
{
role = new Minion();
if (EnumUtility.TryParseEnum <RoleType>(Upper1(tempArray[2]), true, out rt))
{
(role as Minion).HasRole = true;
(role as Minion).Type = rt;
}
}
else
{
RoleFlag rf = RoleFlag.Standard;
int index = 1;
if (tempArray[1].ToLower() == "solo")
{
rf = RoleFlag.Solo;
}
if (tempArray[1].ToLower() == "elite")
{
rf = RoleFlag.Elite;
}
if (rf != RoleFlag.Standard)
{
index = 2;
}
//if (!EnumUtility.TryParse(,out rt))
//{
// throw new InvalidStructureException(" ")
//}
role = new ComplexRole((RoleType)Enum.Parse(typeof(RoleType), Upper1(tempArray[index])));
(role as ComplexRole).Leader = temp.Contains("Leader");
(role as ComplexRole).Flag = rf;
}
return(role);
}
protected void AreEqual(IRole fromMP, IRole fromDDI)
{
Assert.AreEqual(fromMP.GetType().FullName, fromDDI.GetType().FullName);
if (fromMP.GetType().ToString() == typeof(Minion).ToString())
{
Minion mp = fromMP as Minion;
Minion ddi = fromDDI as Minion;
Assert.AreEqual(mp.HasRole, ddi.HasRole);
Assert.AreEqual(mp.Type, ddi.Type);
}
else
{
ComplexRole mp = fromMP as ComplexRole;
ComplexRole ddi = fromDDI as ComplexRole;
Assert.AreEqual(mp.Flag, ddi.Flag);
Assert.AreEqual(mp.Leader, ddi.Leader);
Assert.AreEqual(mp.Type, ddi.Type);
}
}
public static int HP(int level, ComplexRole role, int constitution_score)
{
int num = 8;
if (role != null)
{
switch (role.Type)
{
case RoleType.Artillery:
case RoleType.Lurker:
{
num = 6;
break;
}
case RoleType.Brute:
{
num = 10;
break;
}
}
}
int constitutionScore = constitution_score + (level + 1) * num;
if (role != null)
{
switch (role.Flag)
{
case RoleFlag.Elite:
{
constitutionScore *= 2;
break;
}
case RoleFlag.Solo:
{
constitutionScore *= 4;
break;
}
}
}
return(constitutionScore);
}
public static int AttackBonus(DefenceType defence, int level, IRole role)
{
if (defence == DefenceType.AC)
{
return(level + 5);
}
else
{
if ((role != null) && (role is ComplexRole))
{
ComplexRole cr = role as ComplexRole;
if (cr.Type == RoleType.Soldier)
{
return(level + 5);
}
}
return(level + 3);
}
}
public bool OnNext()
{
int steps = 0;
ComplexRole role = fData.BaseCreature.Role as ComplexRole;
switch (role.Flag)
{
case RoleFlag.Elite:
steps = 1;
break;
case RoleFlag.Solo:
steps = 2;
break;
}
steps += TemplateList.CheckedItems.Count;
if (steps > 2)
{
string str = "You can not normally apply that many templates to this creature.";
str += Environment.NewLine;
str += "Are you sure you want to continue?";
DialogResult dr = MessageBox.Show(str, "Creature Builder", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (dr == DialogResult.No)
{
return(false);
}
}
// Set templates
fData.Templates.Clear();
foreach (ListViewItem lvi in TemplateList.CheckedItems)
{
fData.Templates.Add(lvi.Tag as CreatureTemplate);
}
return(true);
}
private static List <Creature> get_creatures(List <Creature> creatures, int level, bool is_minion, bool is_leader, RoleType role, RoleFlag flag)
{
List <Creature> creatures1 = new List <Creature>();
foreach (Creature creature in creatures)
{
if (creature.Level != level)
{
continue;
}
ComplexRole complexRole = creature.Role as ComplexRole;
Minion minion = creature.Role as Minion;
if (minion != null && !minion.HasRole || minion != null != is_minion)
{
continue;
}
if ((complexRole == null ? false : complexRole.Leader) != is_leader)
{
continue;
}
RoleType type = RoleType.Blaster;
RoleFlag roleFlag = RoleFlag.Standard;
if (complexRole != null)
{
type = complexRole.Type;
roleFlag = complexRole.Flag;
}
if (minion != null)
{
type = minion.Type;
roleFlag = RoleFlag.Standard;
}
if (type != role || roleFlag != flag)
{
continue;
}
creatures1.Add(creature);
}
return(creatures1);
}
public static int AC(int level, IRole role)
{
int mod = 14;
if ((role != null) && (role is ComplexRole))
{
ComplexRole cr = role as ComplexRole;
switch (cr.Type)
{
case RoleType.Artillery:
case RoleType.Brute:
mod = 12;
break;
case RoleType.Soldier:
mod = 16;
break;
}
}
return(level + mod);
}
private void OKBtn_Click(object sender, EventArgs e)
{
if (this.StandardBtn.Checked)
{
ComplexRole complexRole = new ComplexRole()
{
Type = (RoleType)this.RoleBox.SelectedItem,
Flag = (RoleFlag)this.ModBox.SelectedItem,
Leader = this.LeaderBox.Checked
};
this.fRole = complexRole;
}
if (this.MinionBtn.Checked)
{
Minion minion = new Minion()
{
HasRole = this.HasRoleBox.Checked,
Type = (RoleType)this.MinionRoleBox.SelectedItem
};
this.fRole = minion;
}
}
public static int Initiative(int level, IRole role)
{
int score = (level / 2);
if ((role != null) && (role is ComplexRole))
{
ComplexRole cr = role as ComplexRole;
switch (cr.Type)
{
case RoleType.Soldier:
score += 4;
break;
case RoleType.Skirmisher:
case RoleType.Brute:
score += 2;
break;
}
}
return(score);
}
private void OKBtn_Click(object sender, EventArgs e)
{
if (StandardBtn.Checked)
{
ComplexRole cr = new ComplexRole();
cr.Type = (RoleType)RoleBox.SelectedItem;
cr.Flag = (RoleFlag)ModBox.SelectedItem;
cr.Leader = LeaderBox.Checked;
fRole = cr;
}
if (MinionBtn.Checked)
{
Minion m = new Minion();
m.HasRole = HasRoleBox.Checked;
m.Type = (RoleType)MinionRoleBox.SelectedItem;
fRole = m;
}
}
public static int HP(int level, ComplexRole role, int constitution_score)
{
int multiplier = 8;
if (role != null)
{
switch (role.Type)
{
case RoleType.Artillery:
case RoleType.Lurker:
multiplier = 6;
break;
case RoleType.Brute:
multiplier = 10;
break;
}
}
int hp = constitution_score + ((level + 1) * multiplier);
if (role != null)
{
switch (role.Flag)
{
case RoleFlag.Elite:
hp *= 2;
break;
case RoleFlag.Solo:
hp *= 4;
break;
}
}
return(hp);
}
public static void AdjustCreatureLevel(ICreature creature, int delta)
{
// HP
if (creature.Role is ComplexRole)
{
ComplexRole role = creature.Role as ComplexRole;
int hp = 8;
switch (role.Type)
{
case RoleType.Artillery:
case RoleType.Lurker:
hp = 6;
break;
case RoleType.Brute:
hp = 10;
break;
}
switch (role.Flag)
{
case RoleFlag.Elite:
hp *= 2;
break;
case RoleFlag.Solo:
hp *= 5;
break;
}
creature.HP += hp * delta;
creature.HP = Math.Max(creature.HP, 1);
}
// Init
int init_bonus = creature.Initiative - (creature.Level / 2);
creature.Initiative = init_bonus + ((creature.Level + delta) / 2);
// Defences
creature.AC += delta;
creature.Fortitude += delta;
creature.Reflex += delta;
creature.Will += delta;
// Powers
foreach (CreaturePower cp in creature.CreaturePowers)
{
AdjustPowerLevel(cp, delta);
}
// Skills
if (creature.Skills != "")
{
// Parse string
Dictionary <string, int> skill_list = CreatureHelper.ParseSkills(creature.Skills);
// Sort
BinarySearchTree <string> bst = new BinarySearchTree <string>();
foreach (string skill_name in skill_list.Keys)
{
bst.Add(skill_name);
}
string skill_str = "";
foreach (string skill_name in bst.SortedList)
{
if (skill_str != "")
{
skill_str += ", ";
}
int mod = skill_list[skill_name];
// Apply level adjustment
int bonus = mod - (creature.Level / 2);
mod = bonus + ((creature.Level + delta) / 2);
if (mod >= 0)
{
skill_str += skill_name + " +" + mod;
}
else
{
skill_str += skill_name + " " + mod;
}
}
creature.Skills = skill_str;
}
// Level
creature.Level += delta;
}
public bool SetFilter(int level, IRole role)
{
fSuppressEvents = true;
bool set_filter = false;
if (level != 0)
{
FilterLevelToggle.Checked = true;
LevelFromBox.Value = level;
LevelToBox.Value = level;
set_filter = true;
}
if (role != null)
{
if (role is ComplexRole)
{
ComplexRole cr = role as ComplexRole;
FilterRoleToggle.Checked = true;
FilterRoleBox.SelectedItem = cr.Type;
FilterModToggle.Checked = true;
FilterModBox.SelectedItem = cr.Flag.ToString();
set_filter = true;
}
if (role is Minion)
{
Minion minion = role as Minion;
if (minion.HasRole)
{
FilterRoleToggle.Checked = true;
FilterRoleBox.SelectedItem = minion.Type;
}
FilterModToggle.Checked = true;
FilterModBox.SelectedItem = "Minion";
set_filter = true;
}
}
fSuppressEvents = false;
if (set_filter)
{
update_option_state();
OnFilterChanged();
if (!FilterPnl.Visible)
{
InfoLbl.Text = get_filter_string();
}
}
return(set_filter);
}
public bool AllowItem(object obj, out Difficulty diff)
{
diff = Difficulty.Moderate;
if (obj is ICreature)
{
ICreature c = obj as ICreature;
#region Creature
bool outlier = false;
diff = AI.GetThreatDifficulty(c.Level, fPartyLevel);
if ((diff == Difficulty.Trivial) || (diff == Difficulty.Extreme))
{
outlier = true;
}
if (outlier && FilterLevelAppropriateToggle.Checked)
{
return(false);
}
if (FilterNameToggle.Checked && (fNameTokens != null))
{
string name = c.Name.ToLower();
foreach (string token in fNameTokens)
{
if (!name.Contains(token))
{
return(false);
}
}
}
if (FilterCatToggle.Checked && (fCatTokens != null))
{
string cat = c.Category.ToLower();
foreach (string token in fCatTokens)
{
if (!cat.Contains(token))
{
return(false);
}
}
}
if (FilterRoleToggle.Checked)
{
RoleType role = (RoleType)FilterRoleBox.SelectedItem;
if (c.Role is ComplexRole)
{
ComplexRole cr = c.Role as ComplexRole;
if (cr.Type != role)
{
return(false);
}
}
if (c.Role is Minion)
{
Minion m = c.Role as Minion;
if ((!m.HasRole) || (m.Type != role))
{
return(false);
}
}
}
if (FilterModToggle.Checked)
{
RoleFlag flag = RoleFlag.Standard;
bool minion = false;
if (FilterModBox.Text == "Standard")
{
}
if (FilterModBox.Text == "Elite")
{
flag = RoleFlag.Elite;
}
if (FilterModBox.Text == "Solo")
{
flag = RoleFlag.Solo;
}
if (FilterModBox.Text == "Minion")
{
minion = true;
}
ComplexRole cr = c.Role as ComplexRole;
if (cr != null)
{
if (minion)
{
return(false);
}
if (flag != cr.Flag)
{
return(false);
}
}
Minion m = c.Role as Minion;
if (m != null)
{
if (!minion)
{
return(false);
}
}
}
if (FilterOriginToggle.Checked)
{
CreatureOrigin origin = (CreatureOrigin)FilterOriginBox.SelectedItem;
if (c.Origin != origin)
{
return(false);
}
}
if (FilterTypeToggle.Checked)
{
CreatureType type = (CreatureType)FilterTypeBox.SelectedItem;
if (c.Type != type)
{
return(false);
}
}
if (FilterKeywordToggle.Checked && (fKeyTokens != null))
{
string keywords = (c.Keywords != null) ? c.Keywords.ToLower() : "";
foreach (string token in fKeyTokens)
{
if (!keywords.Contains(token))
{
return(false);
}
}
}
if (FilterLevelToggle.Checked)
{
if ((c.Level < LevelFromBox.Value) || (c.Level > LevelToBox.Value))
{
return(false);
}
}
if (FilterSourceToggle.Checked)
{
Creature creature = c as Creature;
if (creature == null)
{
return(false);
}
Library lib = FilterSourceBox.SelectedItem as Library;
if (!lib.Creatures.Contains(creature))
{
return(false);
}
}
#endregion
return(true);
}
if (obj is CreatureTemplate)
{
CreatureTemplate ct = obj as CreatureTemplate;
#region Template
if (FilterNameToggle.Checked && (fNameTokens != null))
{
string name = ct.Name.ToLower();
foreach (string token in fNameTokens)
{
if (!name.Contains(token))
{
return(false);
}
}
}
if (FilterCatToggle.Checked && (fCatTokens != null))
{
// Ignore category for templates
}
if (FilterRoleToggle.Checked)
{
// Match on role
RoleType role = (RoleType)FilterRoleBox.SelectedItem;
if (ct.Role != role)
{
return(false);
}
}
if (FilterOriginToggle.Checked)
{
// Ignore origin for templates
}
if (FilterTypeToggle.Checked)
{
// Ignore type for templates
}
if (FilterKeywordToggle.Checked && (fKeyTokens != null))
{
// Ignore keywords for templates
}
if (FilterSourceToggle.Checked)
{
Library lib = FilterSourceBox.SelectedItem as Library;
if (!lib.Templates.Contains(ct))
{
return(false);
}
}
return(true);
}
if (obj is NPC)
{
NPC npc = obj as NPC;
bool outlier = false;
diff = AI.GetThreatDifficulty(npc.Level, fPartyLevel);
if ((diff == Difficulty.Trivial) || (diff == Difficulty.Extreme))
{
outlier = true;
}
if (outlier && FilterLevelAppropriateToggle.Checked)
{
return(false);
}
if (FilterNameToggle.Checked && (fNameTokens != null))
{
string name = npc.Name.ToLower();
foreach (string token in fNameTokens)
{
if (!name.Contains(token))
{
return(false);
}
}
}
if (FilterCatToggle.Checked && (fCatTokens != null))
{
string cat = npc.Category.ToLower();
foreach (string token in fCatTokens)
{
if (!cat.Contains(token))
{
return(false);
}
}
}
if (FilterRoleToggle.Checked)
{
// Match on role
RoleType role = (RoleType)FilterRoleBox.SelectedItem;
if (npc.Role is ComplexRole)
{
ComplexRole cr = npc.Role as ComplexRole;
if (cr.Type != role)
{
return(false);
}
}
if (npc.Role is Minion)
{
Minion m = npc.Role as Minion;
if ((!m.HasRole) || (m.Type != role))
{
return(false);
}
}
}
if (FilterOriginToggle.Checked)
{
CreatureOrigin origin = (CreatureOrigin)FilterOriginBox.SelectedItem;
if (npc.Origin != origin)
{
return(false);
}
}
if (FilterTypeToggle.Checked)
{
CreatureType type = (CreatureType)FilterTypeBox.SelectedItem;
if (npc.Type != type)
{
return(false);
}
}
if (FilterKeywordToggle.Checked && (fKeyTokens != null))
{
string keywords = (npc.Keywords != null) ? npc.Keywords.ToLower() : "";
foreach (string token in fKeyTokens)
{
if (!keywords.Contains(token))
{
return(false);
}
}
}
if (FilterLevelToggle.Checked)
{
if ((npc.Level < LevelFromBox.Value) || (npc.Level > LevelToBox.Value))
{
return(false);
}
}
#endregion
return(true);
}
if (obj is Trap)
{
Trap trap = obj as Trap;
#region Trap
bool outlier = false;
diff = AI.GetThreatDifficulty(trap.Level, fPartyLevel);
if ((diff == Difficulty.Trivial) || (diff == Difficulty.Extreme))
{
outlier = true;
}
if (outlier && FilterLevelAppropriateToggle.Checked)
{
return(false);
}
if (FilterNameToggle.Checked && (fNameTokens != null))
{
string name = trap.Name.ToLower();
foreach (string token in fNameTokens)
{
if (!name.Contains(token))
{
return(false);
}
}
}
if (FilterCatToggle.Checked && (fCatTokens != null))
{
// Ignore category for traps
}
if (FilterRoleToggle.Checked)
{
// Match on role
RoleType role = (RoleType)FilterRoleBox.SelectedItem;
if (trap.Role is ComplexRole)
{
ComplexRole cr = trap.Role as ComplexRole;
if (cr.Type != role)
{
return(false);
}
}
if (trap.Role is Minion)
{
Minion m = trap.Role as Minion;
if ((!m.HasRole) || (m.Type != role))
{
return(false);
}
}
}
if (FilterModToggle.Checked)
{
RoleFlag flag = RoleFlag.Standard;
bool minion = false;
if (FilterModBox.Text == "Standard")
{
}
if (FilterModBox.Text == "Elite")
{
flag = RoleFlag.Elite;
}
if (FilterModBox.Text == "Solo")
{
flag = RoleFlag.Solo;
}
if (FilterModBox.Text == "Minion")
{
minion = true;
}
ComplexRole cr = trap.Role as ComplexRole;
if (cr != null)
{
if (minion)
{
return(false);
}
if (flag != cr.Flag)
{
return(false);
}
}
Minion m = trap.Role as Minion;
if (m != null)
{
if (!minion)
{
return(false);
}
}
}
if (FilterOriginToggle.Checked)
{
// Ignore origin for traps
}
if (FilterTypeToggle.Checked)
{
// Ignore type for traps
}
if (FilterKeywordToggle.Checked && (fKeyTokens != null))
{
// Ignore keywords for traps
}
if (FilterLevelToggle.Checked)
{
if ((trap.Level < LevelFromBox.Value) || (trap.Level > LevelToBox.Value))
{
return(false);
}
}
if (FilterSourceToggle.Checked)
{
Library lib = FilterSourceBox.SelectedItem as Library;
if (!lib.Traps.Contains(trap))
{
return(false);
}
}
#endregion
return(true);
}
if (obj is SkillChallenge)
{
SkillChallenge sc = obj as SkillChallenge;
#region Skill challenge
if (FilterNameToggle.Checked && (fNameTokens != null))
{
string name = sc.Name.ToLower();
foreach (string token in fNameTokens)
{
if (!name.Contains(token))
{
return(false);
}
}
}
if (FilterCatToggle.Checked && (fCatTokens != null))
{
// Ignore category for skill challenges
}
if (FilterRoleToggle.Checked)
{
// Ignore roles for skill challenges
}
if (FilterOriginToggle.Checked)
{
// Ignore origin for skill challenges
}
if (FilterTypeToggle.Checked)
{
// Ignore type for skill challenges
}
if (FilterKeywordToggle.Checked && (fKeyTokens != null))
{
// Ignore keywords for skill challenges
}
if (FilterSourceToggle.Checked)
{
Library lib = FilterSourceBox.SelectedItem as Library;
if (!lib.SkillChallenges.Contains(sc))
{
return(false);
}
}
#endregion
return(true);
}
return(false);
}
public RoleForm(IRole r, ThreatType type)
{
InitializeComponent();
List <RoleType> roles = new List <RoleType>();
switch (type)
{
case ThreatType.Creature:
roles.Add(RoleType.Artillery);
roles.Add(RoleType.Brute);
roles.Add(RoleType.Controller);
roles.Add(RoleType.Lurker);
roles.Add(RoleType.Skirmisher);
roles.Add(RoleType.Soldier);
break;
case ThreatType.Trap:
roles.Add(RoleType.Blaster);
roles.Add(RoleType.Lurker);
roles.Add(RoleType.Obstacle);
roles.Add(RoleType.Warder);
LeaderBox.Text = "This trap is a leader";
break;
}
foreach (RoleType role in roles)
{
RoleBox.Items.Add(role);
MinionRoleBox.Items.Add(role);
}
foreach (RoleFlag flag in Enum.GetValues(typeof(RoleFlag)))
{
ModBox.Items.Add(flag);
}
Application.Idle += new EventHandler(Application_Idle);
fRole = r.Copy();
if (fRole is ComplexRole)
{
StandardBtn.Checked = true;
ComplexRole cr = fRole as ComplexRole;
RoleBox.SelectedItem = cr.Type;
MinionRoleBox.SelectedItem = cr.Type;
ModBox.SelectedItem = cr.Flag;
LeaderBox.Checked = cr.Leader;
HasRoleBox.Checked = false;
}
if (fRole is Minion)
{
MinionBtn.Checked = true;
Minion m = fRole as Minion;
RoleBox.SelectedItem = m.Type;
MinionRoleBox.SelectedItem = m.Type;
ModBox.SelectedItem = RoleFlag.Standard;
LeaderBox.Checked = false;
HasRoleBox.Checked = m.HasRole;
}
}
private List <string> get_advice()
{
int num = 2;
int level = this.fTrap.Level + 5;
int level1 = this.fTrap.Level + 3;
bool flag = false;
if (this.fTrap.Role is ComplexRole)
{
ComplexRole role = this.fTrap.Role as ComplexRole;
if (role.Flag == RoleFlag.Elite || role.Flag == RoleFlag.Solo)
{
flag = true;
}
}
if (flag)
{
num += 2;
level += 2;
level1 += 2;
}
List <string> strs = new List <string>()
{
"<P class=table>",
"<TABLE>",
"<TR class=heading>",
"<TD colspan=2><B>Initiative Advice</B></TD>",
"</TR>",
"<TR>",
"<TD>Initiative</TD>",
string.Concat("<TD align=center>+", num, "</TD>"),
"</TR>",
"<TR class=heading>",
"<TD colspan=2><B>Attack Advice</B></TD>",
"</TR>",
"<TR>",
"<TD>Attack vs Armour Class</TD>",
string.Concat("<TD align=center>+", level, "</TD>"),
"</TR>",
"<TR>",
"<TD>Attack vs Other Defence</TD>",
string.Concat("<TD align=center>+", level1, "</TD>"),
"</TR>",
"<TR class=heading>",
"<TD colspan=2><B>Damage Advice</B></TD>",
"</TR>"
};
if (!(this.fTrap.Role is Minion))
{
strs.Add("<TR>");
strs.Add("<TD>Damage vs Single Targets</TD>");
strs.Add(string.Concat("<TD align=center>", Statistics.Damage(this.fTrap.Level, DamageExpressionType.Normal), "</TD>"));
strs.Add("</TR>");
strs.Add("<TR>");
strs.Add("<TD>Damage vs Multiple Targets</TD>");
strs.Add(string.Concat("<TD align=center>", Statistics.Damage(this.fTrap.Level, DamageExpressionType.Multiple), "</TD>"));
strs.Add("</TR>");
}
else
{
strs.Add("<TR>");
strs.Add("<TD>Minion Damage</TD>");
strs.Add(string.Concat("<TD align=center>", Statistics.Damage(this.fTrap.Level, DamageExpressionType.Minion), "</TD>"));
strs.Add("</TR>");
}
strs.Add("<TR class=heading>");
strs.Add("<TD colspan=2><B>Skill Advice</B></TD>");
strs.Add("</TR>");
strs.Add("<TR>");
strs.Add("<TD>Easy DC</TD>");
strs.Add(string.Concat("<TD align=center>", AI.GetSkillDC(Difficulty.Easy, this.fTrap.Level), "</TD>"));
strs.Add("</TR>");
strs.Add("<TR>");
strs.Add("<TD>Moderate DC</TD>");
strs.Add(string.Concat("<TD align=center>", AI.GetSkillDC(Difficulty.Moderate, this.fTrap.Level), "</TD>"));
strs.Add("</TR>");
strs.Add("<TR>");
strs.Add("<TD>Hard DC</TD>");
strs.Add(string.Concat("<TD align=center>", AI.GetSkillDC(Difficulty.Hard, this.fTrap.Level), "</TD>"));
strs.Add("</TR>");
strs.Add("</TABLE>");
strs.Add("</P>");
return(strs);
}
List <string> get_advice()
{
int init = 2;
int attack_ac = fTrap.Level + 5;
int attack_nad = fTrap.Level + 3;
bool is_elite = false;
if (fTrap.Role is ComplexRole)
{
ComplexRole cr = fTrap.Role as ComplexRole;
if ((cr.Flag == RoleFlag.Elite) || (cr.Flag == RoleFlag.Solo))
{
is_elite = true;
}
}
if (is_elite)
{
init += 2;
attack_ac += 2;
attack_nad += 2;
}
List <string> lines = new List <string>();
lines.Add("<P class=table>");
lines.Add("<TABLE>");
lines.Add("<TR class=heading>");
lines.Add("<TD colspan=2><B>Initiative Advice</B></TD>");
lines.Add("</TR>");
lines.Add("<TR>");
lines.Add("<TD>Initiative</TD>");
lines.Add("<TD align=center>+" + init + "</TD>");
lines.Add("</TR>");
lines.Add("<TR class=heading>");
lines.Add("<TD colspan=2><B>Attack Advice</B></TD>");
lines.Add("</TR>");
lines.Add("<TR>");
lines.Add("<TD>Attack vs Armour Class</TD>");
lines.Add("<TD align=center>+" + attack_ac + "</TD>");
lines.Add("</TR>");
lines.Add("<TR>");
lines.Add("<TD>Attack vs Other Defence</TD>");
lines.Add("<TD align=center>+" + attack_nad + "</TD>");
lines.Add("</TR>");
lines.Add("<TR class=heading>");
lines.Add("<TD colspan=2><B>Damage Advice</B></TD>");
lines.Add("</TR>");
if (fTrap.Role is Minion)
{
lines.Add("<TR>");
lines.Add("<TD>Minion Damage</TD>");
lines.Add("<TD align=center>" + Statistics.Damage(fTrap.Level, DamageExpressionType.Minion) + "</TD>");
lines.Add("</TR>");
}
else
{
lines.Add("<TR>");
lines.Add("<TD>Damage vs Single Targets</TD>");
lines.Add("<TD align=center>" + Statistics.Damage(fTrap.Level, DamageExpressionType.Normal) + "</TD>");
lines.Add("</TR>");
lines.Add("<TR>");
lines.Add("<TD>Damage vs Multiple Targets</TD>");
lines.Add("<TD align=center>" + Statistics.Damage(fTrap.Level, DamageExpressionType.Multiple) + "</TD>");
lines.Add("</TR>");
}
lines.Add("<TR class=heading>");
lines.Add("<TD colspan=2><B>Skill Advice</B></TD>");
lines.Add("</TR>");
lines.Add("<TR>");
lines.Add("<TD>Easy DC</TD>");
lines.Add("<TD align=center>" + AI.GetSkillDC(Difficulty.Easy, fTrap.Level) + "</TD>");
lines.Add("</TR>");
lines.Add("<TR>");
lines.Add("<TD>Moderate DC</TD>");
lines.Add("<TD align=center>" + AI.GetSkillDC(Difficulty.Moderate, fTrap.Level) + "</TD>");
lines.Add("</TR>");
lines.Add("<TR>");
lines.Add("<TD>Hard DC</TD>");
lines.Add("<TD align=center>" + AI.GetSkillDC(Difficulty.Hard, fTrap.Level) + "</TD>");
lines.Add("</TR>");
lines.Add("</TABLE>");
lines.Add("</P>");
return(lines);
}
public static void AdjustCreatureLevel(ICreature creature, int delta)
{
if (creature.Role is ComplexRole)
{
ComplexRole role = creature.Role as ComplexRole;
int num = 8;
switch (role.Type)
{
case RoleType.Artillery:
case RoleType.Lurker:
{
num = 6;
goto case RoleType.Controller;
}
case RoleType.Blaster:
case RoleType.Controller:
{
switch (role.Flag)
{
case RoleFlag.Elite:
{
num *= 2;
break;
}
case RoleFlag.Solo:
{
num *= 5;
break;
}
}
ICreature hP = creature;
hP.HP = hP.HP + num * delta;
creature.HP = Math.Max(creature.HP, 1);
break;
}
case RoleType.Brute:
{
num = 10;
goto case RoleType.Controller;
}
default:
{
goto case RoleType.Controller;
}
}
}
int initiative = creature.Initiative - creature.Level / 2;
creature.Initiative = initiative + (creature.Level + delta) / 2;
ICreature aC = creature;
aC.AC = aC.AC + delta;
ICreature fortitude = creature;
fortitude.Fortitude = fortitude.Fortitude + delta;
ICreature reflex = creature;
reflex.Reflex = reflex.Reflex + delta;
ICreature will = creature;
will.Will = will.Will + delta;
foreach (CreaturePower creaturePower in creature.CreaturePowers)
{
CreatureHelper.AdjustPowerLevel(creaturePower, delta);
}
if (creature.Skills != "")
{
Dictionary <string, int> strs = CreatureHelper.ParseSkills(creature.Skills);
BinarySearchTree <string> binarySearchTree = new BinarySearchTree <string>();
foreach (string key in strs.Keys)
{
binarySearchTree.Add(key);
}
string str = "";
foreach (string sortedList in binarySearchTree.SortedList)
{
if (str != "")
{
str = string.Concat(str, ", ");
}
int item = strs[sortedList];
int level = item - creature.Level / 2;
item = level + (creature.Level + delta) / 2;
if (item < 0)
{
object obj = str;
object[] objArray = new object[] { obj, sortedList, " ", item };
str = string.Concat(objArray);
}
else
{
object obj1 = str;
object[] objArray1 = new object[] { obj1, sortedList, " +", item };
str = string.Concat(objArray1);
}
}
creature.Skills = str;
}
ICreature level1 = creature;
level1.Level = level1.Level + delta;
}
