public static int BuildObjects(Mobile from, Type type, Point3D start, Point3D end, string[] args, string[,] props, List <Container> packs, bool outline, bool mapAvg)
{
Utility.FixPoints(ref start, ref end);
PropertyInfo[] realProps = null;
if (props != null)
{
realProps = new PropertyInfo[props.GetLength(0)];
PropertyInfo[] allProps = type.GetProperties(BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public);
for (int i = 0; i < realProps.Length; ++i)
{
PropertyInfo thisProp = null;
string propName = props[i, 0];
for (int j = 0; thisProp == null && j < allProps.Length; ++j)
{
if (Insensitive.Equals(propName, allProps[j].Name))
{
thisProp = allProps[j];
}
}
if (thisProp == null)
{
from.SendMessage("Property not found: {0}", propName);
}
else
{
CPA attr = Properties.GetCPA(thisProp);
if (attr == null)
{
from.SendMessage("Property ({0}) not found.", propName);
}
else if (from.AccessLevel < attr.WriteLevel)
{
from.SendMessage("Setting this property ({0}) requires at least {1} access level.", propName, Mobile.GetAccessLevelName(attr.WriteLevel));
}
else if (!thisProp.CanWrite || attr.ReadOnly)
{
from.SendMessage("Property ({0}) is read only.", propName);
}
else
{
realProps[i] = thisProp;
}
}
}
}
ConstructorInfo[] ctors = type.GetConstructors();
for (int i = 0; i < ctors.Length; ++i)
{
ConstructorInfo ctor = ctors[i];
if (!IsConstructable(ctor, from.AccessLevel))
{
continue;
}
ParameterInfo[] paramList = ctor.GetParameters();
if (args.Length == paramList.Length)
{
object[] paramValues = ParseValues(paramList, args);
if (paramValues == null)
{
continue;
}
int built = Build(from, start, end, ctor, paramValues, props, realProps, packs, outline, mapAvg);
if (built > 0)
{
return(built);
}
}
}
return(0);
}
public override void ExecuteList(CommandEventArgs e, ArrayList list)
{
if (list.Count == 0)
{
LogFailure("Nothing was found to use this command on.");
return;
}
try
{
BaseCommand[] commands = new BaseCommand[m_BatchCommands.Count];
CommandEventArgs[] eventArgs = new CommandEventArgs[m_BatchCommands.Count];
for (int i = 0; i < m_BatchCommands.Count; ++i)
{
BatchCommand bc = (BatchCommand)m_BatchCommands[i];
string commandString, argString;
string[] args;
bc.GetDetails(out commandString, out argString, out args);
BaseCommand command = m_Scope.Commands[commandString];
commands[i] = command;
eventArgs[i] = new CommandEventArgs(e.Mobile, commandString, argString, args);
if (command == null)
{
e.Mobile.SendMessage("That is either an invalid command name or one that does not support this modifier: {0}.", commandString);
return;
}
else if (e.Mobile.AccessLevel < command.AccessLevel)
{
e.Mobile.SendMessage("You do not have access to that command: {0}.", commandString);
return;
}
else if (!command.ValidateArgs(m_Scope, eventArgs[i]))
{
return;
}
}
for (int i = 0; i < commands.Length; ++i)
{
BaseCommand command = commands[i];
BatchCommand bc = (BatchCommand)m_BatchCommands[i];
if (list.Count > 20)
{
CommandLogging.Enabled = false;
}
ArrayList usedList;
if (Utility.InsensitiveCompare(bc.Object, "Current") == 0)
{
usedList = list;
}
else
{
Hashtable propertyChains = new Hashtable();
usedList = new ArrayList(list.Count);
for (int j = 0; j < list.Count; ++j)
{
object obj = list[j];
if (obj == null)
{
continue;
}
Type type = obj.GetType();
PropertyInfo[] chain = (PropertyInfo[])propertyChains[type];
string failReason = "";
if (chain == null && !propertyChains.Contains(type))
{
propertyChains[type] = chain = Properties.GetPropertyInfoChain(e.Mobile, type, bc.Object, PropertyAccess.Read, ref failReason);
}
if (chain == null)
{
continue;
}
PropertyInfo endProp = Properties.GetPropertyInfo(ref obj, chain, ref failReason);
if (endProp == null)
{
continue;
}
try
{
obj = endProp.GetValue(obj, null);
if (obj != null)
{
usedList.Add(obj);
}
}
catch
{
}
}
}
command.ExecuteList(eventArgs[i], usedList);
if (list.Count > 20)
{
CommandLogging.Enabled = true;
}
command.Flush(e.Mobile, list.Count > 20);
}
}
catch (Exception ex)
{
e.Mobile.SendMessage(ex.Message);
}
}
private static void AddInv(object o)
{
// Handle contained objects (iterative ;)
if (o is BaseContainer)
{
foreach (Item item in ((BaseContainer)o).Items)
{
if (m_ItemType == null)
{
AddInv(item);
continue;
}
Type it = item.GetType();
if (it.IsSubclassOf(m_ItemType) || it == m_ItemType || item is BaseContainer)
{
AddInv(item);
}
}
// Do we want to inventory this container, or return?
Type ct = o.GetType();
if (!(m_ItemType == null) && !ct.IsSubclassOf(m_ItemType) && ct != m_ItemType)
{
return;
}
}
// Handle this object
InvItem ir = new InvItem(o.GetType());
// Determine and set inv item properties
if (o is BaseWeapon)
{
BaseWeapon bw = (BaseWeapon)o;
ir.m_accuracy = bw.AccuracyLevel.ToString();
ir.m_damage = bw.DamageLevel.ToString();
ir.m_durability = bw.DurabilityLevel.ToString();
ir.m_slayer = bw.Slayer.ToString();
}
else if (o is BaseArmor)
{
BaseArmor ba = (BaseArmor)o;
ir.m_durability = ba.Durability.ToString();
ir.m_damage = ba.ProtectionLevel.ToString();
}
else if (o is EnchantedScroll)
{
EnchantedItem ei = (EnchantedItem)o;
// ProtectionLevel, Durability
if (ei.ItemType.IsSubclassOf(typeof(BaseArmor)))
{
ir.m_durability = ((ArmorDurabilityLevel)ei.iProps[1]).ToString();
ir.m_damage = ((ArmorProtectionLevel)(ei.iProps[0])).ToString();
}
else if (ei.ItemType.IsSubclassOf(typeof(BaseWeapon)))
{
ir.m_accuracy = ((WeaponAccuracyLevel)ei.iProps[2]).ToString();
ir.m_damage = ((WeaponDamageLevel)ei.iProps[0]).ToString();
ir.m_durability = ((WeaponDurabilityLevel)ei.iProps[1]).ToString();
ir.m_slayer = ((SlayerName)ei.iProps[3]).ToString();
}
}
if (o is Item)
{
Item it = (Item)o;
if (it.PlayerCrafted == true)
{
// It's playercrafted, so check for 'Quality' property
string strVal = Properties.GetValue(m_from, o, "Quality");
if (strVal == "Quality = Exceptional")
{
ir.m_quality = "Exceptional";
}
}
if (it.Amount > 0)
{
ir.m_count = it.Amount;
}
ir.m_serial = it.Serial;
// adam: Find the best name we can
if (o is EnchantedScroll)
{
EnchantedItem ei = (EnchantedItem)o;
ir.m_description = ei.ItemType.Name + ".scroll";
}
else
{
if (valid(it.Name))
{
ir.m_description = it.Name;
}
else if (valid(it.ItemData.Name) && (it.GetType().Name == null || it.GetType().Name == "Item" || it.GetType().Name == "Static"))
{
ir.m_description = it.ItemData.Name;
}
else
{
ir.m_description = it.GetType().Name;
}
}
}
// Make sure there are no others like this
foreach (InvItem ii in m_Inv)
{
if (ii.m_type == ir.m_type &&
ii.m_accuracy == ir.m_accuracy &&
ii.m_damage == ir.m_damage &&
ii.m_quality == ir.m_quality &&
ii.m_durability == ir.m_durability &&
ii.m_slayer == ir.m_slayer &&
ii.m_description == ir.m_description) //pla: include new field in this check
{
// It exists, so increment and return
ii.m_count += ir.m_count;
return;
}
}
// It doesn't exist, so add it
m_Inv.Add(ir);
}
public static void DeleteItemByType_OnCommand(CommandEventArgs e)
{
try
{
if (e == null || e.Mobile == null || e.Mobile is PlayerMobile == false)
{
return;
}
string sProp = null;
string sVal = null;
string name = null;
if (e.Length >= 1)
{
name = e.GetString(0);
if (e.Length >= 2)
{
sProp = e.GetString(1);
}
if (e.Length >= 3)
{
sVal = e.GetString(2);
}
// if you are a GM the world needs to be in 'Build' mode to access this comand
if (e.Mobile.AccessLevel < AccessLevel.Administrator && Core.Building == false)
{
e.Mobile.SendMessage("The server must be in build mode for you to access this command.");
return;
}
PlayerMobile pm = e.Mobile as PlayerMobile;
LogHelper Logger = new LogHelper("DeleteItemByType.log", e.Mobile, false);
// reset jump table
pm.JumpIndex = 0;
pm.JumpList = new ArrayList();
Type tx = ScriptCompiler.FindTypeByName(name);
if (tx != null)
{
foreach (Item item in World.Items.Values)
{
if (item != null && !item.Deleted && item.GetType() == tx /* tx.IsAssignableFrom(item.GetType())*/)
{
// read the properties
PropertyInfo[] allProps = item.GetType().GetProperties(BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public);
if (sProp != null)
{
foreach (PropertyInfo prop in allProps)
{
if (prop.Name.ToLower() == sProp.ToLower())
{
bool ok = false;
string val = Properties.GetValue(e.Mobile, item, sProp);
// match a null value
if ((val == null || val.Length == 0 || val.EndsWith("(-null-)", StringComparison.CurrentCultureIgnoreCase)) && (sVal == null || sVal.Length == 0))
{
ok = true;
}
// see if the property matches
else if (val != null && sVal != null)
{
string[] toks = val.Split(new Char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (toks.Length >= 3 && toks[2].Equals(sVal, StringComparison.CurrentCultureIgnoreCase))
{
ok = true;
}
else
{
break;
}
}
if (ok)
{
pm.JumpList.Add(item);
Logger.Log(LogType.Item, item);
break;
}
}
}
}
else
{ // no prop to check, everything matches
pm.JumpList.Add(item);
Logger.Log(LogType.Item, item);
}
}
}
}
// since we already have the items in our jump list, just reuse it for the to-delete list
if (pm.JumpList.Count > 0)
{
foreach (Item ix in pm.JumpList)
{
if (ix != null)
{
Console.WriteLine("Deleting object {0}.", ix);
ix.Delete();
}
}
}
Logger.Finish();
}
else
{
e.Mobile.SendMessage("Format: DeleteItemByType <type>");
}
}
catch (Exception ex) { EventSink.InvokeLogException(new LogExceptionEventArgs(ex)); }
}