public GamePiece(AceObject aceO)
: base(aceO)
{
Stuck = true; Attackable = true;
SetObjectDescriptionBools();
}
protected override void LoadIntoObject(AceObject aceObject)
{
base.LoadIntoObject(aceObject);
aceObject.GeneratorLinks = GetAceObjectGeneratorLinks(aceObject.AceObjectId);
aceObject.GeneratorProfiles = GetAceObjectGeneratorProfiles(aceObject.AceObjectId);
aceObject.CreateList = GetAceObjectInventory(aceObject.AceObjectId);
}
public static WorldObject CreateWorldObject(uint weenieId, ObjectGuid guid, int palette = 0, float shade = 0, int stackSize = 1)
{
try
{
AceObject aceObject = (AceObject)DatabaseManager.World.GetAceObjectByWeenie(weenieId).Clone(guid.Full);
if (palette > 0)
{
aceObject.PaletteTemplate = palette;
}
if (shade > 0)
{
aceObject.Shade = shade;
}
if (aceObject.StackSize.HasValue && aceObject.MaxStackSize.HasValue)
{
if (stackSize > 1)
{
aceObject.StackSize = (ushort)stackSize;
}
if (aceObject.StackSize > aceObject.MaxStackSize)
{
aceObject.StackSize = aceObject.MaxStackSize;
}
}
return(CreateWorldObject(aceObject));
}
catch (NullReferenceException)
{
return(null);
}
}
public Monster(AceObject aceO)
: base(aceO)
{
Guid = GuidManager.NewNonStaticGuid();
IsAlive = true;
SetupVitals();
}
public Clothing(AceObject aceObject)
: base(aceObject)
{
Attackable = true;
SetObjectDescriptionBools();
}
public GenericObject(AceObject aceObject)
: base(aceObject)
{
Stuck = true; Attackable = true;
SetObjectDescriptionBools();
}
public Portal(AceObject aceO)
: base(aceO)
{
Portal = true;
Stuck = true; Attackable = true;
SetObjectDescriptionBools();
var weenie = Database.DatabaseManager.World.GetAceObjectByWeenie(AceObject.WeenieClassId);
// check to see if this ace object has a destination. if so, defer to it.
if (aceO.Destination != null)
{
Destination = aceO.Destination;
}
else
{
// but if not, portals roll up to the weenie
Destination = weenie.Destination;
}
MinimumLevel = weenie.MinLevel ?? 0;
MaximumLevel = weenie.MaxLevel ?? 0;
IsTieable = ((weenie.PortalBitmask ?? 0) & (uint)PortalBitmask.NoRecall) == 0;
IsSummonable = ((weenie.PortalBitmask ?? 0) & (uint)PortalBitmask.NoSummon) == 0;
AppraisalPortalDestination = weenie.AppraisalPortalDestination;
PortalShowDestination = weenie.PortalShowDestination ?? false;
}
public List <AceObject> GetWeenieInstancesByLandblock(ushort landblock)
{
var criteria = new Dictionary <string, object> {
{ "landblock", landblock }
};
var instances = ExecuteConstructedGetListStatement <WorldPreparedStatement, WeenieObjectInstance>(WorldPreparedStatement.GetWeenieInstancesByLandblock, criteria);
List <AceObject> ret = new List <AceObject>();
instances.ForEach(instance =>
{
// Create a new AceObject from Weenie.
AceObject ao = GetObject(instance.WeenieClassId);
// Set the object's current location for this instance.
ao.Location = new Position(instance.LandblockRaw, instance.PositionX, instance.PositionY, instance.PositionZ, instance.RotationX, instance.RotationY, instance.RotationZ, instance.RotationW);
// Use the guid recorded by the PCAP.
// This step could eventually be removed if we want to let the GuidManager handle assigning guids for static objects, ignoring the recorded guids.
string cmsClone = ao.CurrentMotionState; // Make a copy of the CurrentMotionState for cloning
ao = (AceObject)ao.Clone(instance.PreassignedGuid); // Clone AceObject and assign the recorded Guid
ao.CurrentMotionState = cmsClone; // Restore CurrentMotionState from original weenie
ret.Add(ao);
});
return(ret);
}
public static Container CreateTestContainerObject(Player player, uint weenieId)
{
AceObject aceObject = DatabaseManager.World.GetAceObjectByWeenie(weenieId);
Container wo = new Container(aceObject);
player.Session.Network.EnqueueSend(new GameEventViewContents(player.Session, wo.Guid.Full));
return(wo);
}
// todo : SO : Turning to player movement states - looks at @og
public Vendor(AceObject aceO)
: base(aceO)
{
Vendor = true;
Stuck = true; Attackable = true;
SetObjectDescriptionBools();
}
public bool SaveObject(AceObject weenie)
{
if (_weenieCache.ContainsKey(weenie.WeenieClassId))
{
_weenieCache[weenie.WeenieClassId] = weenie;
}
return(_wrappedDatabase.SaveObject(weenie));
}
public static WorldObject CreateWorldObject(AceObject aceO)
{
WeenieType objWeenieType = (WeenieType?)aceO.WeenieType ?? WeenieType.Generic;
switch (objWeenieType)
{
case WeenieType.LifeStone:
return(new Lifestone(aceO));
case WeenieType.Door:
return(new Door(aceO));
case WeenieType.Portal:
return(new Portal(aceO));
case WeenieType.Book:
return(new Book(aceO));
// case WeenieType.PKModifier:
// return new PKModifier(aceO);
case WeenieType.Cow:
return(new Cow(aceO));
case WeenieType.Creature:
return(new Creature(aceO));
case WeenieType.Container:
return(new Container(aceO));
case WeenieType.Scroll:
return(new Scroll(aceO));
case WeenieType.Vendor:
return(new Vendor(aceO));
case WeenieType.Coin:
return(new Coin(aceO));
case WeenieType.Key:
return(new Key(aceO));
case WeenieType.Food:
return(new Food(aceO));
case WeenieType.Gem:
return(new Gem(aceO));
case WeenieType.Game:
return(new Game(aceO));
case WeenieType.GamePiece:
return(new GamePiece(aceO));
default:
return(new GenericObject(aceO));
}
}
public bool ReplaceObject(AceObject aceObject)
{
if (_weenieCache.ContainsKey(aceObject.WeenieClassId))
{
_weenieCache[aceObject.WeenieClassId] = aceObject;
}
return(_wrappedDatabase.ReplaceObject(aceObject));
}
public void UpdateWeenie(AceObject weenie)
{
if (_weenieCache.ContainsKey(weenie.WeenieClassId))
{
_weenieCache[weenie.WeenieClassId] = weenie;
}
_wrappedDatabase.UpdateWeenie(weenie);
}
public Game(AceObject aceO)
: base(aceO)
{
Stuck = true; Attackable = true;
SetObjectDescriptionBools();
// Setup game variables...
// TODO: so much more than what's here now.
}
public Bindstone(AceObject aceObject)
: base(aceObject)
{
Stuck = true; Attackable = true;
SetObjectDescriptionBools();
RadarBehavior = global::ACE.Entity.Enum.RadarBehavior.ShowAlways;
RadarColor = global::ACE.Entity.Enum.RadarColor.LifeStone;
}
public Lifestone(AceObject aceO)
: base(aceO)
{
LifeStone = true;
Stuck = true; Attackable = true;
SetObjectDescriptionBools();
RadarColor = global::ACE.Entity.Enum.RadarColor.LifeStone;
}
public Key(AceObject aceO)
: base(aceO)
{
Attackable = true;
SetObjectDescriptionBools();
KeyCode = AceObject.KeyCode ?? "";
Structure = AceObject.Structure ?? AceObject.MaxStructure;
}
public static WorldObject CreateTestWorldObject(Player player, uint weenieId)
{
AceObject aceObject = DatabaseManager.World.GetAceObjectByWeenie(weenieId);
if (aceObject.ItemsCapacity >= 1)
{
return(CreateTestContainerObject(player, weenieId));
}
return(new GenericObject(aceObject));
}
public Cow(AceObject aceO)
: base(aceO)
{
Stuck = true; Attackable = true;
SetObjectDescriptionBools();
UseRadius = 1;
IsAlive = true;
SetupVitals();
}
public HttpResponseMessage Create([FromBody] AceObject request)
{
if (WorldDb.SaveObject(request))
{
return(Request.CreateResponse(HttpStatusCode.OK, new { message = "changes saved." }));
}
else
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, new { message = "Unable to save changes." }));
}
}
public Book(AceObject aceO)
: base(aceO)
{
Book = true;
Attackable = true;
SetObjectDescriptionBools();
Pages = PropertiesBook.Count; // Set correct Page Count for appraisal based on data actually in database.
MaxPages = MaxPages ?? 1; // If null, set MaxPages to 1.
}
public bool DeleteObject(AceObject aceObject)
{
AceObject weenie;
if (_weenieCache.ContainsKey(aceObject.WeenieClassId))
{
_weenieCache.TryRemove(aceObject.WeenieClassId, out weenie);
}
return(_wrappedDatabase.DeleteObject(aceObject));
}
public void SaveObject(AceObject aceObject, Action <bool> callback)
{
_queue.Add(new Task(() =>
{
var result = _wrappedDatabase.SaveObject(aceObject);
if (callback != null)
{
callback.Invoke(result);
}
}));
}
/// <summary>
/// Create a new monster at the specified position
/// </summary>
public static Monster SpawnMonster(AceObject aceO, Position position)
{
Monster newMonster = new Monster(aceO);
newMonster.Location = position;
newMonster.GeneratorId = aceO.GeneratorIID;
// newMonster.PhysicsData.DefaultScript = aceO.PhysicsScript;
// newMonster.DefaultScript = (uint)Network.Enum.PlayScript.Create;
return(newMonster);
}
public AceObject GetWorldObject(uint objId)
{
AceObject ret = new AceObject();
var criteria = new Dictionary <string, object> {
{ "aceObjectId", objId }
};
bool success = ExecuteConstructedGetStatement <AceObject, WorldPreparedStatement>(WorldPreparedStatement.GetAceObject, criteria, ret);
if (!success)
{
return(null);
}
return(ret);
}
public HttpResponseMessage Update([FromBody] AceObject request)
{
// force this to true, as we're explicitly doing an update
request.HasEverBeenSavedToDatabase = true;
if (WorldDb.ReplaceObject(request))
{
return(Request.CreateResponse(HttpStatusCode.OK, new { message = "changes saved." }));
}
else
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, new { message = "Unable to save changes." }));
}
}
public Door(AceObject aceO)
: base(aceO)
{
Door = true;
Stuck = true; Attackable = true;
SetObjectDescriptionBools();
// This likely will change to be based on reading a dat file to determine if this exists...
HasPhysicsBsp = true;
if (!DefaultOpen)
{
CurrentMotionState = motionStateClosed;
IsOpen = false;
Ethereal = false;
}
else
{
CurrentMotionState = motionStateOpen;
IsOpen = true;
Ethereal = true;
}
IsLocked = AceObject.Locked ?? false;
ResetInterval = AceObject.ResetInterval ?? 30.0f;
ResistLockpick = AceObject.ResistLockpick ?? 0;
LockCode = AceObject.LockCode ?? "";
// If we had the base weenies this would be the way to go
////if (DefaultLocked)
//// IsLocked = true;
////else
//// IsLocked = false;
// But since we don't know what doors were DefaultLocked, let's assume for now that any door that starts Locked should default as such.
if (IsLocked)
{
DefaultLocked = true;
}
movementOpen.ForwardCommand = (uint)MotionCommand.On;
movementClosed.ForwardCommand = (uint)MotionCommand.Off;
if (UseRadius < 2)
{
UseRadius = 2;
}
}
private void byIDToolStripMenuItem_Click(object sender, EventArgs e)
{
string weenieId = Interaction.InputBox("Enter the Weenie ID", "ACE");
uint id;
if (uint.TryParse(weenieId, out id))
{
var db = new WorldDatabase();
var config = WeenieEditorConfig.Load();
db.Initialize(config.ServerIp, uint.Parse(config.ServerPort), config.RootUsername, config.RootPassword, config.WorldDatabaseName);
_weenie = db.GetWeenie(id);
LoadWeenie();
}
}
public List <AceObject> GetWeenieInstancesByLandblock(ushort landblock)
{
var criteria = new Dictionary <string, object> {
{ "landblock", landblock }
};
var instances = ExecuteConstructedGetListStatement <WorldPreparedStatement, WeenieObjectInstance>(WorldPreparedStatement.GetWeenieInstancesByLandblock, criteria);
List <AceObject> ret = new List <AceObject>();
instances.ForEach(instance =>
{
// Create a new AceObject from Weenie.
AceObject ao = GetWorldObject(instance.WeenieClassId);
// Load in the object's properties from the weenie.
ao.DataIdProperties = GetAceObjectPropertiesDid(ao.AceObjectId);
ao.InstanceIdProperties = GetAceObjectPropertiesIid(ao.AceObjectId);
ao.IntProperties = GetAceObjectPropertiesInt(ao.AceObjectId);
ao.Int64Properties = GetAceObjectPropertiesBigInt(ao.AceObjectId);
ao.BoolProperties = GetAceObjectPropertiesBool(ao.AceObjectId);
ao.DoubleProperties = GetAceObjectPropertiesDouble(ao.AceObjectId);
ao.StringProperties = GetAceObjectPropertiesString(ao.AceObjectId);
ao.TextureOverrides = GetAceObjectTextureMaps(ao.AceObjectId);
ao.AnimationOverrides = GetAceObjectAnimations(ao.AceObjectId);
ao.PaletteOverrides = GetAceObjectPalettes(ao.AceObjectId);
ao.SpellIdProperties = GetAceObjectPropertiesSpell(ao.AceObjectId);
ao.GeneratorLinks = GetAceObjectGeneratorLinks(ao.AceObjectId);
ao.AceObjectPropertiesPositions = GetAceObjectPositions(ao.AceObjectId).ToDictionary(x => (PositionType)x.DbPositionType, x => new Position(x));
ao.BookProperties = GetAceObjectPropertiesBook(ao.AceObjectId).ToDictionary(x => x.Page);
// Set the object's current location for this instance.
ao.Location = new Position(instance.LandblockRaw,
instance.PositionX, instance.PositionY, instance.PositionZ,
instance.RotationX, instance.RotationY, instance.RotationZ, instance.RotationW);
// Use the guid recorded by the PCAP.
// This step could eventually be removed if we want to let the GuidManager handle assigning guids for static objects, ignoring the recorded guids.
string cmsClone = ao.CurrentMotionState; // Make a copy of the CurrentMotionState for cloning
ao = (AceObject)ao.Clone(instance.PreassignedGuid); // Clone AceObject and assign the recorded Guid
ao.CurrentMotionState = cmsClone; // Restore CurrentMotionState from original weenie
ret.Add(ao);
});
return(ret);
}
