public NPC SpawnNPC(GridSpace g, GenericFlags <SpawnKeywords> keywords)
{
LeveledPool <NPC> pool = GetPool(keywords);
NPC n;
if (!pool.Get(Probability.SpawnRand, out n, BigBoss.Player.Level))
{
throw new ArgumentException("NPC Pool was empty for keywords: " + keywords);
}
return(SpawnNPC(g, n));
}
public override void ParseXML(XMLNode x)
{
base.ParseXML(x);
Attributes = x.Select <AttributesData>("attributes");
Stats = x.Select <Stats>("stats");
Flags = new GenericFlags <NPCFlags>(x.SelectEnums <NPCFlags>("flags"));
SpawnKeywords = new GenericFlags <SpawnKeywords>(x.SelectEnums <SpawnKeywords>("spawnkeywords"));
KnownSpells = x.Select <Spells>("spells");
StartingItems = x.Select <StartingItems>("startingitems");
Equipment = x.Select <Equipment>("equipslots");
NaturalWeapon = x.Select <Item>("naturalweapon");
//parse AI packages
}
private static void LoadBasicStats(Player player)
{
AttributesData attr = new AttributesData();
attr.Constitution = 14;
attr.Charisma = 12;
attr.Wisdom = 9;
attr.Dexterity = 17;
attr.Intelligence = 16;
attr.Strength = 16;
attr.Size = Size.MEDIUM;
player.Attributes = attr;
Stats stats = new Stats();
//stats.MaxHealth = 100;
stats.MaxPower = 50;
stats.Level = 1;
stats.initialize();
stats.Hunger = 900;
player.Stats = stats;
GenericFlags <NPCFlags> flags = new GenericFlags <NPCFlags>();
flags[NPCFlags.NOPOLY] = true;
flags[NPCFlags.NO_RANDOM_SPAWN] = true;
player.Flags = flags;
player.PlayerTitle = BigBoss.Objects.PlayerProfessions.getTitle(player.PlayerChosenProfession, player.Stats.Level);
player.IsActive = true;
Equipment equipment = new Equipment();
player.Equipment = equipment;
equipment.AddSlot(EquipType.BODY);
equipment.AddSlot(EquipType.FEET);
equipment.AddSlot(EquipType.HAND, 2);
equipment.AddSlot(EquipType.HEAD);
equipment.AddSlot(EquipType.LEGS);
equipment.AddSlot(EquipType.NECK);
equipment.AddSlot(EquipType.RING, 2);
equipment.AddSlot(EquipType.SHIRT);
player.Name = "Kurtis";
foreach (KeyValuePair <string, Spell> kvp in BigBoss.Objects.PlayerSpells)
{
player.KnownSpells.Add(kvp.Key, kvp.Value);
}
}
public override bool Equals(object obj)
{
GenericFlags <T> rhs = obj as GenericFlags <T>;
if (rhs == null)
{
return(false);
}
if (_set.Count != rhs._set.Count)
{
return(false);
}
return(_set.IsSubsetOf(rhs._set));
}
private HandlerBlock CreateHandlerBlock(IMethod method, IMethodContext context, IInstructionList code, SEHBlock block)
{
switch (block.Type)
{
case SEHFlags.Catch:
{
int token = block.Value;
var type = context.ResolveType(method, token);
if (!HasGenericExceptions && type.IsGenericContext())
{
_genericFlags |= GenericFlags.HasGenericExceptions;
}
var h = new HandlerBlock(BlockType.Catch)
{
ExceptionType = type
};
return(h);
}
case SEHFlags.Filter:
{
var h = new HandlerBlock(BlockType.Filter)
{
FilterIndex = code.GetOffsetIndex(block.Value)
};
return(h);
}
case SEHFlags.Finally:
return(new HandlerBlock(BlockType.Finally));
case SEHFlags.Fault:
return(new HandlerBlock(BlockType.Fault));
default:
throw new IndexOutOfRangeException();
}
}
private ILStream ReadCode(IMethod method, IMethodContext context, BufferedBinaryReader reader, int codeSize)
{
var list = new ILStream();
var startPos = reader.Position;
int offset = 0;
while (offset < codeSize)
{
var pos = reader.Position;
var instr = ReadInstruction(method, context, reader, startPos);
var size = reader.Position - pos;
offset += (int)size;
instr.Index = list.Count;
list.Add(instr);
if (!HasGenericInstructions && instr.IsGenericContext)
{
_genericFlags |= GenericFlags.HasGenericInstructions;
}
}
return(list);
}
protected LeveledPool <NPC> GetPool(GenericFlags <SpawnKeywords> keywords)
{
LeveledPool <NPC> pool;
if (!npcPools.TryGetValue(keywords, out pool))
{
#region DEBUG
if (BigBoss.Debug.logging(Logs.NPCs))
{
BigBoss.Debug.printHeader(Logs.NPCs, "Get Pool");
BigBoss.Debug.w(Logs.NPCs, "Keywords:");
BigBoss.Debug.incrementDepth(Logs.NPCs);
keywords.ToLog(Logs.NPCs);
BigBoss.Debug.decrementDepth(Logs.NPCs);
}
#endregion
pool = new LeveledPool <NPC>(DefaultLevelCurve);
npcPools.Add(keywords, pool);
foreach (NPC n in BigBoss.Objects.NPCs.Prototypes)
{
if (!keywords.Empty && n.SpawnKeywords.Contains(keywords) || // NPC has keywords
(keywords.Empty && !n.Flags[NPCFlags.NO_RANDOM_SPAWN])) // If keywords empty
{
pool.Add(n);
}
}
#region DEBUG
if (BigBoss.Debug.logging(Logs.NPCs))
{
pool.ToLog(Logs.NPCs, "NPCs");
BigBoss.Debug.printFooter(Logs.NPCs, "Get Pool");
}
#endregion
}
return(pool);
}
public virtual void Init()
{
_roomMods = new RoomModCollection();
KeywordFlags = new GenericFlags <SpawnKeywords>(Keywords);
}
public bool Contains(GenericFlags <T> rhs)
{
return(rhs._set.IsSubsetOf(_set));
}
public MethodBody(IMethod method, IMethodContext context, BufferedBinaryReader reader)
{
if (method == null)
{
throw new ArgumentNullException("method");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
if (reader == null)
{
throw new ArgumentNullException("reader");
}
_method = method;
int lsb = reader.ReadUInt8();
var flags = (MethodBodyFlags)lsb;
_maxStackSize = 8;
var format = flags & MethodBodyFlags.FormatMask;
List <SEHBlock> sehBlocks = null;
switch (format)
{
case MethodBodyFlags.FatFormat:
{
byte msb = reader.ReadUInt8();
int dwordMultipleSize = (msb & 0xF0) >> 4;
Debug.Assert(dwordMultipleSize == 3); // the fat header is 3 dwords
_maxStackSize = reader.ReadUInt16();
int codeSize = reader.ReadInt32();
int localSig = reader.ReadInt32();
flags = (MethodBodyFlags)((msb & 0x0F) << 8 | lsb);
_code = ReadCode(method, context, reader, codeSize);
if ((flags & MethodBodyFlags.MoreSects) != 0)
{
sehBlocks = ReadSehBlocks(reader);
}
bool hasGenericVars;
_vars = context.ResolveLocalVariables(method, localSig, out hasGenericVars);
if (hasGenericVars)
{
_genericFlags |= GenericFlags.HasGenericVars;
}
}
break;
case MethodBodyFlags.TinyFormat:
case MethodBodyFlags.TinyFormat1:
{
int codeSize = (lsb >> 2);
_code = ReadCode(method, context, reader, codeSize);
}
break;
default:
throw new NotSupportedException("Not supported method body format!");
}
TranslateOffsets();
if (sehBlocks != null)
{
_protectedBlocks = TranslateSehBlocks(method, context, sehBlocks, _code);
}
context.LinkDebugInfo(this);
}
