public override CmdResult ExecuteRequest(CmdRequest args)
{
string filename = "AssetMapping3.xml";
if (args.Length > 0)
{
filename = String.Join(" ", args, 0, args.Length).Trim();
}
return(Success("Done with UUIDs " + SimAssetStore.SaveAssetFile(filename, false)));
}
internal void AddType(string anims)
{
lock (Meanings)
{
if (!Meanings.Contains(anims))
{
anims = string.Intern(anims);
Meanings.Add(anims);
List <UUID> AMeanings = SimAssetStore.MeaningUUIDs(anims);
if (!AMeanings.Contains(AssetID))
{
AMeanings.Add(AssetID);
}
}
}
}
public void Init(UUID id)
{
if (id == UUID.Zero)
{
return;
}
AssetType assetType = AssetType.Texture;
SimAsset sa = SimAssetStore.FindOrCreateAsset(id, assetType);
if (!sa.NeedsRequest)
{
return;
}
{
StartTextureDownload(id);
}
sa.NeedsRequest = false;
lock (AssetRequestType)
{
if (AssetRequestType.ContainsKey(id))
{
return;
}
AssetRequestType[id] = AssetType.Texture;
}
// Callbacks
client.Assets.RequestImage(id, ImageType.Normal, 101300.0f, 0, 0, delegate(TextureRequestState state, AssetTexture assetTexture)
{
if (state == TextureRequestState.Finished)
{
Assets_OnImageReceived(assetTexture);
sa.SetAsset(assetTexture);
return;
}
else if (state == TextureRequestState.Progress)
{
// DisplayPartialImage(assetTexture);
}
else if (state == TextureRequestState.Timeout)
{
AssetRequestType.Remove(id);
}
}, false);
}
internal void OnAssetDownloaded(UUID uUID, Asset asset)
{
EnsureCached(asset, uUID);
WorldObjects.RegisterUUIDMaybe(uUID, asset);
SimAsset A = SimAssetStore.FindOrCreateAsset(uUID, asset.AssetType);
A.SetAsset(asset);
//A.TypeData = asset.AssetData;
if (false)
{
BotClient Client = this.client;
AutoResetEvent UploadCompleteEvent = new AutoResetEvent(false);
if (Client.AnimationFolder == UUID.Zero)
{
Client.AnimationFolder = Client.Inventory.FindFolderForType(AssetType.Animation);
}
DateTime start = new DateTime();
Client.Inventory.RequestCreateItemFromAsset(asset.AssetData, A.Name, "Anim captured " + uUID,
AssetType.Animation,
InventoryType.Animation, Client.AnimationFolder,
delegate(bool success, string status, UUID itemID,
UUID assetID)
{
WriteLine(
String.Format(
"RequestCreateItemFromAsset() returned: Success={0}, Status={1}, ItemID={2}, AssetID={3}",
success, status, itemID, assetID));
WriteLine(String.Format("Upload took {0}",
DateTime.Now.
Subtract(start)));
UploadCompleteEvent.Set();
});
UploadCompleteEvent.WaitOne();
//A.Name
//SetAnimationName(asset.AssetID, s);
}
// Debug(s);
// RegisterUUID(asset.AssetID, s);
}
//private delegate bool AnimationTest(ICollection<UUID> thisEvent);
private void StartOrStopAnimEvent(IDictionary <UUID, int> RemovedThisEvent, IDictionary <UUID, int> AddedThisEvent, string name, IList <CogbotEvent> startStops)
{
int wasStarted = 0;
int wasStopped = 0;
List <UUID> e = SimAssetStore.MeaningUUIDs(name);
// if (e.Count==0) throw new NoSuchElementException(name);
foreach (UUID list in e)
{
if (AddedThisEvent.ContainsKey(list))
{
wasStarted = AddedThisEvent[list];
AddedThisEvent.Remove(list);
}
}
foreach (UUID list in e)
{
if (RemovedThisEvent.ContainsKey(list))
{
wasStopped = RemovedThisEvent[list];
RemovedThisEvent.Remove(list);
}
}
if (wasStarted != 0 && wasStopped != 0)
{
return;
}
if (wasStarted != 0)
{
CogbotEvent simEvent = CreateAEvent(SimEventType.Start, name, SimEventType.ANIM | SimEventType.REGIONAL,
WorldObjects.ToParameter("doneBy", this),
WorldObjects.ToParameter("eventOccursAt", GetHeading()));
simEvent.Serial = wasStarted;
startStops.Add(simEvent);
}
if (wasStopped != 0)
{
CogbotEvent simEvent = CreateAEvent(SimEventType.Stop, name, SimEventType.ANIM | SimEventType.REGIONAL,
WorldObjects.ToParameter("doneBy", this),
WorldObjects.ToParameter("toLocation", GetHeading()));
simEvent.Serial = wasStopped;
startStops.Insert(0, simEvent);
}
}
public static ICollection <SimAsset> GetAlist(string[] tokens)
{
ICollection <SimAsset> list = SimAssetStore.GetAssets(AssetType.Unknown);
ICollection <SimAsset> found = new List <SimAsset>();
lock (list)
foreach (SimAsset A in list)
{
foreach (string s in tokens)
{
if (A.Matches(s))
{
found.Add(A);
break;
}
}
}
return(found);
}
private void StartupPostLoginQueues()
{
lock (DidStartupPostLoginQueuesLock)
{
if (DidStartupPostLoginQueues)
{
return;
}
DidStartupPostLoginQueues = true;
}
ParentGrabber.Start();
CatchUpQueue.Start();
MetaDataQueue.Start();
OnConnectedQueue.Start();
SimAssetStore.TaskQueueStart();
SlowConnectedQueue.Enqueue(() => SlowConnectedQueue.DebugQueue = false);
SlowConnectedQueue.Start();
client.OneAtATimeQueue.Start();
TaskInvGrabber.Start();
}
public void SetAsset(Asset value)
{
if (value != null)
{
lock (value)
{
if (value.AssetType > 0)
{
AssetType = value.AssetType;
}
if (value.AssetID != UUID.Zero)
{
AssetID = value.AssetID;
}
byte[] ad = value.AssetData;
if (ad != null && ad.Length > 0)
{
if (_TypeData == null || _TypeData.Length == 0)
{
_TypeData = ad;
}
}
if (AssetComplete)
{
return;
}
if ((_ServerAsset == value))
{
WriteLine("RE-Got server asset!");
}
AssetComplete = true;
PullServerAsset = false;
NeedsRequest = false;
GuessAssetName();
GetParts();
SimAssetStore.InternAsset(this);
}
}
}
private void Assets_OnImageReceived(AssetTexture assetTexture)
{
try
{
byte[] jpegdata;
ManagedImage imgManaged;
Image image;
SimAsset sa = SimAssetStore.FindOrCreateAsset(assetTexture.AssetID, assetTexture.AssetType);
if (!OpenJPEG.DecodeToImage(assetTexture.AssetData, out imgManaged, out image))
{
throw new Exception("decoding failure");
}
jpegdata = assetTexture.AssetData;
sa._TypeData = jpegdata;
UUIDTypeObjectSetValue(assetTexture.AssetID, jpegdata);
assetTexture.Decode();
}
catch (Exception excp)
{
System.Console.WriteLine("Error decoding image: " + excp.Message);
}
}
private CogbotEvent AnimEvent(UUID uuid, SimEventType status, int serial)
{
SimAsset a = SimAssetStore.FindOrCreateAsset(uuid, AssetType.Animation);
string headingString;
switch (status)
{
case SimEventType.Start:
{
headingString = "eventOccursAt";
break;
}
case SimEventType.Stop:
{
headingString = "toLocation";
break;
}
default:
{
headingString = "eventOccursAt";
break;
}
}
object m = a.GetMeaning();
CogbotEvent oe = CreateAEvent(status, "OnAnim", SimEventType.ANIM | SimEventType.REGIONAL,
WorldObjects.ToParameter("doneBy", this),
WorldObjects.ToParameter("isa", a),
WorldObjects.ToParameter(headingString, GetHeading()));
oe.Serial = serial;
if (m != null)
{
oe.AddParam("isa", m);
}
return(oe);
}
public ImageDownload StartTextureDownload(UUID id)
{
AssetType type = AssetType.Texture;
SimAsset simAsset = SimAssetStore.FindOrCreateAsset(id, type);
AssetCache Cache =
(RegionMasterTexturePipeline == null ? null : RegionMasterTexturePipeline.Cache);
if (Cache != null && Cache.HasAsset(id
#if COGBOT_LIBOMV
, type
#endif
))
{
ImageDownload dl = Cache.GetCachedImage(id);
if (dl != null)
{
simAsset.SetAsset(dl);
}
return(dl);
}
lock (TexturesSkipped) if (TexturesSkipped.Contains(id))
{
return(null);
}
lock (AssetRequestType)
{
if (AssetRequestType.ContainsKey(id))
{
return(null);
}
AssetRequestType[id] = AssetType.Texture;
}
TextureRequested++;
SlowConnectedQueue.Enqueue(() => client.Assets.RequestImage(id, ImageType.Normal, RegionMasterTexturePipeline_OnDownloadFinished));
return(null);
}
//public override void Assets_OnXferReceived(XferDownload xfer)
//{
// //AssetRequests.
// //RegisterUUIDMaybe(xfer.ID, xfer);
//}
public SimAsset EnqueueRequestAsset(UUID id, AssetType assetType, bool priority)
{
if (id == UUID.Zero)
{
return(null);
}
SimAsset sa = SimAssetStore.FindOrCreateAsset(id, assetType);
if (!sa.NeedsRequest)
{
return(sa);
}
if (assetType == AssetType.Texture)
{
StartTextureDownload(id);
return(sa);
}
sa.NeedsRequest = false;
if (assetType == AssetType.SoundWAV)
{
return(sa);
}
//if (assetType == AssetType.Sound) return sa;
lock (AssetRequestType)
{
if (AssetRequestType.ContainsKey(id))
{
return(sa);
}
AssetRequestType[id] = assetType;
SlowConnectedQueue.Enqueue(
() => RegionMasterTexturePipeline.RequestAsset(id, assetType, priority, Assets_OnAssetReceived));
}
return(sa);
}
public override CmdResult ExecuteRequest(CmdRequest args)
{
if (NOSEARCH_ANIM)
{
String str = args.str;
WriteLine("PLAY ECHO " + str);
return(Success("\nStart assets " + str + "\n"));
}
bool writeInfo = !args.IsFFI;
if (args.Length < 1)
{
Dictionary <UUID, int> gestures = WorldSystem.TheSimAvatar.GetCurrentAnimDict();
string alist = String.Empty;
foreach (var anim in gestures)
{
AppendItem("assets", WorldSystem.GetAsset(anim.Key));
if (!writeInfo)
{
continue;
}
alist += WorldSystem.GetAnimationName(anim.Key);
alist += " ";
alist += anim.Value;
alist += Environment.NewLine;
}
if (writeInfo)
{
WriteLine("Currently: {0}", alist);
}
return(SuccessOrFailure());
// " anim [seconds] HOVER [seconds] 23423423423-4234234234-234234234-23423423 +CLAP -JUMP STAND";
}
int argStart = 0;
int time = 1300; //should be long enough for most animations
base.SetWriteLine("message");
string directive = args[0].ToLower();
int mode = 0;
int defaultAnimTime = 2;
int animsRan = 0;
AssetType defaultSearch = AssetType.Gesture;
for (int i = argStart; i < args.Length; i++)
{
string a = args[i];
if (String.IsNullOrEmpty(a))
{
continue;
}
try
{
float ia;
if (float.TryParse(a, out ia))
{
if (ia > 0.0)
{
time = (int)(ia * 1000);
Thread.Sleep(time);
continue;
}
}
}
catch (Exception)
{
}
char c = a.ToCharArray()[0];
if (c == '-')
{
mode = -1;
a = a.Substring(1);
}
else if (c == '+')
{
mode = 1;
a = a.Substring(1);
}
else
{
mode = 0;
}
if (a == "")
{
continue;
}
if (a.ToLower() == "stopall")
{
Dictionary <UUID, bool> animations = new Dictionary <UUID, bool>();
var anims = TheSimAvatar.GetCurrentAnims();
foreach (var ani in anims)
{
animations[ani] = false;
}
int knownCount = animations.Count;
Client.Self.Animate(animations, true);
WriteLine("stopping all");
continue;
}
try
{
defaultSearch = (AssetType)Enum.Parse(typeof(AssetType), a, true);
continue;
}
catch
{
}
UUID anim = WorldSystem.GetAssetUUID(a, defaultSearch);
if (anim == UUID.Zero)
{
try
{
if (a.Substring(2).Contains("-"))
{
anim = UUIDParse(a);
}
}
catch (Exception)
{
}
}
if (anim == UUID.Zero)
{
anim = WorldSystem.GetAssetUUID(a, AssetType.Unknown);
}
if (anim == UUID.Zero)
{
Failure("skipping unknown animation/gesture " + a);
continue;
}
SimAsset asset = SimAssetStore.FindAsset(anim);
animsRan++;
AppendItem("assets", WorldSystem.GetAsset(anim));
if (asset is SimGesture)
{
Client.Self.PlayGesture(asset.AssetID);
continue;
}
if (asset is SimSound)
{
Client.Sound.PlaySound(asset.AssetID);
continue;
}
if (asset != null && !(asset is SimAnimation))
{
Failure("Dont know how to play " + asset);
continue;
}
try
{
switch (mode)
{
case -1:
Client.Self.AnimationStop(anim, true);
if (writeInfo)
{
WriteLine("\nStop anim " + WorldSystem.GetAnimationName(anim));
}
continue;
case +1:
Client.Self.AnimationStart(anim, true);
if (writeInfo)
{
WriteLine("\nStart anim " + WorldSystem.GetAnimationName(anim));
}
continue;
default:
try
{
int val = time;
Client.Self.AnimationStart(anim, true);
if (writeInfo)
{
WriteLine("\nRan anim " + WorldSystem.GetAnimationName(anim) + " for " + val / 1000 +
" seconds.");
}
Thread.Sleep(val);
}
finally
{
Client.Self.AnimationStop(anim, true);
}
continue;
}
}
catch (Exception e)
{
return(Failure("\nRan " + animsRan + " asserts but " + e));
}
}
return(SuccessOrFailure());
}
virtual public void WriteLine(string s, params object[] args)
{
SimAssetStore.WriteLine(DebugInfo() + ": " + s, args);
}
public byte[] TextureBytesForUUID(UUID uUID)
{
//imlicitly DeclareTexture(uUID);
SimAsset assettt = SimAssetStore.FindOrCreateAsset(uUID, AssetType.Texture);
var AssetData = assettt.AssetData;
if (AssetData != null)
{
assettt.IsTraced = false;
return(AssetData);
}
assettt.IsTraced = true;
ImageDownload ID = null;
//lock (uuidTypeObject)
{
object iObject;
if (UUIDTypeObjectTryGetValue(uUID, out iObject))
{
if (iObject is ImageDownload)
{
ID = (ImageDownload)iObject;
}
}
}
if (ID == null)
{
ID = StartTextureDownload(uUID);
if (ID == null)
{
var giveUpTick = DateTime.Now;//.AddMinutes(1);// +1 * 60000;
while (ID == null)
{
ID = StartTextureDownload(uUID);
if (ID == null)
{
lock (TexturesSkipped) if (TexturesSkipped.Contains(uUID))
{
return(null);
}
if (DateTime.Now > giveUpTick)
{
lock (TexturesSkipped) TexturesSkipped.Add(uUID);
//if (Settings.LOG_LEVEL == Helpers.LogLevel.Warning)
Debug("-- ---- ---GIVEUP SculptMesh " + uUID);
return(null);
}
//Thread.Sleep(5000);
DoEvents();
return(null);
}
}
}
lock (UUIDTypeObjectLock)
{
UUIDTypeObjectSetValue(uUID, ID);
}
}
if (Settings.LOG_LEVEL == Helpers.LogLevel.Debug)
{
Debug("-|-|- SUCCEED SculptMesh " + uUID);
}
return(ID.AssetData);
}
public void DeclareTexture(UUID tid)
{
SimAssetStore.FindOrCreateAsset(tid, AssetType.Texture);
}
static void PutType(string anims, UUID uUID)
{
SimAsset a = SimAssetStore.FindAsset(uUID);
a.AddType(anims);
}
protected override List <SimAsset> GetParts()
{
AssetGesture gestureAsset = GetGesture();
// StringBuilder sb = new StringBuilder();
//sb.Append("2\n");
if (gestureAsset == null)
{
return(null);
}
Name = gestureAsset.Trigger;
//sb.Append(TriggerKey + "\n");
//sb.Append(TriggerKeyMask + "\n");
//sb.Append(Trigger + "\n");
Name = gestureAsset.ReplaceWith;//sb.Append(ReplaceWith + "\n");
List <GestureStep> Sequence = gestureAsset.Sequence;
int count = 0;
if (Sequence != null)
{
count = Sequence.Count;
}
List <SimAsset> parts = new List <SimAsset>(count);
//sb.Append(count + "\n");
_Length = 0;
for (int i = 0; i < count; i++)
{
GestureStep step = Sequence[i];
// sb.Append((int)step.GestureStepType + "\n");
SimAsset asset;
switch (step.GestureStepType)
{
case GestureStepType.EOF:
goto Finish;
case GestureStepType.Animation:
GestureStepAnimation animstep = (GestureStepAnimation)step;
asset = SimAssetStore.FindOrCreateAsset(animstep.ID, AssetType.Animation);
asset.Name = animstep.Name;
if (animstep.AnimationStart)
{
parts.Add(asset);
// sb.Append("0\n");
_Length += asset.Length;
}
else
{
// sb.Append("1\n");
}
break;
case GestureStepType.Sound:
GestureStepSound soundstep = (GestureStepSound)step;
asset = SimAssetStore.FindOrCreateAsset(soundstep.ID, AssetType.Sound);
asset.Name = soundstep.Name;
parts.Add(asset);
_Length += asset.Length;
break;
case GestureStepType.Chat:
GestureStepChat chatstep = (GestureStepChat)step;
Name = chatstep.Text;
//sb.Append(chatstep.Text + "\n");
//sb.Append("0\n");
_Length += 10;
break;
case GestureStepType.Wait:
GestureStepWait waitstep = (GestureStepWait)step;
//sb.AppendFormat("{0:0.000000}\n", waitstep.WaitTime);
int waitflags = 0;
if (waitstep.WaitForTime)
{
waitflags |= 0x01;
_Length += waitstep.WaitTime;
}
if (waitstep.WaitForAnimation)
{
waitflags |= 0x02;
_Length += 10;
}
//sb.Append(waitflags + "\n");
break;
}
}
Finish:
if (parts.Count == 1)
{
SimAsset A = parts[0];
if (A is SimAnimation)
{
AnimationGestures[A.AssetID] = this;
if (A.Item == null)
{
A.Item = Item;
}
}
}
return(parts);
}
static UUIDGleaner GetUUIDGleaner(string p, MemberInfo info)
{
lock (UUID2Type)
if (UUID2Type.Count == 0)
{
UUIDGleaner texture = ((obj, sim) => { SimAssetStore.FindOrCreateAsset(obj, AssetType.Texture); });
UUIDGleaner avatar = ((obj, sim) => { GridMaster.DeclareAvatarProfile(obj); });
UUIDGleaner task = ((obj, sim) => { GridMaster.DeclareTask(obj, sim); });
UUIDGleaner nothing = ((obj, sim) => { });
UUIDGleaner objectID = ((obj, sim) => { GridMaster.CreateSimObject(obj, GridMaster, sim); });
UUIDGleaner role = ((obj, sim) => DeclareGeneric("GroupRole", obj, " +p"));
UUID2Type[""] = nothing;
UUID2Type["ID"] = nothing;
UUID2Type["Sound"] = ((obj, sim) => { SimAssetStore.FindOrCreateAsset(obj, AssetType.Sound); });
UUID2Type["Gesture"] = ((obj, sim) => { SimAssetStore.FindOrCreateAsset(obj, AssetType.Gesture); });
UUID2Type["Landmark"] = ((obj, sim) => { SimAssetStore.FindOrCreateAsset(obj, AssetType.Landmark); });
UUID2Type["Animation"] = ((obj, sim) => { SimAssetStore.FindOrCreateAsset(obj, AssetType.Animation); });
UUID2Type["Clothing"] = ((obj, sim) => { SimAssetStore.FindOrCreateAsset(obj, AssetType.Clothing); });
UUID2Type["Region"] = ((obj, sim) => { RegisterUUIDMaybe(obj, typeof(SimRegion)); });
UUID2Type["Estate"] = ((obj, sim) => { RegisterUUIDMaybe(obj, typeof(EstateAssetType)); });
UUID2Type["Image"]
= UUID2Type["SculptTexture"]
= UUID2Type["Photo"]
= UUID2Type["Insignia"]
= UUID2Type["Picture"]
= UUID2Type["Texture"]
= UUID2Type["Sculpt"]
= UUID2Type["ProfileImage"] = texture;
UUID2Type["Owner"] = UUID2Type["Partner"] = UUID2Type["Creator"] = UUID2Type["Founder"] = avatar;
UUID2Type["Group"] = ((obj, sim) => { GridMaster.DeclareGroup(obj); });
UUID2Type["Object"] = objectID;
UUID2Type["Primitive"] = objectID;
// todo inventory item
UUID2Type["OwnerRole"] = role;
UUID2Type["FromTask"] = task;
UUID2Type["FolderID"] = nothing;
UUID2Type["ItemID"] = nothing;
// ussualyl objects but need to confirm: The Key of the specified target object or avatar particles will follow"
UUID2Type["Target"] = nothing;
UUID2Type["Asset"] = nothing;
}
UUIDGleaner o;
lock (UUID2Type)
{
if (UUID2Type.TryGetValue(p, out o))
{
return(o);
}
foreach (var s in new[] { "From", "To", "Next", "Last", "First", "Second", "Life", "Life", })
{
if (p.StartsWith(s))
{
return(UUID2Type[p] = GetUUIDGleaner(p.Substring(s.Length), info));
}
}
foreach (var s in new[] { "ID", "UUID", "Asset" })
{
if (p.EndsWith(s))
{
return(UUID2Type[p] = GetUUIDGleaner(p.Substring(0, p.Length - s.Length), info));
}
}
Debug("Dont know what UUID means in " + p);
return((obj, sim) => { RegisterUUIDMaybe(obj, info); });
}
}
public void InvokeReal(SimActor TheBot)
{
String use = TypeUsage.UsageName;
// Create the Side-Effect closure
ThreadStart closure = new ThreadStart(delegate()
{
InvokeBotSideEffect(TheBot);
});
SimAssetStore simAssetSystem = SimAssetStore.TheStore;
bool animFound = TypeUsage.UseSit;
// IF UseAnim was specified
if (!String.IsNullOrEmpty(TypeUsage.UseAnim))
{
UUID animID = simAssetSystem.GetAssetUUID(TypeUsage.UseAnim, AssetType.Animation);
if (animID != UUID.Zero)
{
closure = TheBot.WithAnim(animID, closure);
animFound = true;
}
}
// else
if (!animFound)
{
//ELSE look for Verb coverage for an anim
UUID animID = simAssetSystem.GetAssetUUID(use, AssetType.Animation);
if (animID != UUID.Zero)
{
closure = TheBot.WithAnim(animID, closure);
}
}
// Surround with tough/grab if needed
if (use == "touch" || use == "grab" || TypeUsage.UseGrab)
{
closure = TheBot.WithGrabAt(Target, closure);
}
// Surround with Sit if needed
if (use == "sit" || TypeUsage.UseSit)
{
closure = TheBot.WithSitOn(Target, closure);
}
// Approach Target
try
{
double maximumDistance = TypeUsage.maximumDistance + Target.GetSizeDistance();
double howClose = TheBot.Approach(Target, maximumDistance - 0.5);
((SimAvatarImpl)TheBot).ApproachVector3D = Target.GlobalPosition;
TheBot.TurnToward(Target);
if (howClose > maximumDistance + 1)
{
Debug(TheBot, "Too far away " + howClose + " from " + this);
return;
}
Target.PathFinding.MakeEnterable(TheBot);
closure.Invoke();
//if (Target == TheBot.ApproachPosition)
// {
// ((SimAvatarImpl) TheBot).ApproachPosition = null;
// TheBot.StopMoving();
//}
}
finally
{
Target.PathFinding.RestoreEnterable(TheBot);
}
}
static public string argString(object arg)
{
if (arg == null)
{
return("NIL");
}
Type type = arg.GetType();
if (arg is BotClient)
{
arg = ((BotClient)arg).GetAvatar();
if (arg is BotClient)
{
return(((BotClient)arg).ToString());
}
}
if (arg is WorldObjects)
{
arg = ((WorldObjects)arg).TheSimAvatar;
}
if (arg is Simulator)
{
Simulator sim = (Simulator)arg;
uint globalX, globalY;
Utils.LongToUInts(sim.Handle, out globalX, out globalY);
return("'(simulator " + argString(sim.Name) + " " + globalX / 256 + " " + globalY / 256 + " " +
argString(sim.IPEndPoint.ToString()) + ")");
}
if (arg is Avatar)
{
Avatar prim = (Avatar)arg;
arg = "'(SimAvatarFn "; //+ argString(prim.ID.ToString());
if (prim.Name != null)
{
arg = arg + " " + argString(prim.Name);
}
return(arg + ")");
}
if ((arg is AssetAnimation) || (arg is AssetTexture) || (arg is AssetSound))
{
Asset prim = (Asset)arg;
arg = SimAssetStore.GetSimAsset(prim);
}
if (arg is SimAsset)
{
SimAsset prim = (SimAsset)arg;
AssetType tyepe = prim.AssetType;
arg = "'(Sim" + tyepe + "Fn "; //+ argString(prim.ID.ToString());
if (prim.Name != null)
{
arg = arg + " " + argString(prim.Name);
}
return(arg + ")");
}
if (arg is Primitive)
{
Primitive prim = (Primitive)arg;
arg = "'(SimObjectFn " + argString(prim.ID.ToString());
if (prim.Properties != null)
{
arg = arg + " " + argString(prim.Properties.Name);
}
return(arg + ")");
}
if (arg is SimAvatar)
{
SimAvatar prim = (SimAvatar)arg;
arg = "'(SimAvatarFn " + argString(prim.GetName());
return(arg + ")");
}
if (arg is SimObject)
{
SimObject prim = (SimObject)arg;
arg = "'(SimObjectFn " + argString(prim.ID.ToString());
string name = prim.GetName();
if (!string.IsNullOrEmpty(name))
{
arg = arg + " #|" + argString(name) + "|# ";
}
return(arg + ")");
}
if (type.IsEnum)
{
return(argString(arg.ToString()));
}
//InternalDictionary
if (arg is IList)
{
String dictname = "'(list " + type.Name;
IList list = (IList)arg;
foreach (object key in list)
{
dictname += " " + argString(key);
}
return(dictname + ")");
}
if (arg is Parcel)
{
String dictname = "'(parcel";
Parcel list = (Parcel)arg;
dictname += " " + argString(list.SnapshotID.ToString());
dictname += " " + argString(list.Name);
return(dictname + ")");
}
if (arg is Group)
{
String dictname = "'(Group";
Group list = (Group)arg;
dictname += " " + argString(list.Name);
return(dictname + ")");
}
if (arg is IDictionary)
{
String dictname = "'(dict " + type.Name;
IDictionary dict0 = (IDictionary)arg;
IDictionary dict = dict0;
lock (dict.SyncRoot)
{
foreach (object key in dict.Keys)
{
Object o = dict[key];
dictname += " " + argString(key) + "=" + argString(o);
}
return(dictname + ")");
}
}
//if (arg is Quaternion)
//{
// Quaternion quat = (Quaternion)arg;
// quat.Normalize();
// arg = WorldSystem.QuatToRotation(quat);
//}
if (arg is Quaternion)
{
Quaternion vect = (Quaternion)arg;
return("'(Quaternion " + vect.X + " " + vect.Y + " " + vect.Z + " " + vect.W + ")");
}
if (arg is UUID)
{
// if (true) return argString(arg.ToString());
object found = WorldObjects.GridMaster.GetObject((UUID)arg);
if (found == null || found is UUID)
{
return(argString(arg.ToString()));
}
return(argString(found));
}
if (arg is Vector3)
{
Vector3 vect = (Vector3)arg;
return("'(Vector3 " + vect.X + " " + vect.Y + " " + vect.Z + ")");
}
if (arg is Vector2)
{
Vector2 vect = (Vector2)arg;
return("'(Vector2 " + vect.X + " " + vect.Y + ")");
}
if (arg is Vector3d)
{
Vector3d vect = (Vector3d)arg;
return("'(Vector3d " + vect.X + " " + vect.Y + " " + vect.Z + ")");
}
if (type.IsArray)
{
Array a = (Array)arg;
return("#{/*" + type + "*/" + argsListString(a) + "}");
}
if (arg is String)
{
return("\"" + arg.ToString().Replace("\"", "\\\"") + "\"");
}
if (type.Namespace.StartsWith("System"))
{
return("" + arg);
}
if (arg is IEnumerable)
{
IEnumerable a = (IEnumerable)arg;
return("'(/*" + type + "*/" + argsListString(a) + ")");
}
if (type.IsValueType)
{
String tostr = "{" + arg + "";
foreach (FieldInfo fi in type.GetFields())
{
if (!fi.IsStatic)
{
tostr += ",";
tostr += fi.Name + "=";
tostr += argString(fi.GetValue(arg));
}
}
return(argString(tostr + "}"));
}
if (!type.IsValueType)
{
String tostr = "{" + arg + "";
foreach (FieldInfo fi in type.GetFields())
{
if (!fi.IsStatic)
{
tostr += ",";
tostr += fi.Name + "=";
tostr += fi.GetValue(arg);
}
}
return(argString(tostr + "}"));
}
return("" + arg);
}
/// public UUID CurrentAmin = UUID.Zero;
/// <summary>
/// Nephrael Rae: [on-object-animation '(avatar "Candie Brooks") "TALK"][on-object-animation '(avatar "Candie Brooks") "STAND_1"][on-object-animation '(avatar "Candie Brooks") "e45fbdc9-af8f-9408-f742-fcb8c341d2c8"]
/// </summary>
/// <param name="anims"></param>
public void OnAvatarAnimations(List <Animation> anims0)
{
var anims = new InternalDictionary <UUID, int>();
var animDict = CogbotHelpers.DictOf(anims);
foreach (var list in anims0)
{
animDict[list.AnimationID] = list.AnimationSequence;
}
Dictionary <UUID, int> RemovedAnims = new Dictionary <UUID, int>();
Dictionary <UUID, int> AddedAnims = new Dictionary <UUID, int>();
bool SendAnimEvent = !WorldObjects.UseNewEventSystem;
//if (!theAvatar.Name.Contains("rael")) return;
lock (ExpectedCurrentAnims)
{
int mostCurrentSequence = int.MinValue;
int leastCurrentSequence = int.MaxValue;
Dictionary <UUID, int> dictionary = CogbotHelpers.DictOf(ExpectedCurrentAnims);//.Dictionary;
GetSequenceNumbers(dictionary, ref leastCurrentSequence, ref mostCurrentSequence);
/// first time so find the lowest number
int mostCurrentSequence1 = int.MinValue;
int leastCurrentSequence1 = int.MaxValue;
GetSequenceNumbers(animDict, ref leastCurrentSequence1, ref mostCurrentSequence1);
//UUID mostCurrentAnim = UUID.Zero;// = UUID.Zero;
/// List<String> names = new List<String>();
Dictionary <UUID, int> RemovedThisEvent = new Dictionary <UUID, int>(dictionary);
anims.ForEach(delegate(UUID key)
{
RemovedThisEvent.Remove(key);
int newAnimNumber;
anims.TryGetValue(key, out newAnimNumber);
if (newAnimNumber >= mostCurrentSequence)
{
mostCurrentSequence = newAnimNumber;
WorldObjects.GridMaster.EnqueueRequestAsset(key, AssetType.Animation, true);
//mostCurrentAnim = key;
}
if (ExpectedCurrentAnims.ContainsKey(key))
{
int oldAnimNumber;
ExpectedCurrentAnims.TryGetValue(key, out oldAnimNumber);
if (oldAnimNumber == newAnimNumber)
/// still the same
{
AddedAnims.Remove(key);
RemovedAnims.Remove(key);
return;
}
if (oldAnimNumber > newAnimNumber)
{
// Debug("error oldAnimNumber > newAnimNumber");
}
/// else
{
if (oldAnimNumber + 1 != newAnimNumber)
{
RemovedAnims[key] = oldAnimNumber + 1;
AddedAnims[key] = newAnimNumber;
}
}
return;
}
AddedAnims[key] = newAnimNumber; /// AddedAnims.Add(key, newAnimNumber);
RemovedAnims.Remove(key);
/// int whenSeq = newAnimNumber + 1;
/// if (!RemovedAnimsWhen.ContainsKey(whenSeq))
/// {
/// RemovedAnimsWhen[whenSeq] = new List<UUID>();
/// }
/// RemovedAnimsWhen[whenSeq].Add(key);
});
List <UUID> shownRemoved = new List <UUID>();
List <UUID> showAdded = new List <UUID>();
Dictionary <UUID, int> AddedThisEvent = new Dictionary <UUID, int>(AddedAnims);
foreach (UUID key in RemovedThisEvent.Keys)
{
dictionary.Remove(key);
}
foreach (UUID list in RemovedAnims.Keys)
{
if (RemovedThisEvent.ContainsKey(list))
{
RemovedThisEvent.Remove(list);
}
}
List <CogbotEvent> startStops = new List <CogbotEvent>();
//if (SimAnimationStore.IsSitAnim(RemovedThisEvent)) {
// if (!SimAnimationStore.IsSitAnim(AddedThisEvent))
// {
// LogEvent(new SimObjectEvent("StandUp", SimEventType.ANIM, this, ZHeading * SimPathStore.RAD2DEG, GetSimulator().Name, GetSimPosition()));
// }
//}
//start or stop moving
Dictionary <UUID, int> RemovedThisEventUnsent = new Dictionary <UUID, int>(RemovedThisEvent);
Dictionary <UUID, int> AddedThisEventUnsent = new Dictionary <UUID, int>(AddedThisEvent);
if (mergeEvents)
{
StartOrStopAnimEvent(RemovedThisEventUnsent, AddedThisEventUnsent, "Movement-TranslationProcess",
startStops);
StartOrStopAnimEvent(RemovedThisEventUnsent, AddedThisEventUnsent, "Jumping", startStops);
StartOrStopAnimEvent(RemovedThisEventUnsent, AddedThisEventUnsent, "SittingDown", startStops);
StartOrStopAnimEvent(RemovedThisEventUnsent, AddedThisEventUnsent, "StandingStill", startStops);
// start or stop flying
StartOrStopAnimEvent(RemovedThisEventUnsent, AddedThisEventUnsent, "Flying", startStops);
//start or stop sleeping
StartOrStopAnimEvent(RemovedThisEventUnsent, AddedThisEventUnsent, "Lying-Physical", startStops);
//start or stop talking
//StartOrStopAnimEvent(RemovedThisEvent, AddedThisEvent, SimAnimationStore.IsCommunationAnim, "Commuincation", SimEventType.ANIM, startStops);
// StartOrStopAnimEvent(RemovedThisEvent, AddedThisEvent, "OtherAnim", startStops);
foreach (CogbotEvent evt in startStops)
{
if (evt.Verb == "Flying")
{
LastEventByName[evt.EventName] = evt;
if (evt.IsEventType(SimEventType.Start))
{
continue;
}
}
if (evt.Verb == "StandingStill")
{
LastEventByName[evt.EventName] = evt;
//continue;
}
if (evt.Verb == "SittingDown")
{
LastEventByName[evt.EventName] = evt;
//continue;
}
if (evt.EventName == "Movement-TranslationProcess-Start")
{
LastEventByName[evt.EventName] = evt;
//lastEvent = evt;
//continue;
}
//if (evt.EventName == "MovingStop")
//{
// object old = GetLastEvent("MovingStart", 2);
// evt.Verb = "MoveTo";
//}
if (evt.IsEventType(SimEventType.Start))
{
SetPosture(evt);
}
// LogEvent(evt);
}
}
for (int seq = leastCurrentSequence; seq <= mostCurrentSequence; seq++)
{
if (RemovedAnims.Count > 0)
{
foreach (KeyValuePair <UUID, int> uuid in RemovedAnims)
{
if (seq == uuid.Value)
{
if (RemovedThisEventUnsent.ContainsKey(uuid.Key))
{
var evt = AnimEvent(uuid.Key, SimEventType.Stop, seq);
bool sent = LogEvent(evt);
if (!sent && ShouldEventSource)
{
WorldSystem.SendPipelineEvent(evt);
}
shownRemoved.Add(uuid.Key);
}
}
}
}
if (AddedAnims.Count > 0)
{
foreach (KeyValuePair <UUID, int> uuid in AddedAnims)
{
if (seq == uuid.Value)
{
if (AddedThisEventUnsent.ContainsKey(uuid.Key))
{
var evt = AnimEvent(uuid.Key, SimEventType.Start, seq);
bool sent = LogEvent(evt);
if (!sent && ShouldEventSource)
{
WorldSystem.SendPipelineEvent(evt);
}
showAdded.Add(uuid.Key);
}
}
}
}
}
leastCurrentSequence = mostCurrentSequence;
foreach (UUID key in shownRemoved)
{
RemovedThisEvent.Remove(key);
RemovedAnims.Remove(key);
}
if (SimAssetStore.IsSitAnim(showAdded))
{
}
foreach (UUID key in showAdded)
{
AddedAnims.Remove(key);
}
}
//ExpectedCurrentAnims.Dictionary.Clear();
var before = CogbotHelpers.DictOf(ExpectedCurrentAnims);
lock (before)
{
before.Clear();
anims.ForEach(kv => before.Add(kv.Key, kv.Value));
}
/// String newName = WorldSystem.GetAnimationName(mostCurrentAnim);
/// {
/// if (oldAnim != mostCurrentAnim)
/// {
/// String oldName = WorldSystem.GetAnimationName(oldAnim);
/// if (oldName.Length > 4 && newName.Length > 4 &&
/// oldName.Substring(0, 5) == newName.Substring(0, 5))
/// {
/// }
/// else
/// WorldSystem.SendNewEvent("On-Object-Start-Animation", this, newName);
/// }
/// }
/// else
/// {
/// WorldSystem.SendNewEvent("On-Object-Start-Animation", this, newName);
/// }
/// CurrentAmin = mostCurrentAnim;
/// SendNewEvent("On-Avatar-Animation", avatar, names);
}
