604 lines
No EOL
16 KiB
C#
604 lines
No EOL
16 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using Server;
|
|
using Server.Items;
|
|
using Server.Network;
|
|
using Server.Targeting;
|
|
using CPA = Server.CommandPropertyAttribute;
|
|
|
|
namespace Server.Commands
|
|
{
|
|
public class Add
|
|
{
|
|
public static void Initialize()
|
|
{
|
|
CommandSystem.Register( "Tile", AccessLevel.GameMaster, new CommandEventHandler( Tile_OnCommand ) );
|
|
CommandSystem.Register( "TileRXYZ", AccessLevel.GameMaster, new CommandEventHandler( TileRXYZ_OnCommand ) );
|
|
CommandSystem.Register( "TileXYZ", AccessLevel.GameMaster, new CommandEventHandler( TileXYZ_OnCommand ) );
|
|
CommandSystem.Register( "TileZ", AccessLevel.GameMaster, new CommandEventHandler( TileZ_OnCommand ) );
|
|
}
|
|
|
|
public static void Invoke( Mobile from, Point3D start, Point3D end, string[] args )
|
|
{
|
|
Invoke( from, start, end, args, null );
|
|
}
|
|
|
|
public static void Invoke( Mobile from, Point3D start, Point3D end, string[] args, List<Container> packs )
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.AppendFormat( "{0} {1} building ", from.AccessLevel, CommandLogging.Format( from ) );
|
|
|
|
if ( start == end )
|
|
sb.AppendFormat( "at {0} in {1}", start, from.Map );
|
|
else
|
|
sb.AppendFormat( "from {0} to {1} in {2}", start, end, from.Map );
|
|
|
|
sb.Append( ":" );
|
|
|
|
for ( int i = 0; i < args.Length; ++i )
|
|
sb.AppendFormat( " \"{0}\"", args[i] );
|
|
|
|
CommandLogging.WriteLine( from, sb.ToString() );
|
|
|
|
string name = args[0];
|
|
|
|
FixArgs( ref args );
|
|
|
|
string[,] props = null;
|
|
|
|
for ( int i = 0; i < args.Length; ++i )
|
|
{
|
|
if ( Insensitive.Equals( args[i], "set" ) )
|
|
{
|
|
int remains = args.Length - i - 1;
|
|
|
|
if ( remains >= 2 )
|
|
{
|
|
props = new string[remains / 2, 2];
|
|
|
|
remains /= 2;
|
|
|
|
for ( int j = 0; j < remains; ++j )
|
|
{
|
|
props[j, 0] = args[i + (j * 2) + 1];
|
|
props[j, 1] = args[i + (j * 2) + 2];
|
|
}
|
|
|
|
FixSetString( ref args, i );
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
Type type = ScriptCompiler.FindTypeByName( name );
|
|
|
|
if ( !IsEntity( type ) ) {
|
|
from.SendMessage( "No type with that name was found." );
|
|
return;
|
|
}
|
|
|
|
DateTime time = DateTime.Now;
|
|
|
|
int built = BuildObjects( from, type, start, end, args, props, packs );
|
|
|
|
if ( built > 0 )
|
|
from.SendMessage( "{0} object{1} generated in {2:F1} seconds.", built, built != 1 ? "s" : "", (DateTime.Now - time).TotalSeconds );
|
|
else
|
|
SendUsage( type, from );
|
|
}
|
|
|
|
public static void FixSetString( ref string[] args, int index )
|
|
{
|
|
string[] old = args;
|
|
args = new string[index];
|
|
|
|
Array.Copy( old, 0, args, 0, index );
|
|
}
|
|
|
|
public static void FixArgs( ref string[] args )
|
|
{
|
|
string[] old = args;
|
|
args = new string[args.Length - 1];
|
|
|
|
Array.Copy( old, 1, args, 0, args.Length );
|
|
}
|
|
|
|
public static int BuildObjects( Mobile from, Type type, Point3D start, Point3D end, string[] args, string[,] props, List<Container> packs )
|
|
{
|
|
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 );
|
|
|
|
if ( built > 0 )
|
|
return built;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
public static object[] ParseValues( ParameterInfo[] paramList, string[] args )
|
|
{
|
|
object[] values = new object[args.Length];
|
|
|
|
for ( int i = 0; i < args.Length; ++i )
|
|
{
|
|
object value = ParseValue( paramList[i].ParameterType, args[i] );
|
|
|
|
if ( value != null )
|
|
values[i] = value;
|
|
else
|
|
return null;
|
|
}
|
|
|
|
return values;
|
|
}
|
|
|
|
public static object ParseValue( Type type, string value )
|
|
{
|
|
try
|
|
{
|
|
if ( IsEnum( type ) )
|
|
{
|
|
return Enum.Parse( type, value, true );
|
|
}
|
|
else if ( IsType( type ) )
|
|
{
|
|
return ScriptCompiler.FindTypeByName( value );
|
|
}
|
|
else if ( IsParsable( type ) )
|
|
{
|
|
return ParseParsable( type, value );
|
|
}
|
|
else
|
|
{
|
|
object obj = value;
|
|
|
|
if ( value != null && value.StartsWith( "0x" ) )
|
|
{
|
|
if ( IsSignedNumeric( type ) )
|
|
obj = Convert.ToInt64( value.Substring( 2 ), 16 );
|
|
else if ( IsUnsignedNumeric( type ) )
|
|
obj = Convert.ToUInt64( value.Substring( 2 ), 16 );
|
|
|
|
obj = Convert.ToInt32( value.Substring( 2 ), 16 );
|
|
}
|
|
|
|
if ( obj == null && !type.IsValueType )
|
|
return null;
|
|
else
|
|
return Convert.ChangeType( obj, type );
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static IEntity Build( Mobile from, ConstructorInfo ctor, object[] values, string[,] props, PropertyInfo[] realProps, ref bool sendError )
|
|
{
|
|
object built = ctor.Invoke( values );
|
|
|
|
if ( built != null && realProps != null )
|
|
{
|
|
bool hadError = false;
|
|
|
|
for ( int i = 0; i < realProps.Length; ++i )
|
|
{
|
|
if ( realProps[i] == null )
|
|
continue;
|
|
|
|
string result = Properties.InternalSetValue( from, built, built, realProps[i], props[i, 1], props[i, 1], false );
|
|
|
|
if ( result != "Property has been set." )
|
|
{
|
|
if ( sendError )
|
|
from.SendMessage( result );
|
|
|
|
hadError = true;
|
|
}
|
|
}
|
|
|
|
if ( hadError )
|
|
sendError = false;
|
|
}
|
|
|
|
return (IEntity)built;
|
|
}
|
|
|
|
public static int Build( Mobile from, Point3D start, Point3D end, ConstructorInfo ctor, object[] values, string[,] props, PropertyInfo[] realProps, List<Container> packs )
|
|
{
|
|
try
|
|
{
|
|
Map map = from.Map;
|
|
|
|
int objectCount = ( packs == null ? (((end.X - start.X) + 1) * ((end.Y - start.Y) + 1)) : packs.Count );
|
|
|
|
if ( objectCount >= 20 )
|
|
from.SendMessage( "Constructing {0} objects, please wait.", objectCount );
|
|
|
|
bool sendError = true;
|
|
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.Append( "Serials: " );
|
|
|
|
if ( packs != null )
|
|
{
|
|
for ( int i = 0; i < packs.Count; ++i )
|
|
{
|
|
IEntity built = Build( from, ctor, values, props, realProps, ref sendError );
|
|
|
|
sb.AppendFormat( "0x{0:X}; ", built.Serial.Value );
|
|
|
|
if ( built is Item ) {
|
|
Container pack = packs[i];
|
|
pack.DropItem( (Item)built );
|
|
}
|
|
else if ( built is Mobile ) {
|
|
Mobile m = (Mobile)built;
|
|
m.MoveToWorld( new Point3D( start.X, start.Y, start.Z ), map );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for ( int x = start.X; x <= end.X; ++x )
|
|
{
|
|
for ( int y = start.Y; y <= end.Y; ++y )
|
|
{
|
|
IEntity built = Build( from, ctor, values, props, realProps, ref sendError );
|
|
|
|
sb.AppendFormat( "0x{0:X}; ", built.Serial.Value );
|
|
|
|
if ( built is Item ) {
|
|
Item item = (Item)built;
|
|
item.MoveToWorld( new Point3D( x, y, start.Z ), map );
|
|
}
|
|
else if ( built is Mobile ) {
|
|
Mobile m = (Mobile)built;
|
|
m.MoveToWorld( new Point3D( x, y, start.Z ), map );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
CommandLogging.WriteLine( from, sb.ToString() );
|
|
|
|
return objectCount;
|
|
}
|
|
catch ( Exception ex )
|
|
{
|
|
Console.WriteLine(ex);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
public static void SendUsage( Type type, Mobile from )
|
|
{
|
|
ConstructorInfo[] ctors = type.GetConstructors();
|
|
bool foundCtor = false;
|
|
|
|
for ( int i = 0; i < ctors.Length; ++i )
|
|
{
|
|
ConstructorInfo ctor = ctors[i];
|
|
|
|
if ( !IsConstructable( ctor, from.AccessLevel ) )
|
|
continue;
|
|
|
|
if ( !foundCtor )
|
|
{
|
|
foundCtor = true;
|
|
from.SendMessage( "Usage:" );
|
|
}
|
|
|
|
SendCtor( type, ctor, from );
|
|
}
|
|
|
|
if ( !foundCtor )
|
|
from.SendMessage( "That type is not marked constructable." );
|
|
}
|
|
|
|
public static void SendCtor( Type type, ConstructorInfo ctor, Mobile from )
|
|
{
|
|
ParameterInfo[] paramList = ctor.GetParameters();
|
|
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.Append( type.Name );
|
|
|
|
for ( int i = 0; i < paramList.Length; ++i )
|
|
{
|
|
if ( i != 0 )
|
|
sb.Append( ',' );
|
|
|
|
sb.Append( ' ' );
|
|
|
|
sb.Append( paramList[i].ParameterType.Name );
|
|
sb.Append( ' ' );
|
|
sb.Append( paramList[i].Name );
|
|
}
|
|
|
|
from.SendMessage( sb.ToString() );
|
|
}
|
|
|
|
public class AddTarget : Target
|
|
{
|
|
private string[] m_Args;
|
|
|
|
public AddTarget( string[] args ) : base( -1, true, TargetFlags.None )
|
|
{
|
|
m_Args = args;
|
|
}
|
|
|
|
protected override void OnTarget( Mobile from, object o )
|
|
{
|
|
IPoint3D p = o as IPoint3D;
|
|
|
|
if ( p != null )
|
|
{
|
|
if ( p is Item )
|
|
p = ((Item)p).GetWorldTop();
|
|
else if ( p is Mobile )
|
|
p = ((Mobile)p).Location;
|
|
|
|
Point3D point = new Point3D( p );
|
|
Add.Invoke( from, point, point, m_Args );
|
|
}
|
|
}
|
|
}
|
|
|
|
private class TileState
|
|
{
|
|
public bool m_UseFixedZ;
|
|
public int m_FixedZ;
|
|
public string[] m_Args;
|
|
|
|
public TileState( string[] args ) : this( false, 0, args )
|
|
{
|
|
}
|
|
|
|
public TileState( int fixedZ, string[] args ) : this( true, fixedZ, args )
|
|
{
|
|
}
|
|
|
|
public TileState( bool useFixedZ, int fixedZ, string[] args )
|
|
{
|
|
m_UseFixedZ = useFixedZ;
|
|
m_FixedZ = fixedZ;
|
|
m_Args = args;
|
|
}
|
|
}
|
|
|
|
private static void TileBox_Callback( Mobile from, Map map, Point3D start, Point3D end, object state )
|
|
{
|
|
TileState ts = (TileState)state;
|
|
|
|
if ( ts.m_UseFixedZ )
|
|
start.Z = end.Z = ts.m_FixedZ;
|
|
|
|
Invoke( from, start, end, ts.m_Args );
|
|
}
|
|
|
|
[Usage( "Tile <name> [params] [set {<propertyName> <value> ...}]" )]
|
|
[Description( "Tiles an item or npc by name into a targeted bounding box. Optional constructor parameters. Optional set property list." )]
|
|
public static void Tile_OnCommand( CommandEventArgs e )
|
|
{
|
|
if ( e.Length >= 1 )
|
|
BoundingBoxPicker.Begin( e.Mobile, new BoundingBoxCallback( TileBox_Callback ), new TileState( e.Arguments ) );
|
|
else
|
|
e.Mobile.SendMessage( "Format: Add <type> [params] [set {<propertyName> <value> ...}]" );
|
|
}
|
|
|
|
[Usage( "TileRXYZ <x> <y> <w> <h> <z> <name> [params] [set {<propertyName> <value> ...}]" )]
|
|
[Description( "Tiles an item or npc by name into a given bounding box, (x, y) parameters are relative to your characters position. Optional constructor parameters. Optional set property list." )]
|
|
public static void TileRXYZ_OnCommand( CommandEventArgs e )
|
|
{
|
|
if ( e.Length >= 6 )
|
|
{
|
|
Point3D p = new Point3D( e.Mobile.X + e.GetInt32( 0 ), e.Mobile.Y + e.GetInt32( 1 ), e.Mobile.Z + e.GetInt32( 4 ) );
|
|
Point3D p2 = new Point3D( p.X + e.GetInt32( 2 ) - 1, p.Y + e.GetInt32( 3 ) - 1, p.Z );
|
|
|
|
string[] subArgs = new string[e.Length - 5];
|
|
|
|
for ( int i = 0; i < subArgs.Length; ++i )
|
|
subArgs[i] = e.Arguments[i + 5];
|
|
|
|
Add.Invoke( e.Mobile, p, p2, subArgs );
|
|
}
|
|
else
|
|
{
|
|
e.Mobile.SendMessage( "Format: TileRXYZ <x> <y> <w> <h> <z> <type> [params] [set {<propertyName> <value> ...}]" );
|
|
}
|
|
}
|
|
|
|
[Usage( "TileXYZ <x> <y> <w> <h> <z> <name> [params] [set {<propertyName> <value> ...}]" )]
|
|
[Description( "Tiles an item or npc by name into a given bounding box. Optional constructor parameters. Optional set property list." )]
|
|
public static void TileXYZ_OnCommand( CommandEventArgs e )
|
|
{
|
|
if ( e.Length >= 6 )
|
|
{
|
|
Point3D p = new Point3D( e.GetInt32( 0 ), e.GetInt32( 1 ), e.GetInt32( 4 ) );
|
|
Point3D p2 = new Point3D( p.X + e.GetInt32( 2 ) - 1, p.Y + e.GetInt32( 3 ) - 1, e.GetInt32( 4 ) );
|
|
|
|
string[] subArgs = new string[e.Length - 5];
|
|
|
|
for ( int i = 0; i < subArgs.Length; ++i )
|
|
subArgs[i] = e.Arguments[i + 5];
|
|
|
|
Add.Invoke( e.Mobile, p, p2, subArgs );
|
|
}
|
|
else
|
|
{
|
|
e.Mobile.SendMessage( "Format: TileXYZ <x> <y> <w> <h> <z> <type> [params] [set {<propertyName> <value> ...}]" );
|
|
}
|
|
}
|
|
|
|
[Usage( "TileZ <z> <name> [params] [set {<propertyName> <value> ...}]" )]
|
|
[Description( "Tiles an item or npc by name into a targeted bounding box at a fixed Z location. Optional constructor parameters. Optional set property list." )]
|
|
public static void TileZ_OnCommand( CommandEventArgs e )
|
|
{
|
|
if ( e.Length >= 2 )
|
|
{
|
|
string[] subArgs = new string[e.Length - 1];
|
|
|
|
for ( int i = 0; i < subArgs.Length; ++i )
|
|
subArgs[i] = e.Arguments[i + 1];
|
|
|
|
BoundingBoxPicker.Begin( e.Mobile, new BoundingBoxCallback( TileBox_Callback ), new TileState( e.GetInt32( 0 ), subArgs ) );
|
|
}
|
|
else
|
|
{
|
|
e.Mobile.SendMessage( "Format: TileZ <z> <type> [params] [set {<propertyName> <value> ...}]" );
|
|
}
|
|
}
|
|
|
|
private static Type m_EntityType = typeof( IEntity );
|
|
|
|
public static bool IsEntity( Type t )
|
|
{
|
|
return m_EntityType.IsAssignableFrom( t );
|
|
}
|
|
|
|
private static Type m_ConstructableType = typeof( ConstructableAttribute );
|
|
|
|
public static bool IsConstructable( ConstructorInfo ctor, AccessLevel accessLevel )
|
|
{
|
|
object[] attrs = ctor.GetCustomAttributes( m_ConstructableType, false );
|
|
|
|
if ( attrs.Length == 0 )
|
|
return false;
|
|
|
|
return accessLevel >= ((ConstructableAttribute)attrs[0]).AccessLevel;
|
|
}
|
|
|
|
private static Type m_EnumType = typeof( Enum );
|
|
|
|
public static bool IsEnum( Type type )
|
|
{
|
|
return type.IsSubclassOf( m_EnumType );
|
|
}
|
|
|
|
private static Type m_TypeType = typeof( Type );
|
|
|
|
public static bool IsType( Type type )
|
|
{
|
|
return ( type == m_TypeType || type.IsSubclassOf( m_TypeType ) );
|
|
}
|
|
|
|
private static Type m_ParsableType = typeof( ParsableAttribute );
|
|
|
|
public static bool IsParsable( Type type )
|
|
{
|
|
return type.IsDefined( m_ParsableType, false );
|
|
}
|
|
|
|
private static Type[] m_ParseTypes = new Type[]{ typeof( string ) };
|
|
private static object[] m_ParseArgs = new object[1];
|
|
|
|
public static object ParseParsable( Type type, string value )
|
|
{
|
|
MethodInfo method = type.GetMethod( "Parse", m_ParseTypes );
|
|
|
|
m_ParseArgs[0] = value;
|
|
|
|
return method.Invoke( null, m_ParseArgs );
|
|
}
|
|
|
|
private static Type[] m_SignedNumerics = new Type[]
|
|
{
|
|
typeof( Int64 ),
|
|
typeof( Int32 ),
|
|
typeof( Int16 ),
|
|
typeof( SByte )
|
|
};
|
|
|
|
public static bool IsSignedNumeric( Type type )
|
|
{
|
|
for ( int i = 0; i < m_SignedNumerics.Length; ++i )
|
|
if ( type == m_SignedNumerics[i] )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
private static Type[] m_UnsignedNumerics = new Type[]
|
|
{
|
|
typeof( UInt64 ),
|
|
typeof( UInt32 ),
|
|
typeof( UInt16 ),
|
|
typeof( Byte )
|
|
};
|
|
|
|
public static bool IsUnsignedNumeric( Type type )
|
|
{
|
|
for ( int i = 0; i < m_UnsignedNumerics.Length; ++i )
|
|
if ( type == m_UnsignedNumerics[i] )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
}
|
|
} |