1. This site uses cookies. By continuing to use this site, you are agreeing to our use of cookies. Learn More.

tutorial for custom ores/ingots?

Discussion in 'Script Support' started by Fred1990, Feb 12, 2019 at 4:25 PM.

  1. Fred1990
    Offline

    Fred1990 Member

    Joined:
    Jan 23, 2019
    Messages:
    31
    Likes Received:
    1
    Hi guys, is there a tutorial for add custom ingots and ores?

    My custom material is Silver.

    >>>I'm filled out this line too to the resourcesinfo.cs,

    public static CraftResourceType GetType( CraftResource resource )
    {
    if ( resource >= CraftResource.Iron && resource <= CraftResource.Silver )
    return CraftResourceType.Metal;

    ********************



    >>>This on ingots.cs
    public override int LabelNumber
    {
    get
    {
    if ( m_Resource >= CraftResource.DullCopper && m_Resource <= CraftResource.Silver )
    return 1042684 + (int)(m_Resource - CraftResource.DullCopper);
    return 1042692;
    }
    }
    }

    *********************

    >>>This on the ore.cs
    public override int LabelNumber
    {
    get
    {
    if ( m_Resource >= CraftResource.DullCopper && m_Resource <= CraftResource.Silver )
    return 1042845 + (int)(m_Resource - CraftResource.DullCopper);
    return 1042853; // iron ore;
    }
    }



    *****************************

    >> and filled out the lines copying the code of an existing material, on ores.cs - ingot.cs - armorenums.cs - basearmor - resourcesinfo -defblacksmith.cs - baseweapon.cs - craftitem.cs .
    The sequence is correct the silver material is after valorite material .

    Do you have any idea?



    errors:
    + Engines / Craft / DefBlacksmithy.cs:
    CS0246: Line 663: The type or name of the 'SilverIngot' namespace was not found. Probably missing a using directive or an assembly reference
    + Engines / Harvest / Mining.cs:
    CS0246: Line 96: The type or name of the 'SilverOre' namespace was not found. Probably missing a using directive or an assembly reference
    CS0246: Line 96: The type or name of the 'SilverGranite' namespace was not found. Probably missing a using directive or an assembly reference
    + Items / Resources / Blacksmithing / Ore.cs:
    CS0246: Line 647: The type or name of the 'SilverIngot' namespace can not be found. Probably missing a using directive or an assembly reference
    + Misc / ResourceInfo.cs:
    CS0161: Line 656: 'Server.Items.CraftResources.GetFromOreInfo (Server.Items.OreInfo)': Not all code paths return a value.
    CS0246: Line 468: The type or name of the 'SilverIngot' namespace can not be found. Probably missing a using directive or an assembly reference
    CS0246: Line 468: The type or name of the 'SilverOre' namespace was not found. Probably missing a using directive or an assembly reference
    CS0246: Line 468: The type or name of the 'SilverGranite' namespace was not found. Probably missing a using directive or an assembly reference
     
  2. Po0ka
    Offline

    Po0ka Active Member

    Joined:
    Aug 19, 2014
    Messages:
    704
    Likes Received:
    83
    You need to add it to ResourceInfo.cs and to the various items listed above, if i remember right, Ingot.cs should have all the classes for the ingots from iron to valorite, you should add your SilverIngot to it, etc.

    Search for every instances of DullCopper, and search from there.
    As for how the item displays in the craft menu, perhaps you would need to add your own method to get the display name (instead of using clilocs).
     
  3. Fred1990
    Offline

    Fred1990 Member

    Joined:
    Jan 23, 2019
    Messages:
    31
    Likes Received:
    1




    Hi
    I have this methods on


    >>> Ingots.cs


    switch ( reader.ReadInt() )
    {
    case 0: info = OreInfo.Iron; break;
    case 1: info = OreInfo.DullCopper; break;
    case 2: info = OreInfo.ShadowIron; break;
    case 3: info = OreInfo.Copper; break;
    case 4: info = OreInfo.Bronze; break;
    case 5: info = OreInfo.Gold; break;
    case 6: info = OreInfo.Agapite; break;
    case 7: info = OreInfo.Verite; break;
    case 8: info = OreInfo.Valorite; break;
    case 9: info = OreInfo.Silver; break;
    default: info = null; break;



    [FlipableAttribute(0x1BF2, 0x1BEF)]
    public class SilverIngot : BaseIngot
    {
    [Constructable]
    public SilverIngot() : this( 1 )
    {
    }
    [Constructable]
    public SilverIngot( int amount ) : base( CraftResource.Silver, amount )
    {
    }
    public SilverIngot( Serial serial ) : base( serial )
    {
    }
    public override void Serialize( GenericWriter writer )
    {
    base.Serialize( writer );
    writer.Write( ( int) 0 ); // version
    }
    public override void Deserialize( GenericReader reader )
    {
    base.Deserialize (reader );
    int version = reader.ReadInt();
    }


    >>>On Ingots.cs

    switch ( reader.ReadInt() )
    {
    case 0: info = OreInfo.Iron; break;
    case 1: info = OreInfo.DullCopper; break;
    case 2: info = OreInfo.ShadowIron; break;
    case 3: info = OreInfo.Copper; break;
    case 4: info = OreInfo.Bronze; break;
    case 5: info = OreInfo.Gold; break;
    case 6: info = OreInfo.Agapite; break;
    case 7: info = OreInfo.Verite; break;
    case 8: info = OreInfo.Valorite; break;
    case 9: info = OreInfo.Silver; break;
    default: info = null; break;
    }

    [FlipableAttribute(0x1BF2, 0x1BEF)]
    public class SilverIngot : BaseIngot
    {
    [Constructable]
    public SilverIngot() : this( 1 )
    {
    }
    [Constructable]
    public SilverIngot( int amount ) : base( CraftResource.Silver, amount )
    {
    }
    public SilverIngot( Serial serial ) : base( serial )
    {
    }
    public override void Serialize( GenericWriter writer )
    {
    base.Serialize( writer );
    writer.Write( ( int) 0 ); // version
    }
    public override void Deserialize( GenericReader reader )
    {
    base.Deserialize (reader );
    int version = reader.ReadInt();
    }


    >>> On resoucesinfo.cs ( i copied only the interested part)

    public enum CraftResource
    {
    None = 0,
    Iron = 1,
    DullCopper,
    ShadowIron,
    Copper,
    Bronze,
    Gold,
    Agapite,
    Verite,
    Valorite,
    Silver, <<<

    public static readonly CraftAttributeInfo Blank;
    public static readonly CraftAttributeInfo DullCopper, ShadowIron, Copper, Bronze, Golden, Agapite, Verite, Valorite, Silver; <<<
    public static readonly CraftAttributeInfo Spined, Horned, Barbed;

    CraftAttributeInfo silver = Silver = new CraftAttributeInfo();
    silver.ArmorPhysicalResist = 4;
    silver.ArmorColdResist = 3;
    silver.ArmorPoisonResist = 3;
    silver.ArmorEnergyResist = 3;
    silver.ArmorDurability = 50;
    silver.WeaponFireDamage = 10;
    silver.WeaponColdDamage = 20;
    silver.WeaponPoisonDamage = 10;
    silver.WeaponEnergyDamage = 20;
    silver.RunicMinAttributes = 5;
    silver.RunicMaxAttributes = 5;
    if (Core.ML)
    {
    silver.RunicMinIntensity = 85;
    silver.RunicMaxIntensity = 100;
    }
    else
    {
    silver.RunicMinIntensity = 50;
    silver.RunicMaxIntensity = 100;
    }



    public class CraftResources
    {
    private static CraftResourceInfo[] m_MetalInfo = new CraftResourceInfo[]
    {


    new CraftResourceInfo( 0x979, 1053103, "Agapite", CraftAttributeInfo.Agapite, CraftResource.Agapite, typeof( AgapiteIngot ), typeof( AgapiteOre ), typeof( AgapiteGranite ) ),
    new CraftResourceInfo( 0x89F, 1053102, "Verite", CraftAttributeInfo.Verite, CraftResource.Verite, typeof( VeriteIngot ), typeof( VeriteOre ), typeof( VeriteGranite ) ),
    new CraftResourceInfo( 0x8AB, 1053101, "Valorite", CraftAttributeInfo.Valorite, CraftResource.Valorite, typeof( ValoriteIngot ), typeof( ValoriteOre ), typeof( ValoriteGranite ) ),
    new CraftResourceInfo( 0xA08, 1061354, "Silver", CraftAttributeInfo.Silver, CraftResource.Silver, typeof( SilverIngot ), typeof( SilverOre ), typeof( SilverGranite ) ),
    };



    public static CraftResource GetFromOreInfo( OreInfo info )
    {
    return CraftResource.Valorite;
    else if (info.Level == 9)
    return CraftResource.Silver;
    else if (info.Level == 10)
    }


    public class OreInfo
    {
    public static readonly OreInfo Valorite = new OreInfo( 8, 0x8AB, "Valorite" );
    public static readonly OreInfo Silver = new OreInfo( 9, 0xA08, "Silver");

    private int m_Level;
    private int m_Hue;
    private string m_Name;
    public OreInfo( int level, int hue, string name )
    {
    m_Level = level;
    m_Hue = hue;
    m_Name = name;
    }
    public int Level
    {
    get
    {
    return m_Level;
    }
    }
    public int Hue
    {
    get
    {
    return m_Hue;
    }
    }
    public string Name
    {
    get
    {
    return m_Name;
    }
    }
    }
    }

    In these files is all correct I think
    I use runuo 2.3
    --- Double Post Merged, Feb 13, 2019 at 4:38 AM ---
    ON ARMORENUMS

    public enum ArmorMaterialType
    {
    Cloth,
    Leather,
    Studded,
    Bone,
    Spined,
    Horned,
    Barbed,
    Ringmail,
    Chainmail,
    Plate,
    Dragon, // On OSI, Dragon is seen and considered its own type.
    Silver <<<

    ON BASEARMOR

    switch ( m_Resource )
    {

    case CraftResource.Verite: ar += 14; break;
    case CraftResource.Valorite: ar += 16; break;
    case CraftResource.Silver: ar += 10; break; <<<

    }


    switch ( reader.ReadInt() )
    {
    default:
    case 8: info = OreInfo.Valorite; break;
    case 9: info = OreInfo.Silver; break; <<<
    }


    witch ( m_Resource )
    {
    case CraftResource.DullCopper: oreType = 1053108; break; // dull copper
    case CraftResource.ShadowIron: oreType = 1053107; break; // shadow iron
    case CraftResource.Copper: oreType = 1053106; break; // copper
    case CraftResource.Bronze: oreType = 1053105; break; // bronze
    case CraftResource.Gold: oreType = 1053104; break; // golden
    case CraftResource.Agapite: oreType = 1053103; break; // agapite
    case CraftResource.Verite: oreType = 1053102; break; // verite
    case CraftResource.Valorite: oreType = 1053101; break; // valorite
    case CraftResource.Silver: oreType = 1061354; break; // silver <<<<<<<<<<<<
    case CraftResource.SpinedLeather: oreType = 1061118; break; // spined
    case CraftResource.HornedLeather: oreType = 1061117; break; // horned
    case CraftResource.BarbedLeather: oreType = 1061116; break; // barbed
    case CraftResource.RedScales: oreType = 1060814; break; // red
    case CraftResource.YellowScales: oreType = 1060818; break; // yellow
    case CraftResource.BlackScales: oreType = 1060820; break; // black
    case CraftResource.GreenScales: oreType = 1060819; break; // green
    case CraftResource.WhiteScales: oreType = 1060821; break; // white
    case CraftResource.BlueScales: oreType = 1060815; break; // blue
    default: oreType = 0; break;
    }


    ON BASEWEAPON


    switch ( m_Resource )
    {

    case CraftResource.Valorite: oreType = 1053101; break; // valorite
    case CraftResource.Silver: oreType = 1061354; break; // silver

    default: oreType = 0; break;
    }



    CraftResource thisResource = CraftResources.GetFromType( resourceType );
    if ( thisResource == ((BaseRunicTool)tool).Resource )
    {
    Resource = thisResource;
    CraftContext context = craftSystem.GetContext( from );
    if ( context != null && context.DoNotColor )
    Hue = 0;
    switch ( thisResource )
    {

    case CraftResource.Silver:
    {
    Identified = true;
    DurabilityLevel = WeaponDurabilityLevel.Indestructible;
    DamageLevel = WeaponDamageLevel.Vanq;
    AccuracyLevel = WeaponAccuracyLevel.Supremely;
    break;
    --- Double Post Merged, Feb 13, 2019 at 4:43 AM ---
    On Defblacksmithy

    // Set the overridable material
    SetSubRes( typeof( IronIngot ), 1044022 );
    // Add every material you want the player to be able to choose from
    // This will override the overridable material
    AddSubRes( typeof( ValoriteIngot ), 1044030, 95.0, 1044036, 1044268 );
    AddSubRes( typeof( SilverIngot ), 1061722, 70.0, 1044036, 1044268 );

    On Repair.cs

    switch ( resource )
    {

    case CraftResource.Valorite: difficulty = 95.0; break;
    case CraftResource.Silver: difficulty = 80.0; break;
     
  4. Po0ka
    Offline

    Po0ka Active Member

    Joined:
    Aug 19, 2014
    Messages:
    704
    Likes Received:
    83
    Please, drag and drop Ingot.cs and ResourceInfo.cs in your reply.
    I suspect you have a wrongly placed bracket.

    Are you using an IDE like Visual Studio?
     
  5. Fred1990
    Offline

    Fred1990 Member

    Joined:
    Jan 23, 2019
    Messages:
    31
    Likes Received:
    1
    hi Pooka yes i'm using visual studio , I have attached the files too.

    here the

    ingots.cs

    using System;
    using Server.Items;
    using Server.Network;
    namespace Server.Items
    {
    public abstract class BaseIngot : Item, ICommodity
    {
    private CraftResource m_Resource;
    [CommandProperty( AccessLevel.GameMaster )]
    public CraftResource Resource
    {
    get{ return m_Resource; }
    set{ m_Resource = value; InvalidateProperties(); }
    }
    public override double DefaultWeight
    {
    get { return 0.1; }
    }

    int ICommodity.DescriptionNumber { get { return LabelNumber; } }
    bool ICommodity.IsDeedable { get { return true; } }
    public override void Serialize( GenericWriter writer )
    {
    base.Serialize( writer );
    writer.Write( (int) 1 ); // version
    writer.Write( (int) m_Resource );
    }
    public override void Deserialize( GenericReader reader )
    {
    base.Deserialize( reader );
    int version = reader.ReadInt();
    switch ( version )
    {
    case 1:
    {
    m_Resource = (CraftResource)reader.ReadInt();
    break;
    }
    case 0:
    {
    OreInfo info;
    switch ( reader.ReadInt() )
    {
    case 0: info = OreInfo.Iron; break;
    case 1: info = OreInfo.DullCopper; break;
    case 2: info = OreInfo.ShadowIron; break;
    case 3: info = OreInfo.Copper; break;
    case 4: info = OreInfo.Bronze; break;
    case 5: info = OreInfo.Gold; break;
    case 6: info = OreInfo.Agapite; break;
    case 7: info = OreInfo.Verite; break;
    case 8: info = OreInfo.Valorite; break;
    case 9: info = OreInfo.Silver; break;
    default: info = null; break;
    }
    m_Resource = CraftResources.GetFromOreInfo( info );
    break;
    }
    }
    }
    public BaseIngot( CraftResource resource ) : this( resource, 1 )
    {
    }
    public BaseIngot( CraftResource resource, int amount ) : base( 0x1BF2 )
    {
    Stackable = true;
    Amount = amount;
    Hue = CraftResources.GetHue( resource );
    m_Resource = resource;
    }
    public BaseIngot( Serial serial ) : base( serial )
    {
    }
    public override void AddNameProperty( ObjectPropertyList list )
    {
    if ( Amount > 1 )
    list.Add( 1050039, "{0}\t#{1}", Amount, 1027154 ); // ~1_NUMBER~ ~2_ITEMNAME~
    else
    list.Add( 1027154 ); // ingots
    }
    public override void GetProperties( ObjectPropertyList list )
    {
    base.GetProperties( list );
    if ( !CraftResources.IsStandard( m_Resource ) )
    {
    int num = CraftResources.GetLocalizationNumber( m_Resource );
    if ( num > 0 )
    list.Add( num );
    else
    list.Add( CraftResources.GetName( m_Resource ) );
    }
    }
    public override int LabelNumber
    {
    get
    {
    if ( m_Resource >= CraftResource.DullCopper && m_Resource <= CraftResource.Silver )
    return 1042684 + (int)(m_Resource - CraftResource.DullCopper);
    return 1042692;
    }
    }
    }
    [FlipableAttribute( 0x1BF2, 0x1BEF )]
    public class IronIngot : BaseIngot
    {
    [Constructable]
    public IronIngot() : this( 1 )
    {
    }
    [Constructable]
    public IronIngot( int amount ) : base( CraftResource.Iron, amount )
    {
    }
    public IronIngot( Serial serial ) : base( serial )
    {
    }
    public override void Serialize( GenericWriter writer )
    {
    base.Serialize( writer );
    writer.Write( (int) 0 ); // version
    }
    public override void Deserialize( GenericReader reader )
    {
    base.Deserialize( reader );
    int version = reader.ReadInt();
    }

    }
    [FlipableAttribute( 0x1BF2, 0x1BEF )]
    public class DullCopperIngot : BaseIngot
    {
    [Constructable]
    public DullCopperIngot() : this( 1 )
    {
    }
    [Constructable]
    public DullCopperIngot( int amount ) : base( CraftResource.DullCopper, amount )
    {
    }
    public DullCopperIngot( Serial serial ) : base( serial )
    {
    }
    public override void Serialize( GenericWriter writer )
    {
    base.Serialize( writer );
    writer.Write( (int) 0 ); // version
    }
    public override void Deserialize( GenericReader reader )
    {
    base.Deserialize( reader );
    int version = reader.ReadInt();
    }

    }
    [FlipableAttribute( 0x1BF2, 0x1BEF )]
    public class ShadowIronIngot : BaseIngot
    {
    [Constructable]
    public ShadowIronIngot() : this( 1 )
    {
    }
    [Constructable]
    public ShadowIronIngot( int amount ) : base( CraftResource.ShadowIron, amount )
    {
    }
    public ShadowIronIngot( Serial serial ) : base( serial )
    {
    }
    public override void Serialize( GenericWriter writer )
    {
    base.Serialize( writer );
    writer.Write( (int) 0 ); // version
    }
    public override void Deserialize( GenericReader reader )
    {
    base.Deserialize( reader );
    int version = reader.ReadInt();
    }

    }
    [FlipableAttribute( 0x1BF2, 0x1BEF )]
    public class CopperIngot : BaseIngot
    {
    [Constructable]
    public CopperIngot() : this( 1 )
    {
    }
    [Constructable]
    public CopperIngot( int amount ) : base( CraftResource.Copper, amount )
    {
    }
    public CopperIngot( Serial serial ) : base( serial )
    {
    }
    public override void Serialize( GenericWriter writer )
    {
    base.Serialize( writer );
    writer.Write( (int) 0 ); // version
    }
    public override void Deserialize( GenericReader reader )
    {
    base.Deserialize( reader );
    int version = reader.ReadInt();
    }

    }
    [FlipableAttribute( 0x1BF2, 0x1BEF )]
    public class BronzeIngot : BaseIngot
    {
    [Constructable]
    public BronzeIngot() : this( 1 )
    {
    }
    [Constructable]
    public BronzeIngot( int amount ) : base( CraftResource.Bronze, amount )
    {
    }
    public BronzeIngot( Serial serial ) : base( serial )
    {
    }
    public override void Serialize( GenericWriter writer )
    {
    base.Serialize( writer );
    writer.Write( (int) 0 ); // version
    }
    public override void Deserialize( GenericReader reader )
    {
    base.Deserialize( reader );
    int version = reader.ReadInt();
    }

    }

    [FlipableAttribute( 0x1BF2, 0x1BEF )]
    public class GoldIngot : BaseIngot
    {
    [Constructable]
    public GoldIngot() : this( 1 )
    {
    }
    [Constructable]
    public GoldIngot( int amount ) : base( CraftResource.Gold, amount )
    {
    }
    public GoldIngot( Serial serial ) : base( serial )
    {
    }
    public override void Serialize( GenericWriter writer )
    {
    base.Serialize( writer );
    writer.Write( (int) 0 ); // version
    }
    public override void Deserialize( GenericReader reader )
    {
    base.Deserialize( reader );
    int version = reader.ReadInt();
    }

    }
    [FlipableAttribute( 0x1BF2, 0x1BEF )]
    public class AgapiteIngot : BaseIngot
    {
    [Constructable]
    public AgapiteIngot() : this( 1 )
    {
    }
    [Constructable]
    public AgapiteIngot( int amount ) : base( CraftResource.Agapite, amount )
    {
    }
    public AgapiteIngot( Serial serial ) : base( serial )
    {
    }
    public override void Serialize( GenericWriter writer )
    {
    base.Serialize( writer );
    writer.Write( (int) 0 ); // version
    }
    public override void Deserialize( GenericReader reader )
    {
    base.Deserialize( reader );
    int version = reader.ReadInt();
    }

    }
    [FlipableAttribute( 0x1BF2, 0x1BEF )]
    public class VeriteIngot : BaseIngot
    {
    [Constructable]
    public VeriteIngot() : this( 1 )
    {
    }
    [Constructable]
    public VeriteIngot( int amount ) : base( CraftResource.Verite, amount )
    {
    }
    public VeriteIngot( Serial serial ) : base( serial )
    {
    }
    public override void Serialize( GenericWriter writer )
    {
    base.Serialize( writer );
    writer.Write( (int) 0 ); // version
    }
    public override void Deserialize( GenericReader reader )
    {
    base.Deserialize( reader );
    int version = reader.ReadInt();
    }

    }
    [FlipableAttribute( 0x1BF2, 0x1BEF )]
    public class ValoriteIngot : BaseIngot
    {
    [Constructable]
    public ValoriteIngot() : this( 1 )
    {
    }
    [Constructable]
    public ValoriteIngot( int amount ) : base( CraftResource.Valorite, amount )
    {
    }
    public ValoriteIngot( Serial serial ) : base( serial )
    {
    }
    public override void Serialize( GenericWriter writer )
    {
    base.Serialize( writer );
    writer.Write( (int) 0 ); // version
    }
    public override void Deserialize( GenericReader reader )
    {
    base.Deserialize( reader );
    int version = reader.ReadInt();
    }
    [FlipableAttribute(0x1BF2, 0x1BEF)]
    public class SilverIngot : BaseIngot
    {
    [Constructable]
    public SilverIngot() : this( 1 )
    {
    }
    [Constructable]
    public SilverIngot( int amount ) : base( CraftResource.Silver, amount )
    {
    }
    public SilverIngot( Serial serial ) : base( serial )
    {
    }
    public override void Serialize( GenericWriter writer )
    {
    base.Serialize( writer );
    writer.Write( ( int) 0 ); // version
    }
    public override void Deserialize( GenericReader reader )
    {
    base.Deserialize (reader );
    int version = reader.ReadInt();
    }



    }
    }
    }



    Resourcesinfo.cs


    using System;
    using System.Collections;
    namespace Server.Items
    {
    public enum CraftResource
    {
    None = 0,
    Iron = 1,
    DullCopper,
    ShadowIron,
    Copper,
    Bronze,
    Gold,
    Agapite,
    Verite,
    Valorite,
    Silver,
    RegularLeather = 101,
    SpinedLeather,
    HornedLeather,
    BarbedLeather,
    RedScales = 201,
    YellowScales,
    BlackScales,
    GreenScales,
    WhiteScales,
    BlueScales,
    RegularWood = 301,
    OakWood,
    AshWood,
    YewWood,
    Heartwood,
    Bloodwood,
    Frostwood
    }
    public enum CraftResourceType
    {
    None,
    Metal,
    Leather,
    Scales,
    Wood
    }
    public class CraftAttributeInfo
    {
    private int m_WeaponFireDamage;
    private int m_WeaponColdDamage;
    private int m_WeaponPoisonDamage;
    private int m_WeaponEnergyDamage;
    private int m_WeaponChaosDamage;
    private int m_WeaponDirectDamage;
    private int m_WeaponDurability;
    private int m_WeaponLuck;
    private int m_WeaponGoldIncrease;
    private int m_WeaponLowerRequirements;
    private int m_ArmorPhysicalResist;
    private int m_ArmorFireResist;
    private int m_ArmorColdResist;
    private int m_ArmorPoisonResist;
    private int m_ArmorEnergyResist;
    private int m_ArmorDurability;
    private int m_ArmorLuck;
    private int m_ArmorGoldIncrease;
    private int m_ArmorLowerRequirements;
    private int m_RunicMinAttributes;
    private int m_RunicMaxAttributes;
    private int m_RunicMinIntensity;
    private int m_RunicMaxIntensity;
    public int WeaponFireDamage{ get{ return m_WeaponFireDamage; } set{ m_WeaponFireDamage = value; } }
    public int WeaponColdDamage{ get{ return m_WeaponColdDamage; } set{ m_WeaponColdDamage = value; } }
    public int WeaponPoisonDamage{ get{ return m_WeaponPoisonDamage; } set{ m_WeaponPoisonDamage = value; } }
    public int WeaponEnergyDamage{ get{ return m_WeaponEnergyDamage; } set{ m_WeaponEnergyDamage = value; } }
    public int WeaponChaosDamage{ get{ return m_WeaponChaosDamage; } set{ m_WeaponChaosDamage = value; } }
    public int WeaponDirectDamage{ get{ return m_WeaponDirectDamage; } set{ m_WeaponDirectDamage = value; } }
    public int WeaponDurability{ get{ return m_WeaponDurability; } set{ m_WeaponDurability = value; } }
    public int WeaponLuck{ get{ return m_WeaponLuck; } set{ m_WeaponLuck = value; } }
    public int WeaponGoldIncrease{ get{ return m_WeaponGoldIncrease; } set{ m_WeaponGoldIncrease = value; } }
    public int WeaponLowerRequirements{ get{ return m_WeaponLowerRequirements; } set{ m_WeaponLowerRequirements = value; } }
    public int ArmorPhysicalResist{ get{ return m_ArmorPhysicalResist; } set{ m_ArmorPhysicalResist = value; } }
    public int ArmorFireResist{ get{ return m_ArmorFireResist; } set{ m_ArmorFireResist = value; } }
    public int ArmorColdResist{ get{ return m_ArmorColdResist; } set{ m_ArmorColdResist = value; } }
    public int ArmorPoisonResist{ get{ return m_ArmorPoisonResist; } set{ m_ArmorPoisonResist = value; } }
    public int ArmorEnergyResist{ get{ return m_ArmorEnergyResist; } set{ m_ArmorEnergyResist = value; } }
    public int ArmorDurability{ get{ return m_ArmorDurability; } set{ m_ArmorDurability = value; } }
    public int ArmorLuck{ get{ return m_ArmorLuck; } set{ m_ArmorLuck = value; } }
    public int ArmorGoldIncrease{ get{ return m_ArmorGoldIncrease; } set{ m_ArmorGoldIncrease = value; } }
    public int ArmorLowerRequirements{ get{ return m_ArmorLowerRequirements; } set{ m_ArmorLowerRequirements = value; } }
    public int RunicMinAttributes{ get{ return m_RunicMinAttributes; } set{ m_RunicMinAttributes = value; } }
    public int RunicMaxAttributes{ get{ return m_RunicMaxAttributes; } set{ m_RunicMaxAttributes = value; } }
    public int RunicMinIntensity{ get{ return m_RunicMinIntensity; } set{ m_RunicMinIntensity = value; } }
    public int RunicMaxIntensity{ get{ return m_RunicMaxIntensity; } set{ m_RunicMaxIntensity = value; } }
    public CraftAttributeInfo()
    {
    }
    public static readonly CraftAttributeInfo Blank;
    public static readonly CraftAttributeInfo DullCopper, ShadowIron, Copper, Bronze, Golden, Agapite, Verite, Valorite, Silver;
    public static readonly CraftAttributeInfo Spined, Horned, Barbed;
    public static readonly CraftAttributeInfo RedScales, YellowScales, BlackScales, GreenScales, WhiteScales, BlueScales;
    public static readonly CraftAttributeInfo OakWood, AshWood, YewWood, Heartwood, Bloodwood, Frostwood;
    static CraftAttributeInfo()
    {
    Blank = new CraftAttributeInfo();
    CraftAttributeInfo dullCopper = DullCopper = new CraftAttributeInfo();
    dullCopper.ArmorPhysicalResist = 6;
    dullCopper.ArmorDurability = 50;
    dullCopper.ArmorLowerRequirements = 20;
    dullCopper.WeaponDurability = 100;
    dullCopper.WeaponLowerRequirements = 50;
    dullCopper.RunicMinAttributes = 1;
    dullCopper.RunicMaxAttributes = 2;
    if ( Core.ML )
    {
    dullCopper.RunicMinIntensity = 40;
    dullCopper.RunicMaxIntensity = 100;
    }
    else
    {
    dullCopper.RunicMinIntensity = 10;
    dullCopper.RunicMaxIntensity = 35;
    }
    CraftAttributeInfo shadowIron = ShadowIron = new CraftAttributeInfo();
    shadowIron.ArmorPhysicalResist = 2;
    shadowIron.ArmorFireResist = 1;
    shadowIron.ArmorEnergyResist = 5;
    shadowIron.ArmorDurability = 100;
    shadowIron.WeaponColdDamage = 20;
    shadowIron.WeaponDurability = 50;
    shadowIron.RunicMinAttributes = 2;
    shadowIron.RunicMaxAttributes = 2;
    if ( Core.ML )
    {
    shadowIron.RunicMinIntensity = 45;
    shadowIron.RunicMaxIntensity = 100;
    }
    else
    {
    shadowIron.RunicMinIntensity = 20;
    shadowIron.RunicMaxIntensity = 45;
    }
    CraftAttributeInfo copper = Copper = new CraftAttributeInfo();
    copper.ArmorPhysicalResist = 1;
    copper.ArmorFireResist = 1;
    copper.ArmorPoisonResist = 5;
    copper.ArmorEnergyResist = 2;
    copper.WeaponPoisonDamage = 10;
    copper.WeaponEnergyDamage = 20;
    copper.RunicMinAttributes = 2;
    copper.RunicMaxAttributes = 3;
    if ( Core.ML )
    {
    copper.RunicMinIntensity = 50;
    copper.RunicMaxIntensity = 100;
    }
    else
    {
    copper.RunicMinIntensity = 25;
    copper.RunicMaxIntensity = 50;
    }
    CraftAttributeInfo bronze = Bronze = new CraftAttributeInfo();
    bronze.ArmorPhysicalResist = 3;
    bronze.ArmorColdResist = 5;
    bronze.ArmorPoisonResist = 1;
    bronze.ArmorEnergyResist = 1;
    bronze.WeaponFireDamage = 40;
    bronze.RunicMinAttributes = 3;
    bronze.RunicMaxAttributes = 3;
    if ( Core.ML )
    {
    bronze.RunicMinIntensity = 55;
    bronze.RunicMaxIntensity = 100;
    }
    else
    {
    bronze.RunicMinIntensity = 30;
    bronze.RunicMaxIntensity = 65;
    }


    CraftAttributeInfo golden = Golden = new CraftAttributeInfo();
    golden.ArmorPhysicalResist = 1;
    golden.ArmorFireResist = 1;
    golden.ArmorColdResist = 2;
    golden.ArmorEnergyResist = 2;
    golden.ArmorLuck = 40;
    golden.ArmorLowerRequirements = 30;
    golden.WeaponLuck = 40;
    golden.WeaponLowerRequirements = 50;
    golden.RunicMinAttributes = 3;
    golden.RunicMaxAttributes = 4;
    if ( Core.ML )
    {
    golden.RunicMinIntensity = 60;
    golden.RunicMaxIntensity = 100;
    }
    else
    {
    golden.RunicMinIntensity = 35;
    golden.RunicMaxIntensity = 75;
    }
    CraftAttributeInfo agapite = Agapite = new CraftAttributeInfo();
    agapite.ArmorPhysicalResist = 2;
    agapite.ArmorFireResist = 3;
    agapite.ArmorColdResist = 2;
    agapite.ArmorPoisonResist = 2;
    agapite.ArmorEnergyResist = 2;
    agapite.WeaponColdDamage = 30;
    agapite.WeaponEnergyDamage = 20;
    agapite.RunicMinAttributes = 4;
    agapite.RunicMaxAttributes = 4;
    if ( Core.ML )
    {
    agapite.RunicMinIntensity = 65;
    agapite.RunicMaxIntensity = 100;
    }
    else
    {
    agapite.RunicMinIntensity = 40;
    agapite.RunicMaxIntensity = 80;
    }
    CraftAttributeInfo verite = Verite = new CraftAttributeInfo();
    verite.ArmorPhysicalResist = 3;
    verite.ArmorFireResist = 3;
    verite.ArmorColdResist = 2;
    verite.ArmorPoisonResist = 3;
    verite.ArmorEnergyResist = 1;
    verite.WeaponPoisonDamage = 40;
    verite.WeaponEnergyDamage = 20;
    verite.RunicMinAttributes = 4;
    verite.RunicMaxAttributes = 5;
    if ( Core.ML )
    {
    verite.RunicMinIntensity = 70;
    verite.RunicMaxIntensity = 100;
    }
    else
    {
    verite.RunicMinIntensity = 45;
    verite.RunicMaxIntensity = 90;
    }
    CraftAttributeInfo valorite = Valorite = new CraftAttributeInfo();
    valorite.ArmorPhysicalResist = 4;
    valorite.ArmorColdResist = 3;
    valorite.ArmorPoisonResist = 3;
    valorite.ArmorEnergyResist = 3;
    valorite.ArmorDurability = 50;
    valorite.WeaponFireDamage = 10;
    valorite.WeaponColdDamage = 20;
    valorite.WeaponPoisonDamage = 10;
    valorite.WeaponEnergyDamage = 20;
    valorite.RunicMinAttributes = 5;
    valorite.RunicMaxAttributes = 5;
    if ( Core.ML )
    {
    valorite.RunicMinIntensity = 85;
    valorite.RunicMaxIntensity = 100;
    }
    else
    {
    valorite.RunicMinIntensity = 50;
    valorite.RunicMaxIntensity = 100;
    }
    CraftAttributeInfo silver = Silver = new CraftAttributeInfo();
    silver.ArmorPhysicalResist = 4;
    silver.ArmorColdResist = 3;
    silver.ArmorPoisonResist = 3;
    silver.ArmorEnergyResist = 3;
    silver.ArmorDurability = 50;
    silver.WeaponFireDamage = 10;
    silver.WeaponColdDamage = 20;
    silver.WeaponPoisonDamage = 10;
    silver.WeaponEnergyDamage = 20;
    silver.RunicMinAttributes = 5;
    silver.RunicMaxAttributes = 5;
    if (Core.ML)
    {
    silver.RunicMinIntensity = 85;
    silver.RunicMaxIntensity = 100;
    }
    else
    {
    silver.RunicMinIntensity = 50;
    silver.RunicMaxIntensity = 100;
    }


    CraftAttributeInfo spined = Spined = new CraftAttributeInfo();
    spined.ArmorPhysicalResist = 5;
    spined.ArmorLuck = 40;
    spined.RunicMinAttributes = 1;
    spined.RunicMaxAttributes = 3;
    if ( Core.ML )
    {
    spined.RunicMinIntensity = 40;
    spined.RunicMaxIntensity = 100;
    }
    else
    {
    spined.RunicMinIntensity = 20;
    spined.RunicMaxIntensity = 40;
    }
    CraftAttributeInfo horned = Horned = new CraftAttributeInfo();
    horned.ArmorPhysicalResist = 2;
    horned.ArmorFireResist = 3;
    horned.ArmorColdResist = 2;
    horned.ArmorPoisonResist = 2;
    horned.ArmorEnergyResist = 2;
    horned.RunicMinAttributes = 3;
    horned.RunicMaxAttributes = 4;
    if ( Core.ML )
    {
    horned.RunicMinIntensity = 45;
    horned.RunicMaxIntensity = 100;
    }
    else
    {
    horned.RunicMinIntensity = 30;
    horned.RunicMaxIntensity = 70;
    }
    CraftAttributeInfo barbed = Barbed = new CraftAttributeInfo();
    barbed.ArmorPhysicalResist = 2;
    barbed.ArmorFireResist = 1;
    barbed.ArmorColdResist = 2;
    barbed.ArmorPoisonResist = 3;
    barbed.ArmorEnergyResist = 4;
    barbed.RunicMinAttributes = 4;
    barbed.RunicMaxAttributes = 5;
    if ( Core.ML )
    {
    barbed.RunicMinIntensity = 50;
    barbed.RunicMaxIntensity = 100;
    }
    else
    {
    barbed.RunicMinIntensity = 40;
    barbed.RunicMaxIntensity = 100;
    }
    CraftAttributeInfo red = RedScales = new CraftAttributeInfo();
    red.ArmorFireResist = 10;
    red.ArmorColdResist = -3;
    CraftAttributeInfo yellow = YellowScales = new CraftAttributeInfo();
    yellow.ArmorPhysicalResist = -3;
    yellow.ArmorLuck = 20;
    CraftAttributeInfo black = BlackScales = new CraftAttributeInfo();
    black.ArmorPhysicalResist = 10;
    black.ArmorEnergyResist = -3;
    CraftAttributeInfo green = GreenScales = new CraftAttributeInfo();
    green.ArmorFireResist = -3;
    green.ArmorPoisonResist = 10;
    CraftAttributeInfo white = WhiteScales = new CraftAttributeInfo();
    white.ArmorPhysicalResist = -3;
    white.ArmorColdResist = 10;
    CraftAttributeInfo blue = BlueScales = new CraftAttributeInfo();
    blue.ArmorPoisonResist = -3;
    blue.ArmorEnergyResist = 10;
    //public static readonly CraftAttributeInfo OakWood, AshWood, YewWood, Heartwood, Bloodwood, Frostwood;
    CraftAttributeInfo oak = OakWood = new CraftAttributeInfo();
    CraftAttributeInfo ash = AshWood = new CraftAttributeInfo();
    CraftAttributeInfo yew = YewWood = new CraftAttributeInfo();
    CraftAttributeInfo heart = Heartwood = new CraftAttributeInfo();
    CraftAttributeInfo blood = Bloodwood = new CraftAttributeInfo();
    CraftAttributeInfo frost = Frostwood = new CraftAttributeInfo();
    }
    }
    public class CraftResourceInfo
    {
    private int m_Hue;
    private int m_Number;
    private string m_Name;
    private CraftAttributeInfo m_AttributeInfo;
    private CraftResource m_Resource;
    private Type[] m_ResourceTypes;
    public int Hue{ get{ return m_Hue; } }
    public int Number{ get{ return m_Number; } }
    public string Name{ get{ return m_Name; } }
    public CraftAttributeInfo AttributeInfo{ get{ return m_AttributeInfo; } }
    public CraftResource Resource{ get{ return m_Resource; } }
    public Type[] ResourceTypes{ get{ return m_ResourceTypes; } }
    public CraftResourceInfo( int hue, int number, string name, CraftAttributeInfo attributeInfo, CraftResource resource, params Type[] resourceTypes )
    {
    m_Hue = hue;
    m_Number = number;
    m_Name = name;
    m_AttributeInfo = attributeInfo;
    m_Resource = resource;
    m_ResourceTypes = resourceTypes;
    for ( int i = 0; i < resourceTypes.Length; ++i )
    CraftResources.RegisterType( resourceTypes, resource );
    }
    }
    public class CraftResources
    {
    private static CraftResourceInfo[] m_MetalInfo = new CraftResourceInfo[]
    {
    new CraftResourceInfo( 0x000, 1053109, "Iron", CraftAttributeInfo.Blank, CraftResource.Iron, typeof( IronIngot ), typeof( IronOre ), typeof( Granite ) ),
    new CraftResourceInfo( 0x973, 1053108, "Dull Copper", CraftAttributeInfo.DullCopper, CraftResource.DullCopper, typeof( DullCopperIngot ), typeof( DullCopperOre ), typeof( DullCopperGranite ) ),
    new CraftResourceInfo( 0x966, 1053107, "Shadow Iron", CraftAttributeInfo.ShadowIron, CraftResource.ShadowIron, typeof( ShadowIronIngot ), typeof( ShadowIronOre ), typeof( ShadowIronGranite ) ),
    new CraftResourceInfo( 0x96D, 1053106, "Copper", CraftAttributeInfo.Copper, CraftResource.Copper, typeof( CopperIngot ), typeof( CopperOre ), typeof( CopperGranite ) ),
    new CraftResourceInfo( 0x972, 1053105, "Bronze", CraftAttributeInfo.Bronze, CraftResource.Bronze, typeof( BronzeIngot ), typeof( BronzeOre ), typeof( BronzeGranite ) ),
    new CraftResourceInfo( 0x8A5, 1053104, "Golden", CraftAttributeInfo.Golden, CraftResource.Gold, typeof( GoldIngot ), typeof( GoldOre ), typeof( GoldGranite ) ),
    new CraftResourceInfo( 0x979, 1053103, "Agapite", CraftAttributeInfo.Agapite, CraftResource.Agapite, typeof( AgapiteIngot ), typeof( AgapiteOre ), typeof( AgapiteGranite ) ),
    new CraftResourceInfo( 0x89F, 1053102, "Verite", CraftAttributeInfo.Verite, CraftResource.Verite, typeof( VeriteIngot ), typeof( VeriteOre ), typeof( VeriteGranite ) ),
    new CraftResourceInfo( 0x8AB, 1053101, "Valorite", CraftAttributeInfo.Valorite, CraftResource.Valorite, typeof( ValoriteIngot ), typeof( ValoriteOre ), typeof( ValoriteGranite ) ),
    new CraftResourceInfo( 0xA08, 1061354, "Silver", CraftAttributeInfo.Silver, CraftResource.Silver, typeof( SilverIngot ), typeof( SilverOre ), typeof( SilverGranite ) ),
    };


    private static CraftResourceInfo[] m_ScaleInfo = new CraftResourceInfo[]
    {
    new CraftResourceInfo( 0x66D, 1053129, "Red Scales", CraftAttributeInfo.RedScales, CraftResource.RedScales, typeof( RedScales ) ),
    new CraftResourceInfo( 0x8A8, 1053130, "Yellow Scales", CraftAttributeInfo.YellowScales, CraftResource.YellowScales, typeof( YellowScales ) ),
    new CraftResourceInfo( 0x455, 1053131, "Black Scales", CraftAttributeInfo.BlackScales, CraftResource.BlackScales, typeof( BlackScales ) ),
    new CraftResourceInfo( 0x851, 1053132, "Green Scales", CraftAttributeInfo.GreenScales, CraftResource.GreenScales, typeof( GreenScales ) ),
    new CraftResourceInfo( 0x8FD, 1053133, "White Scales", CraftAttributeInfo.WhiteScales, CraftResource.WhiteScales, typeof( WhiteScales ) ),
    new CraftResourceInfo( 0x8B0, 1053134, "Blue Scales", CraftAttributeInfo.BlueScales, CraftResource.BlueScales, typeof( BlueScales ) )
    };
    private static CraftResourceInfo[] m_LeatherInfo = new CraftResourceInfo[]
    {
    new CraftResourceInfo( 0x000, 1049353, "Normal", CraftAttributeInfo.Blank, CraftResource.RegularLeather, typeof( Leather ), typeof( Hides ) ),
    new CraftResourceInfo( 0x283, 1049354, "Spined", CraftAttributeInfo.Spined, CraftResource.SpinedLeather, typeof( SpinedLeather ), typeof( SpinedHides ) ),
    new CraftResourceInfo( 0x227, 1049355, "Horned", CraftAttributeInfo.Horned, CraftResource.HornedLeather, typeof( HornedLeather ), typeof( HornedHides ) ),
    new CraftResourceInfo( 0x1C1, 1049356, "Barbed", CraftAttributeInfo.Barbed, CraftResource.BarbedLeather, typeof( BarbedLeather ), typeof( BarbedHides ) )
    };
    private static CraftResourceInfo[] m_AOSLeatherInfo = new CraftResourceInfo[]
    {
    new CraftResourceInfo( 0x000, 1049353, "Normal", CraftAttributeInfo.Blank, CraftResource.RegularLeather, typeof( Leather ), typeof( Hides ) ),
    new CraftResourceInfo( 0x8AC, 1049354, "Spined", CraftAttributeInfo.Spined, CraftResource.SpinedLeather, typeof( SpinedLeather ), typeof( SpinedHides ) ),
    new CraftResourceInfo( 0x845, 1049355, "Horned", CraftAttributeInfo.Horned, CraftResource.HornedLeather, typeof( HornedLeather ), typeof( HornedHides ) ),
    new CraftResourceInfo( 0x851, 1049356, "Barbed", CraftAttributeInfo.Barbed, CraftResource.BarbedLeather, typeof( BarbedLeather ), typeof( BarbedHides ) ),
    };
    private static CraftResourceInfo[] m_WoodInfo = new CraftResourceInfo[]
    {
    new CraftResourceInfo( 0x000, 1011542, "Normal", CraftAttributeInfo.Blank, CraftResource.RegularWood, typeof( Log ), typeof( Board ) ),
    new CraftResourceInfo( 0x7DA, 1072533, "Oak", CraftAttributeInfo_OakWood, CraftResource.OakWood, typeof( OakLog ), typeof( OakBoard ) ),
    new CraftResourceInfo( 0x4A7, 1072534, "Ash", CraftAttributeInfo.AshWood, CraftResource.AshWood, typeof( AshLog ), typeof( AshBoard ) ),
    new CraftResourceInfo( 0x4A8, 1072535, "Yew", CraftAttributeInfo.YewWood, CraftResource.YewWood, typeof( YewLog ), typeof( YewBoard ) ),
    new CraftResourceInfo( 0x4A9, 1072536, "Heartwood", CraftAttributeInfo.Heartwood, CraftResource.Heartwood, typeof( HeartwoodLog ), typeof( HeartwoodBoard ) ),
    new CraftResourceInfo( 0x4AA, 1072538, "Bloodwood", CraftAttributeInfo.Bloodwood, CraftResource.Bloodwood, typeof( BloodwoodLog ), typeof( BloodwoodBoard ) ),
    new CraftResourceInfo( 0x47F, 1072539, "Frostwood", CraftAttributeInfo.Frostwood, CraftResource.Frostwood, typeof( FrostwoodLog ), typeof( FrostwoodBoard ) )
    };
    /// <summary>
    /// Returns true if '<paramref name="resource"/>' is None, Iron, RegularLeather or RegularWood. False if otherwise.
    /// </summary>
    public static bool IsStandard( CraftResource resource )
    {
    return ( resource == CraftResource.None || resource == CraftResource.Iron || resource == CraftResource.RegularLeather || resource == CraftResource.RegularWood );
    }
    private static Hashtable m_TypeTable;
    /// <summary>
    /// Registers that '<paramref name="resourceType"/>' uses '<paramref name="resource"/>' so that it can later be queried by <see cref="CraftResources.GetFromType"/>
    /// </summary>
    public static void RegisterType( Type resourceType, CraftResource resource )
    {
    if ( m_TypeTable == null )
    m_TypeTable = new Hashtable();
    m_TypeTable[resourceType] = resource;
    }
    /// <summary>
    /// Returns the <see cref="CraftResource"/> value for which '<paramref name="resourceType"/>' uses -or- CraftResource.None if an unregistered type was specified.
    /// </summary>
    public static CraftResource GetFromType( Type resourceType )
    {
    if ( m_TypeTable == null )
    return CraftResource.None;
    object obj = m_TypeTable[resourceType];
    if ( !(obj is CraftResource) )
    return CraftResource.None;
    return (CraftResource)obj;
    }
    /// <summary>
    /// Returns a <see cref="CraftResourceInfo"/> instance describing '<paramref name="resource"/>' -or- null if an invalid resource was specified.
    /// </summary>
    public static CraftResourceInfo GetInfo( CraftResource resource )
    {
    CraftResourceInfo[] list = null;
    switch ( GetType( resource ) )
    {
    case CraftResourceType.Metal: list = m_MetalInfo; break;
    case CraftResourceType.Leather: list = Core.AOS ? m_AOSLeatherInfo : m_LeatherInfo; break;
    case CraftResourceType.Scales: list = m_ScaleInfo; break;
    case CraftResourceType.Wood: list = m_WoodInfo; break;
    }
    if ( list != null )
    {
    int index = GetIndex( resource );
    if ( index >= 0 && index < list.Length )
    return list[index];
    }
    return null;
    }
    /// <summary>
    /// Returns a <see cref="CraftResourceType"/> value indiciating the type of '<paramref name="resource"/>'.
    /// </summary>
    public static CraftResourceType GetType( CraftResource resource )
    {
    if ( resource >= CraftResource.Iron && resource <= CraftResource.Silver )
    return CraftResourceType.Metal;
    if ( resource >= CraftResource.RegularLeather && resource <= CraftResource.BarbedLeather )
    return CraftResourceType.Leather;
    if ( resource >= CraftResource.RedScales && resource <= CraftResource.BlueScales )
    return CraftResourceType.Scales;
    if ( resource >= CraftResource.RegularWood && resource <= CraftResource.Frostwood )
    return CraftResourceType.Wood;
    return CraftResourceType.None;
    }
    /// <summary>
    /// Returns the first <see cref="CraftResource"/> in the series of resources for which '<paramref name="resource"/>' belongs.
    /// </summary>
    public static CraftResource GetStart( CraftResource resource )
    {
    switch ( GetType( resource ) )
    {
    case CraftResourceType.Metal: return CraftResource.Iron;
    case CraftResourceType.Leather: return CraftResource.RegularLeather;
    case CraftResourceType.Scales: return CraftResource.RedScales;
    case CraftResourceType.Wood: return CraftResource.RegularWood;
    }
    return CraftResource.None;
    }
    /// <summary>
    /// Returns the index of '<paramref name="resource"/>' in the seriest of resources for which it belongs.
    /// </summary>
    public static int GetIndex( CraftResource resource )
    {
    CraftResource start = GetStart( resource );
    if ( start == CraftResource.None )
    return 0;
    return (int)(resource - start);
    }
    /// <summary>
    /// Returns the <see cref="CraftResourceInfo.Number"/> property of '<paramref name="resource"/>' -or- 0 if an invalid resource was specified.
    /// </summary>
    public static int GetLocalizationNumber( CraftResource resource )
    {
    CraftResourceInfo info = GetInfo( resource );
    return ( info == null ? 0 : info.Number );
    }
    /// <summary>
    /// Returns the <see cref="CraftResourceInfo.Hue"/> property of '<paramref name="resource"/>' -or- 0 if an invalid resource was specified.
    /// </summary>
    public static int GetHue( CraftResource resource )
    {
    CraftResourceInfo info = GetInfo( resource );
    return ( info == null ? 0 : info.Hue );
    }
    /// <summary>
    /// Returns the <see cref="CraftResourceInfo.Name"/> property of '<paramref name="resource"/>' -or- an empty string if the resource specified was invalid.
    /// </summary>
    public static string GetName( CraftResource resource )
    {
    CraftResourceInfo info = GetInfo( resource );
    return ( info == null ? String.Empty : info.Name );
    }
    /// <summary>
    /// Returns the <see cref="CraftResource"/> value which represents '<paramref name="info"/>' -or- CraftResource.None if unable to convert.
    /// </summary>
    public static CraftResource GetFromOreInfo( OreInfo info )
    {
    if ( info.Name.IndexOf( "Spined" ) >= 0 )
    return CraftResource.SpinedLeather;
    else if ( info.Name.IndexOf( "Horned" ) >= 0 )
    return CraftResource.HornedLeather;
    else if ( info.Name.IndexOf( "Barbed" ) >= 0 )
    return CraftResource.BarbedLeather;
    else if ( info.Name.IndexOf( "Leather" ) >= 0 )
    return CraftResource.RegularLeather;
    if ( info.Level == 0 )
    return CraftResource.Iron;
    else if ( info.Level == 1 )
    return CraftResource.DullCopper;
    else if ( info.Level == 2 )
    return CraftResource.ShadowIron;
    else if ( info.Level == 3 )
    return CraftResource.Copper;
    else if ( info.Level == 4 )
    return CraftResource.Bronze;
    else if (info.Level == 5)
    return CraftResource.Gold;
    else if ( info.Level == 6 )
    return CraftResource.Agapite;
    else if ( info.Level == 7 )
    return CraftResource.Verite;
    else if ( info.Level == 8 )
    return CraftResource.Valorite;
    else if (info.Level == 9)
    return CraftResource.Silver;
    else if (info.Level == 10)
    return CraftResource.None;
    }
    /// <summary>
    /// Returns the <see cref="CraftResource"/> value which represents '<paramref name="info"/>', using '<paramref name="material"/>' to help resolve leather OreInfo instances.
    /// </summary>
    public static CraftResource GetFromOreInfo( OreInfo info, ArmorMaterialType material )
    {
    if ( material == ArmorMaterialType.Studded || material == ArmorMaterialType.Leather || material == ArmorMaterialType.Spined ||
    material == ArmorMaterialType.Horned || material == ArmorMaterialType.Barbed )
    {
    if ( info.Level == 0 )
    return CraftResource.RegularLeather;
    else if ( info.Level == 1 )
    return CraftResource.SpinedLeather;
    else if ( info.Level == 2 )
    return CraftResource.HornedLeather;
    else if ( info.Level == 3 )
    return CraftResource.BarbedLeather;
    return CraftResource.None;
    }
    return GetFromOreInfo( info );
    }
    }
    // NOTE: This class is only for compatability with very old RunUO versions.
    // No changes to it should be required for custom resources.
    public class OreInfo
    {
    public static readonly OreInfo Iron = new OreInfo( 0, 0x000, "Iron" );
    public static readonly OreInfo DullCopper = new OreInfo( 1, 0x973, "Dull Copper" );
    public static readonly OreInfo ShadowIron = new OreInfo( 2, 0x966, "Shadow Iron" );
    public static readonly OreInfo Copper = new OreInfo( 3, 0x96D, "Copper" );
    public static readonly OreInfo Bronze = new OreInfo( 4, 0x972, "Bronze" );
    public static readonly OreInfo Gold = new OreInfo( 5, 0x8A5, "Gold" );
    public static readonly OreInfo Agapite = new OreInfo( 6, 0x979, "Agapite" );
    public static readonly OreInfo Verite = new OreInfo( 7, 0x89F, "Verite" );
    public static readonly OreInfo Valorite = new OreInfo( 8, 0x8AB, "Valorite" );
    public static readonly OreInfo Silver = new OreInfo( 9, 0xA08, "Silver");
    private int m_Level;
    private int m_Hue;
    private string m_Name;
    public OreInfo( int level, int hue, string name )
    {
    m_Level = level;
    m_Hue = hue;
    m_Name = name;
    }
    public int Level
    {
    get
    {
    return m_Level;
    }
    }
    public int Hue
    {
    get
    {
    return m_Hue;
    }
    }
    public string Name
    {
    get
    {
    return m_Name;
    }
    }
    }
    }
     

    Attached Files:

  6. Po0ka
    Offline

    Po0ka Active Member

    Joined:
    Aug 19, 2014
    Messages:
    704
    Likes Received:
    83
    Please, do not paste the content of the files in your thread, they take space, aren't formatted and are hard to read.
    I will take a look at those files.
    --- Double Post Merged, Feb 16, 2019 at 8:21 PM ---
    That shoud suffice.
    Be careful what you paste in your code and where you paste it; a computer will do litterally what you ask it to do in a format it expects, forgetting even the smallest semi-column somewhere in c# can prevent it from compiling as it can't be processed correctly.

    classdefinition.png commas.png
    See attachments.
    If you have further questions resulting of this, do not hesitate.
     
    #6 Po0ka, Feb 16, 2019 at 8:01 PM
    Last edited: Feb 16, 2019 at 8:23 PM
  7. Fred1990
    Offline

    Fred1990 Member

    Joined:
    Jan 23, 2019
    Messages:
    31
    Likes Received:
    1
    Hi Pooka thanks for your reply and tips, so even if silver is the last methos I need to put only 2 braces? because visual studio says error .
    I will try soon and see if runuo works:) .
    --- Double Post Merged, Feb 17, 2019 at 6:40 AM ---
    I tried how you say leaving only 2 braces at the end but I got this;

    + Items / Resources / Blacksmithing / Ingots.cs:
    CS1513: Line 460: The sign is expected}
    CS1513: Line 460: The sign is expected}
     
  8. Po0ka
    Offline

    Po0ka Active Member

    Joined:
    Aug 19, 2014
    Messages:
    704
    Likes Received:
    83
    I need to see the files you have edited
     
  9. Fred1990
    Offline

    Fred1990 Member

    Joined:
    Jan 23, 2019
    Messages:
    31
    Likes Received:
    1
    Sure, here it the ingot.cs
     

    Attached Files:

  10. Po0ka
    Offline

    Po0ka Active Member

    Joined:
    Aug 19, 2014
    Messages:
    704
    Likes Received:
    83
    You did not fix the main issue, SilverIngot is still inside ValoriteIngot.
    Check where the brackets start and end, they must always be in pair somewhere.
     
  11. Fred1990
    Offline

    Fred1990 Member

    Joined:
    Jan 23, 2019
    Messages:
    31
    Likes Received:
    1
    KK I got it :) I will try and let you know
     
Similar Threads: tutorial custom
Forum Title Date
ServUO Tutorials Yet Another Debian ServUO Tutorial Dec 8, 2018
3rd Party Support UO Centered Tutorials? Jun 26, 2018
3rd Party Support Tutorial on Map Conversion using EssenceUDK.Tools for CentrED+ Jun 9, 2018
Documentation New Haven Tutorial for the EC (video) Nov 5, 2017
ServUO Tutorials AccessLevel Tutorial [Deleted] Jun 17, 2017
General Discussion Create gump tutorial? Jul 15, 2016
Documentation How to write a tutorial Jan 21, 2016