/// <summary>
/// Gets a BoxMobile object from a type
/// </summary>
/// <param name="t">The type to evaluate</param>
/// <returns>A BoxMobile object or null if the type can't be constructed properly</returns>
public static BoxMobile FromType(Type t)
{
ConstructorInfo[] ctors = t.GetConstructors();
bool constructable = false;
BoxMobile mobile = null;
foreach (ConstructorInfo c in ctors)
{
if (BoxUtil.IsConstructable(c))
{
constructable = true;
break;
}
}
if (constructable)
{
mobile = new BoxMobile();
mobile.m_Name = t.Name;
foreach (ConstructorInfo c in ctors)
{
if (BoxUtil.IsConstructable(c))
{
ParameterInfo[] pms = c.GetParameters();
if (pms.Length == 0)
{
try
{
Mobile theMobile = (Mobile)Activator.CreateInstance(t);
mobile.m_Art = theMobile.Body.BodyID;
mobile.Hue = theMobile.Hue;
if (theMobile != null)
{
theMobile.Delete();
}
}
catch
{
// TODO : Logging?
return(null);
}
}
else if (pms.Length == 1 && (pms[0].ParameterType == typeof(string)))
{
mobile.CanBeNamed = true;
}
}
}
}
return(mobile);
}
public override void HandlerInput(InputState input)
{
if (input.CurrentState.IsKeyDown(key) && !input.LastKeyState.IsKeyDown(key))
{
do
{
ctrl.dropBox.MoveDown();
} while (ctrl.dropBox.position.Y > -BoxUtil.getTop(ctrl.dropBox.boxData) * DropBox.size);
}
}
/// <summary>
/// Creates a BoxItem definition from a type
/// </summary>
/// <param name="type">The type that will be analyzed</param>
/// <returns>The corresponding BoxItem object, null if the object can't be constructed</returns>
public static BoxItem FromType(Type type)
{
BoxItem item = new BoxItem();
ConstructorInfo[] ctors = type.GetConstructors();
item.m_Name = type.Name;
foreach (ConstructorInfo ctor in ctors)
{
if (BoxUtil.IsConstructable(ctor))
{
int NumOfParams = ctor.GetParameters().Length;
if (NumOfParams == 0)
{
item.m_EmptyCtor = true;
item.m_Item = ItemDef.GetItemDef(type);
}
else if (NumOfParams <= 2)
{
if (item.m_AdditionalCtors == null)
{
item.m_AdditionalCtors = new ArrayList();
}
item.m_AdditionalCtors.Add(ConstructorDef.FromConstructorInfo(ctor));
}
}
}
if (item.m_EmptyCtor || item.m_AdditionalCtors != null)
{
// If there's no default constructor, try to get the ItemDef from the additional constructors
if (!item.m_EmptyCtor)
{
// Get the first available def
foreach (ConstructorDef cDef in item.m_AdditionalCtors)
{
if (cDef.DefaultArt != null)
{
item.m_Item = cDef.DefaultArt.Clone() as ItemDef;
break;
}
}
}
return(item);
}
else
{
return(null);
}
}
/// <summary>
/// Creates a new BoxFolderInfo object
/// </summary>
/// <param name="username">The username of the user registered for acess to the explorer</param>
public FolderInfo(string username)
{
m_Structure = new GenericNode();
m_Folders = new System.Collections.ArrayList(RemoteExplorerConfig.GetExplorerFolder(username));
// Create the folders structure
foreach (string folder in m_Folders)
{
BoxUtil.EnsureFolder(folder);
GenericNode fNode = new GenericNode(folder);
DoFolder(Path.Combine(BoxUtil.RunUOFolder, folder), fNode);
m_Structure.Elements.Add(fNode);
}
}
/// <summary>
/// Processes a type and collects information about its properties
/// </summary>
/// <param name="t">The Type to examine</param>
private void ProcessType(Type t)
{
ArrayList list = new ArrayList();
if ((BoxUtil.IsItem(t) || BoxUtil.IsMobile(t)))
{
PropertyInfo[] props = t.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
if (props.Length > 0)
{
foreach (PropertyInfo info in props)
{
BoxProp p = BoxProp.FromPropertyInfo(info);
if (p != null)
{
list.Add(p);
if (p.ValueType == BoxPropType.Enumeration)
{
if (!EnumListed(p.EnumName))
{
BoxEnum e = BoxEnum.FromPropertyInfo(info);
m_Enums.Add(e);
}
}
}
}
}
}
if (list.Count > 0)
{
m_Constructables[t.Name] = list;
}
else
{
m_Constructables[t.Name] = null;
}
}
public override BoxMessage Perform()
{
string file = null;
string path = null;
Type type = null;
switch (m_DataType)
{
case BoxDatafile.BoxData:
file = "BoxData.xml";
type = typeof(BoxData);
break;
case BoxDatafile.PropsData:
file = "PropsData.xml";
type = typeof(PropsData);
break;
case BoxDatafile.SpawnData:
file = "SpawnData.xml";
type = typeof(SpawnData);
break;
}
path = System.IO.Path.Combine(BoxUtil.BoxFolder, file);
object data = BoxUtil.XmlLoad(path, type);
if (data == null)
{
return(new DatafileNotFound());
}
else
{
return(new ReturnDatafile(data));
}
}
/// <summary>
/// Reads a BoxData object from a file
/// </summary>
/// <param name="filename">The filename containing the BoxData object</param>
/// <returns>The BoxData object read from file, or null if not succesful</returns>
public static BoxData Load(string filename)
{
return(BoxUtil.XmlLoad(filename, typeof(BoxData)) as BoxData);
}
/// <summary>
/// Saves the box data to file
/// </summary>
private static void Save(BoxData data)
{
string path = Path.Combine(BoxUtil.BoxFolder, "BoxData.xml");
BoxUtil.XmlSave(data, path);
}
/// <summary>
/// Saves the PropsData to an xml file in the RunUO\TheBox folder
/// </summary>
public void Save()
{
string file = Path.Combine(BoxUtil.BoxFolder, "PropsData.xml");
BoxUtil.XmlSave(this, file);
}
/// <summary>
/// Loads a PropsData object from an xml file
/// </summary>
/// <param name="file">The xml file containing the PropsData object</param>
/// <returns>The loaded PropsData</returns>
public static PropsData Load(string file)
{
return(BoxUtil.XmlLoad(file, typeof(PropsData)) as PropsData);
}
/// <summary>
/// Saves the SpawnData to the TheBox folder
/// </summary>
private void Save()
{
string filename = System.IO.Path.Combine(BoxUtil.BoxFolder, "SpawnData.xml");
BoxUtil.XmlSave(this, filename);
}
private static void EmitConvert(CodeEmitter ilgen, java.lang.Class srcClass, java.lang.Class dstClass, int level)
{
if (srcClass != dstClass)
{
TypeWrapper src = TypeWrapper.FromClass(srcClass);
TypeWrapper dst = TypeWrapper.FromClass(dstClass);
src.Finish();
dst.Finish();
if (src.IsNonPrimitiveValueType)
{
src.EmitBox(ilgen);
}
if (dst == PrimitiveTypeWrapper.VOID)
{
ilgen.Emit(OpCodes.Pop);
}
else if (src.IsPrimitive)
{
if (dst.IsPrimitive)
{
if (src == PrimitiveTypeWrapper.BYTE)
{
ilgen.Emit(OpCodes.Conv_I1);
}
if (dst == PrimitiveTypeWrapper.FLOAT)
{
ilgen.Emit(OpCodes.Conv_R4);
}
else if (dst == PrimitiveTypeWrapper.DOUBLE)
{
ilgen.Emit(OpCodes.Conv_R8);
}
else if (dst == PrimitiveTypeWrapper.LONG)
{
if (src == PrimitiveTypeWrapper.FLOAT)
{
ilgen.Emit(OpCodes.Call, ByteCodeHelperMethods.f2l);
}
else if (src == PrimitiveTypeWrapper.DOUBLE)
{
ilgen.Emit(OpCodes.Call, ByteCodeHelperMethods.d2l);
}
else
{
ilgen.Emit(OpCodes.Conv_I8);
}
}
else if (dst == PrimitiveTypeWrapper.BOOLEAN)
{
if (src == PrimitiveTypeWrapper.FLOAT)
{
ilgen.Emit(OpCodes.Call, ByteCodeHelperMethods.f2i);
}
else if (src == PrimitiveTypeWrapper.DOUBLE)
{
ilgen.Emit(OpCodes.Call, ByteCodeHelperMethods.d2i);
}
else
{
ilgen.Emit(OpCodes.Conv_I4);
}
ilgen.Emit(OpCodes.Ldc_I4_1);
ilgen.Emit(OpCodes.And);
}
else if (src == PrimitiveTypeWrapper.LONG)
{
ilgen.Emit(OpCodes.Conv_I4);
}
else if (src == PrimitiveTypeWrapper.FLOAT)
{
ilgen.Emit(OpCodes.Call, ByteCodeHelperMethods.f2i);
}
else if (src == PrimitiveTypeWrapper.DOUBLE)
{
ilgen.Emit(OpCodes.Call, ByteCodeHelperMethods.d2i);
}
}
else
{
BoxUtil.Box(ilgen, srcClass, dstClass, level);
}
}
else if (src.IsGhost)
{
src.EmitConvSignatureTypeToStackType(ilgen);
EmitConvert(ilgen, [email protected] <java.lang.Object> .Value, dstClass, level);
}
else if (srcClass == [email protected] <sun.invoke.empty.Empty> .Value)
{
ilgen.Emit(OpCodes.Pop);
ilgen.Emit(OpCodes.Ldloc, ilgen.DeclareLocal(dst.TypeAsSignatureType));
}
else if (dst.IsPrimitive)
{
BoxUtil.Unbox(ilgen, srcClass, dstClass, level);
}
else if (dst.IsGhost)
{
dst.EmitConvStackTypeToSignatureType(ilgen, null);
}
else if (dst.IsNonPrimitiveValueType)
{
dst.EmitUnbox(ilgen);
}
else
{
dst.EmitCheckcast(ilgen);
}
}
}
private void ParseBoxes(Box parent)
{
while (_reader.BaseStream.Position < _reader.BaseStream.Length)
{
UInt32 boxSize = _reader.ReadUInt32();
BoxType boxType = (BoxType)_reader.ReadUInt32();
var sibling = BoxUtil.CreateInstance(boxType);
sibling.Parent = parent;
parent.Children.Add(sibling);
ParseBox(sibling, boxSize);
switch (boxType)
{
case BoxType.moov:
case BoxType.trak:
case BoxType.mdia:
case BoxType.minf:
case BoxType.dinf:
case BoxType.udta:
ParseDefaultParentBox(sibling);
break;
case BoxType.ftyp:
ParseFtyp(sibling);
break;
case BoxType.mdat:
ParseMdat(sibling);
break;
case BoxType.mvhd:
ParseMvhd(sibling);
break;
case BoxType.hdlr:
ParseHdlr(sibling);
break;
case BoxType.dref:
ParseDref(sibling);
break;
case BoxType.stbl:
ParseStbl(sibling);
break;
case BoxType.stts:
ParseStts(sibling);
break;
case BoxType.stsc:
ParseStsc(sibling);
break;
case BoxType.stsz:
ParseStsz(sibling);
break;
case BoxType.stco:
ParseStco(sibling);
break;
case BoxType.stsd:
ParseStsd(sibling);
break;
case BoxType.avc1:
ParseAvc1(sibling);
break;
case BoxType.mp4a:
ParseMp4a(sibling);
break;
case BoxType.esds:
ParseEsds(sibling);
break;
default:
_reader.BaseStream.Seek((boxSize - 4 * 2), SeekOrigin.Current);
break;
}
if (sibling.IsLastPosition())
{
return;
}
}
}
