Mob entities all added, entity factory created.

This commit is contained in:
Justin Aquadro 2011-04-06 18:57:05 +00:00
parent 722c27c873
commit 7364a1cf5f
3 changed files with 885 additions and 102 deletions

View file

@ -44,7 +44,7 @@ namespace Substrate.Map
private short _air;
private byte _onGround;
private string? _world;
private string _world;
public string ID
{
@ -124,100 +124,9 @@ namespace Substrate.Map
}
#region Predefined Schemas
public static readonly NBTCompoundNode MobSchema = BaseSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Mob"),
new NBTScalerNode("AttackTime", NBT_Type.TAG_SHORT),
new NBTScalerNode("DeathTime", NBT_Type.TAG_SHORT),
new NBTScalerNode("Health", NBT_Type.TAG_SHORT),
new NBTScalerNode("HurtTime", NBT_Type.TAG_SHORT),
});
public static readonly NBTCompoundNode MonsterSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Monster"),
});
public static readonly NBTCompoundNode CreeperSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Creeper"),
});
public static readonly NBTCompoundNode SkeletonSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Skeleton"),
});
public static readonly NBTCompoundNode SpiderSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Spider"),
});
public static readonly NBTCompoundNode GiantSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Giant"),
});
public static readonly NBTCompoundNode ZombieSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Zombie"),
});
public static readonly NBTCompoundNode PigZombieSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "PigZombie"),
});
public static readonly NBTCompoundNode GhastSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Ghast"),
});
public static readonly NBTCompoundNode PigSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Pig"),
new NBTScalerNode("Saddle", NBT_Type.TAG_BYTE),
});
public static readonly NBTCompoundNode SheepSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Sheep"),
new NBTScalerNode("Sheared", NBT_Type.TAG_BYTE),
new NBTScalerNode("Color", NBT_Type.TAG_BYTE),
});
public static readonly NBTCompoundNode CowSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Cow"),
});
public static readonly NBTCompoundNode ChickenSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Chicken"),
});
public static readonly NBTCompoundNode Slimechema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Slime"),
new NBTScalerNode("Size", NBT_Type.TAG_INT),
});
public static readonly NBTCompoundNode WolfSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Wolf"),
new NBTScalerNode("Owner", NBT_Type.TAG_STRING),
new NBTScalerNode("Sitting", NBT_Type.TAG_BYTE),
new NBTScalerNode("Angry", NBT_Type.TAG_BYTE),
});
#endregion
#region INBTObject<Entity> Members
public Entity LoadTree (NBT_Value tree)
public virtual Entity LoadTree (NBT_Value tree)
{
NBT_Compound ctree = tree as NBT_Compound;
if (ctree == null) {
@ -257,7 +166,7 @@ namespace Substrate.Map
return this;
}
public Entity LoadTreeSafe (NBT_Value tree)
public virtual Entity LoadTreeSafe (NBT_Value tree)
{
if (!ValidateTree(tree)) {
return null;
@ -266,7 +175,7 @@ namespace Substrate.Map
return LoadTree(tree);
}
public NBT_Value BuildTree ()
public virtual NBT_Value BuildTree ()
{
NBT_Compound tree = new NBT_Compound();
tree["id"] = new NBT_String(_id);
@ -294,13 +203,13 @@ namespace Substrate.Map
tree["OnGround"] = new NBT_Byte(_onGround);
if (_world != null) {
tree["World"] = new NBT_String(_world.GetValueOrDefault());
tree["World"] = new NBT_String(_world);
}
return tree;
}
public bool ValidateTree (NBT_Value tree)
public virtual bool ValidateTree (NBT_Value tree)
{
return new NBTVerifier(tree, BaseSchema).Verify();
}
@ -310,7 +219,7 @@ namespace Substrate.Map
#region ICopyable<Entity> Members
public Entity Copy ()
public virtual Entity Copy ()
{
return new Entity(this);
}
@ -320,6 +229,807 @@ namespace Substrate.Map
public class EntityMob : Entity
{
public static readonly NBTCompoundNode MobSchema = BaseSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Mob"),
new NBTScalerNode("AttackTime", NBT_Type.TAG_SHORT),
new NBTScalerNode("DeathTime", NBT_Type.TAG_SHORT),
new NBTScalerNode("Health", NBT_Type.TAG_SHORT),
new NBTScalerNode("HurtTime", NBT_Type.TAG_SHORT),
});
private short _attackTime;
private short _deathTime;
private short _health;
private short _hurtTime;
public int AttackTime
{
get { return _attackTime; }
set { _attackTime = (short)value; }
}
public int DeathTime
{
get { return _deathTime; }
set { _deathTime = (short)value; }
}
public int Health
{
get { return _health; }
set { _health = (short)value; }
}
public int HurtTime
{
get { return _hurtTime; }
set { _hurtTime = (short)value; }
}
public EntityMob ()
: base("Mob")
{
}
public EntityMob (string id)
: base(id)
{
}
public EntityMob (Entity e)
: base(e)
{
EntityMob e2 = e as EntityMob;
if (e2 != null) {
_attackTime = e2._attackTime;
_deathTime = e2._deathTime;
_health = e2._health;
_hurtTime = e2._hurtTime;
}
}
#region INBTObject<Entity> Members
public override Entity LoadTree (NBT_Value tree)
{
NBT_Compound ctree = tree as NBT_Compound;
if (ctree == null || base.LoadTree(tree) == null) {
return null;
}
_attackTime = ctree["AttackTime"].ToNBTShort();
_deathTime = ctree["DeathTime"].ToNBTShort();
_health = ctree["Health"].ToNBTShort();
_hurtTime = ctree["HurtTime"].ToNBTShort();
return this;
}
public override NBT_Value BuildTree ()
{
NBT_Compound tree = base.BuildTree() as NBT_Compound;
tree["AttackTime"] = new NBT_Short(_attackTime);
tree["DeathTime"] = new NBT_Short(_deathTime);
tree["Health"] = new NBT_Short(_health);
tree["HurtTime"] = new NBT_Short(_hurtTime);
return tree;
}
public override bool ValidateTree (NBT_Value tree)
{
return new NBTVerifier(tree, MobSchema).Verify();
}
#endregion
#region ICopyable<Entity> Members
public override Entity Copy ()
{
return new EntityMob(this);
}
#endregion
}
public class EntityMonster : EntityMob
{
public static readonly NBTCompoundNode MonsterSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Monster"),
});
public EntityMonster ()
: base("Monster")
{
}
public EntityMonster (Entity e)
: base(e)
{
}
#region INBTObject<Entity> Members
public override bool ValidateTree (NBT_Value tree)
{
return new NBTVerifier(tree, MonsterSchema).Verify();
}
#endregion
#region ICopyable<Entity> Members
public override Entity Copy ()
{
return new EntityMonster(this);
}
#endregion
}
public class EntityCreeper : EntityMob
{
public static readonly NBTCompoundNode CreeperSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Creeper"),
});
public EntityCreeper ()
: base("Creeper")
{
}
public EntityCreeper (Entity e)
: base(e)
{
}
#region INBTObject<Entity> Members
public override bool ValidateTree (NBT_Value tree)
{
return new NBTVerifier(tree, CreeperSchema).Verify();
}
#endregion
#region ICopyable<Entity> Members
public override Entity Copy ()
{
return new EntityCreeper(this);
}
#endregion
}
public class EntitySkeleton : EntityMob
{
public static readonly NBTCompoundNode SkeletonSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Skeleton"),
});
public EntitySkeleton ()
: base("Skeleton")
{
}
public EntitySkeleton (Entity e)
: base(e)
{
}
#region INBTObject<Entity> Members
public override bool ValidateTree (NBT_Value tree)
{
return new NBTVerifier(tree, SkeletonSchema).Verify();
}
#endregion
#region ICopyable<Entity> Members
public override Entity Copy ()
{
return new EntitySkeleton(this);
}
#endregion
}
public class EntitySpider : EntityMob
{
public static readonly NBTCompoundNode SpiderSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Spider"),
});
public EntitySpider ()
: base("Spider")
{
}
public EntitySpider (Entity e)
: base(e)
{
}
#region INBTObject<Entity> Members
public override bool ValidateTree (NBT_Value tree)
{
return new NBTVerifier(tree, SpiderSchema).Verify();
}
#endregion
#region ICopyable<Entity> Members
public override Entity Copy ()
{
return new EntitySpider(this);
}
#endregion
}
public class EntityGiant : EntityMob
{
public static readonly NBTCompoundNode GiantSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Giant"),
});
public EntityGiant ()
: base("Giant")
{
}
public EntityGiant (Entity e)
: base(e)
{
}
#region INBTObject<Entity> Members
public override bool ValidateTree (NBT_Value tree)
{
return new NBTVerifier(tree, GiantSchema).Verify();
}
#endregion
#region ICopyable<Entity> Members
public override Entity Copy ()
{
return new EntityGiant(this);
}
#endregion
}
public class EntityZombie : EntityMob
{
public static readonly NBTCompoundNode ZombieSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Zombie"),
});
public EntityZombie ()
: base("Zombie")
{
}
public EntityZombie (Entity e)
: base(e)
{
}
#region INBTObject<Entity> Members
public override bool ValidateTree (NBT_Value tree)
{
return new NBTVerifier(tree, ZombieSchema).Verify();
}
#endregion
#region ICopyable<Entity> Members
public override Entity Copy ()
{
return new EntityZombie(this);
}
#endregion
}
public class EntitySlime : EntityMob
{
public static readonly NBTCompoundNode SlimeSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Slime"),
new NBTScalerNode("Size", NBT_Type.TAG_INT),
});
private int _size;
public int Size
{
get { return _size; }
set { _size = value; }
}
public EntitySlime ()
: base("Slime")
{
}
public EntitySlime (Entity e)
: base(e)
{
EntitySlime e2 = e as EntitySlime;
if (e2 != null) {
_size = e2._size;
}
}
#region INBTObject<Entity> Members
public override Entity LoadTree (NBT_Value tree)
{
NBT_Compound ctree = tree as NBT_Compound;
if (ctree == null || base.LoadTree(tree) == null) {
return null;
}
_size = ctree["Size"].ToNBTInt();
return this;
}
public override NBT_Value BuildTree ()
{
NBT_Compound tree = base.BuildTree() as NBT_Compound;
tree["Size"] = new NBT_Int(_size);
return tree;
}
public override bool ValidateTree (NBT_Value tree)
{
return new NBTVerifier(tree, SlimeSchema).Verify();
}
#endregion
#region ICopyable<Entity> Members
public override Entity Copy ()
{
return new EntitySlime(this);
}
#endregion
}
public class EntityPigZombie : EntityMob
{
public static readonly NBTCompoundNode PigZombieSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "PigZombie"),
});
public EntityPigZombie ()
: base("PigZombie")
{
}
public EntityPigZombie (Entity e)
: base(e)
{
}
#region INBTObject<Entity> Members
public override bool ValidateTree (NBT_Value tree)
{
return new NBTVerifier(tree, PigZombieSchema).Verify();
}
#endregion
#region ICopyable<Entity> Members
public override Entity Copy ()
{
return new EntityPigZombie(this);
}
#endregion
}
public class EntityGhast : EntityMob
{
public static readonly NBTCompoundNode GhastSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Ghast"),
});
public EntityGhast ()
: base("Ghast")
{
}
public EntityGhast (Entity e)
: base(e)
{
}
#region INBTObject<Entity> Members
public override bool ValidateTree (NBT_Value tree)
{
return new NBTVerifier(tree, GhastSchema).Verify();
}
#endregion
#region ICopyable<Entity> Members
public override Entity Copy ()
{
return new EntityGhast(this);
}
#endregion
}
public class EntityPig : EntityMob
{
public static readonly NBTCompoundNode PigSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Pig"),
new NBTScalerNode("Saddle", NBT_Type.TAG_BYTE),
});
private bool _saddle;
public bool HasSaddle
{
get { return _saddle; }
set { _saddle = value; }
}
public EntityPig ()
: base("Pig")
{
}
public EntityPig (Entity e)
: base(e)
{
EntityPig e2 = e as EntityPig;
if (e2 != null) {
_saddle = e2._saddle;
}
}
#region INBTObject<Entity> Members
public override Entity LoadTree (NBT_Value tree)
{
NBT_Compound ctree = tree as NBT_Compound;
if (ctree == null || base.LoadTree(tree) == null) {
return null;
}
_saddle = ctree["Saddle"].ToNBTByte() == 1;
return this;
}
public override NBT_Value BuildTree ()
{
NBT_Compound tree = base.BuildTree() as NBT_Compound;
tree["Saddle"] = new NBT_Byte((byte)(_saddle ? 1 : 0));
return tree;
}
public override bool ValidateTree (NBT_Value tree)
{
return new NBTVerifier(tree, PigSchema).Verify();
}
#endregion
#region ICopyable<Entity> Members
public override Entity Copy ()
{
return new EntityPig(this);
}
#endregion
}
public class EntitySheep : EntityMob
{
public static readonly NBTCompoundNode SheepSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Pig"),
new NBTScalerNode("Sheared", NBT_Type.TAG_BYTE),
new NBTScalerNode("Color", NBT_Type.TAG_BYTE),
});
private bool _sheared;
private byte _color;
public bool IsSheared
{
get { return _sheared; }
set { _sheared = value; }
}
public int Color
{
get { return _color; }
set { _color = (byte)value; }
}
public EntitySheep ()
: base("Sheep")
{
}
public EntitySheep (Entity e)
: base(e)
{
EntitySheep e2 = e as EntitySheep;
if (e2 != null) {
_sheared = e2._sheared;
_color = e2._color;
}
}
#region INBTObject<Entity> Members
public override Entity LoadTree (NBT_Value tree)
{
NBT_Compound ctree = tree as NBT_Compound;
if (ctree == null || base.LoadTree(tree) == null) {
return null;
}
_sheared = ctree["Sheared"].ToNBTByte() == 1;
_color = ctree["Color"].ToNBTByte();
return this;
}
public override NBT_Value BuildTree ()
{
NBT_Compound tree = base.BuildTree() as NBT_Compound;
tree["Sheared"] = new NBT_Byte((byte)(_sheared ? 1 : 0));
tree["Color"] = new NBT_Byte(_color);
return tree;
}
public override bool ValidateTree (NBT_Value tree)
{
return new NBTVerifier(tree, SheepSchema).Verify();
}
#endregion
#region ICopyable<Entity> Members
public override Entity Copy ()
{
return new EntitySheep(this);
}
#endregion
}
public class EntityCow : EntityMob
{
public static readonly NBTCompoundNode CowSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Cow"),
});
public EntityCow ()
: base("Cow")
{
}
public EntityCow (Entity e)
: base(e)
{
}
#region INBTObject<Entity> Members
public override bool ValidateTree (NBT_Value tree)
{
return new NBTVerifier(tree, CowSchema).Verify();
}
#endregion
#region ICopyable<Entity> Members
public override Entity Copy ()
{
return new EntityCow(this);
}
#endregion
}
public class EntityChicken : EntityMob
{
public static readonly NBTCompoundNode ChickenSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Chicken"),
});
public EntityChicken ()
: base("Chicken")
{
}
public EntityChicken (Entity e)
: base(e)
{
}
#region INBTObject<Entity> Members
public override bool ValidateTree (NBT_Value tree)
{
return new NBTVerifier(tree, ChickenSchema).Verify();
}
#endregion
#region ICopyable<Entity> Members
public override Entity Copy ()
{
return new EntityChicken(this);
}
#endregion
}
public class EntityWolf : EntityMob
{
public static readonly NBTCompoundNode WolfSchema = MobSchema.MergeInto(new NBTCompoundNode("")
{
new NBTStringNode("id", "Wolf"),
new NBTScalerNode("Owner", NBT_Type.TAG_STRING),
new NBTScalerNode("Sitting", NBT_Type.TAG_BYTE),
new NBTScalerNode("Angry", NBT_Type.TAG_BYTE),
});
private string _owner;
private bool _sitting;
private bool _angry;
public string Owner
{
get { return _owner; }
set { _owner = value; }
}
public bool IsSitting
{
get { return _sitting; }
set { _sitting = value; }
}
public bool IsAngry
{
get { return _angry; }
set { _angry = value; }
}
public EntityWolf ()
: base("Wolf")
{
}
public EntityWolf (Entity e)
: base(e)
{
EntityWolf e2 = e as EntityWolf;
if (e2 != null) {
_owner = e2._owner;
_sitting = e2._sitting;
_angry = e2._angry;
}
}
#region INBTObject<Entity> Members
public override Entity LoadTree (NBT_Value tree)
{
NBT_Compound ctree = tree as NBT_Compound;
if (ctree == null || base.LoadTree(tree) == null) {
return null;
}
_owner = ctree["Owner"].ToNBTString();
_sitting = ctree["Sitting"].ToNBTByte() == 1;
_angry = ctree["Angry"].ToNBTByte() == 1;
return this;
}
public override NBT_Value BuildTree ()
{
NBT_Compound tree = base.BuildTree() as NBT_Compound;
tree["Owner"] = new NBT_String(_owner);
tree["Sitting"] = new NBT_Byte((byte)(_sitting ? 1 : 0));
tree["Angry"] = new NBT_Byte((byte)(_angry ? 1 : 0));
return tree;
}
public override bool ValidateTree (NBT_Value tree)
{
return new NBTVerifier(tree, WolfSchema).Verify();
}
#endregion
#region ICopyable<Entity> Members
public override Entity Copy ()
{
return new EntityPig(this);
}
#endregion
}
}

View file

@ -0,0 +1,73 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace Substrate.Map
{
using NBT;
public class EntityFactory
{
private static Dictionary<string, Type> _registry;
public static Entity Create (string type)
{
Type t;
if (!_registry.TryGetValue(type, out t)) {
return null;
}
return Activator.CreateInstance(t, new object[] { type} ) as Entity;
}
public static Entity Create (NBT_Compound tree)
{
string type = tree["id"].ToNBTString();
Type t;
if (!_registry.TryGetValue(type, out t)) {
return null;
}
Entity te = Activator.CreateInstance(t) as Entity;
return te.LoadTreeSafe(tree);
}
public static Type Lookup (string type)
{
Type t;
if (!_registry.TryGetValue(type, out t)) {
return null;
}
return t;
}
public static void Register (string id, Type subtype)
{
_registry[id] = subtype;
}
static EntityFactory ()
{
_registry = new Dictionary<string, Type>();
_registry["Chicken"] = typeof(EntityChicken);
_registry["Cow"] = typeof(EntityCow);
_registry["Creeper"] = typeof(EntityCreeper);
_registry["Ghast"] = typeof(EntityGhast);
_registry["Giant"] = typeof(EntityGiant);
_registry["Mob"] = typeof(EntityMob);
_registry["Monster"] = typeof(EntityMonster);
_registry["Pig"] = typeof(EntityPig);
_registry["PigZombie"] = typeof(EntityPigZombie);
_registry["Sheep"] = typeof(EntitySheep);
_registry["Skeleton"] = typeof(EntitySkeleton);
_registry["Slime"] = typeof(EntitySlime);
_registry["Spider"] = typeof(EntitySpider);
_registry["Wolf"] = typeof(EntityWolf);
_registry["Zombie"] = typeof(EntityZombie);
}
}
}

View file

@ -17,7 +17,7 @@ namespace Substrate.Map
return null;
}
return Activator.CreateInstance(t) as TileEntity;
return Activator.CreateInstance(t, new object[] { type }) as TileEntity;
}
public static TileEntity Create (NBT_Compound tree)
@ -29,7 +29,7 @@ namespace Substrate.Map
return null;
}
TileEntity te = Activator.CreateInstance(t, new object[] { tree }) as TileEntity;
TileEntity te = Activator.CreateInstance(t) as TileEntity;
return te.LoadTreeSafe(tree);
}