static string decodeString(Stream stream, ReferenceLog refLog)
{
//
UInt32 l = decodeU29(stream);
bool isRef = (l & 1) == 0;
l = l >> 1;
if (isRef)
{
if (refLog.Strings.Length > 0)
{
return(refLog.Strings[l]);
}
else
{
throw new Exception("error code string");
}
}
else
{
byte[] bs = new byte[l];
stream.Read(bs, 0, bs.Length);
string toString = System.Text.Encoding.UTF8.GetString(bs);
List <string> lists = new List <string>()
{
};
lists.AddRange(refLog.Strings);
lists.Add(toString);
refLog.Strings = lists.ToArray();
return(toString);
}
}
static int encodeString(Stream stream, string value, ReferenceLog refLog)
{
//
writeAmfType(stream, amf_string);
bool isRef = false;
UInt32 l = Convert.ToUInt32(System.Text.Encoding.UTF8.GetBytes(value).Length);
for (int i = 0; i < refLog.Strings.Length; i++)
{
if (refLog.Strings[i] == value)
{
l = Convert.ToUInt32(i);
isRef = true;
break;
}
}
if (isRef)
{
l = l << 1;
}
else
{
l = (l << 1) | 1;
}
if (l > 0x1FFFFFFF)
{
throw new ArgumentOutOfRangeException();
}
int nl = encodeU29(stream, l);
int ns = 0;
if (!isRef)
{
byte[] valueBytes = System.Text.Encoding.UTF8.GetBytes(value);
stream.Write(valueBytes, 0, valueBytes.Length);
refLog.Strings = new string[] { value };
List <string> lists = new List <string>()
{
};
lists.Add(value);
lists.AddRange(refLog.Strings);
refLog.Strings = lists.ToArray();
}
return(ns + nl + 1);
}
static byte[] decodeByteArray(Stream stream, ReferenceLog refLog)
{
UInt32 l = decodeU29(stream);
bool isRef = (l & 1) == 0;
l = l >> 1;
if (isRef)
{
if (refLog.Bytes.Length > 0)
{
return(refLog.Bytes[l]);
}
else
{
throw new Exception("error code byte array");
}
}
else
{
byte[] bs = new byte[l];
stream.Read(bs, 0, bs.Length);
List <byte[]> lists = new List <byte[]>()
{
};
lists.AddRange(refLog.Bytes);
lists.Add(bs);
refLog.Bytes = lists.ToArray();
return(bs);
}
}
int encodeArray(Stream stream, Array value, ReferenceLog refLog)
{
if (value.GetType() == typeof(System.Byte[]))
{
//直接encodeByteArray
return(0);
}
writeAmfType(stream, amf_array);
int l = value.Length;
UInt32 el = (UInt32)((l << 1) | 1);
if (el > 0x1FFFFFFF)
{
throw new ArgumentOutOfRangeException();
}
int nl = encodeU29(stream, el);
stream.Write(new byte[] { 0x01 });
int tl = nl + 2;
for (int i = 0; i < l; i++)
{
int nc = encodeWithRef(stream, refLog, value.GetValue(i));
tl += nc;
}
return(tl);
}
static int encodeWithRef(Stream stream, ReferenceLog refLog, object value)
{
AMF_TYPE amfType = Utils.utils.GetObjectType(value);
switch (amfType)
{
case AMF_TYPE.Invalid:
return(encodeNull(stream));
case AMF_TYPE.Bool:
return(encodeBool(stream, Convert.ToBoolean(value)));
case AMF_TYPE.Int:
return(encodeInt(stream, Convert.ToInt64(value)));
case AMF_TYPE.Uint:
return(encodeUint(stream, Convert.ToUInt64(value)));
case AMF_TYPE.Float64:
return(encodeFloat(stream, Convert.ToDouble(value)));
case AMF_TYPE.Array:
object[] obs = null;
if (value is ArrayList)
{
obs = ((ArrayList)value).ToArray();
throw new Exception("ArrayList Is Not Convert, Recommended byte[]");
}
else
{
List <object> list = new List <object>()
{
};
Array array = (Array)(value);
for (int i = 0; i < array.Length; i++)
{
list.Add(array.GetValue(i));
}
obs = list.ToArray();
}
return(encodeArray(stream, obs, refLog));
case AMF_TYPE.Struct:
return(encodeArrayWithStruct(stream, value, refLog));
case AMF_TYPE.String:
return(encodeString(stream, Convert.ToString(value), refLog));
case AMF_TYPE.Default:
return(0);
}
return(0);
}
static public object Decode(Stream reader)
{
reader.Position = 0;
ReferenceLog referenceLog = new ReferenceLog()
{
Strings = new string[] { }, Bytes = new byte[][] { }
};
return(decodeWithRef(reader, referenceLog));
}
static public int Encode(Stream writer, object v)
{
ReferenceLog referenceLog = new ReferenceLog()
{
Strings = new string[] { }, Bytes = new byte[][] { }
};
Utils.utils.Log("encode:--->>", v);
return(encodeWithRef(writer, referenceLog, v));
}
public void Start()
{
using (MemoryStream stream = new MemoryStream())
{
//encodeInt(stream,5);
ReferenceLog reflog = new ReferenceLog();
encodeArray(stream, new int[] { 1, 2, 3 }, reflog);
byte[] datas = stream.ToArray();
Array.Reverse(datas);
Log(datas);
//Console.WriteLine(this.Encode(stream, null));
//Console.WriteLine(stream.ToArray().Length);
}
}
static object decodeArray(Stream stream, ReferenceLog refLog)
{
UInt32 l = decodeU29(stream);
l = l >> 1;
byte[] bs = new byte[1];
stream.Read(bs, 0, bs.Length);
object[] arrayList = new object[l];
for (int i = 0; i < l; i++)
{
arrayList[i] = decodeWithRef(stream, refLog);
}
return(arrayList);
}
static private object decodeWithRef(Stream stream, ReferenceLog refLog)
{
byte[] bs = new byte[1];
int len = stream.Read(bs, 0, bs.Length);
switch (bs[0])
{
case amf_undefine:
return(null);
case amf_null:
return(null);
case amf_false:
return(false);
case amf_true:
return(true);
case amf_integer:
return(decodeInteger(stream));
case amf_double:
return(decodeFloat(stream));
case amf_string:
return(decodeString(stream, refLog));
case amf_byte_array:
return(decodeByteArray(stream, refLog));
case amf_array:
return(decodeArray(stream, refLog));
default:
break;
}
return(null);
}
static int encodeArray(Stream stream, object[] value, ReferenceLog refLog)
{
if (value.GetType() == typeof(System.Byte[]))
{
List <byte> source = new List <byte>();
for (int i = 0; i < value.Length; i++)
{
source.Add((byte)(value[i]));
}
//直接encodeByteArray
return(encodeByteArray(stream, source.ToArray(), refLog));
}
writeAmfType(stream, amf_array);
int l = value.Length;
UInt32 el = Convert.ToUInt32((l << 1) | 1);
if (el > 0x1FFFFFFF)
{
throw new ArgumentOutOfRangeException();
}
int nl = encodeU29(stream, el);
stream.Write(new byte[] { 0x01 }, 0, 1);
int tl = nl + 2;
for (int i = 0; i < l; i++)
{
int nc = encodeWithRef(stream, refLog, value.GetValue(i));
tl += nc;
}
return(tl);
}
int encodeWithRef(Stream stream, ReferenceLog refLog, object value)
{
AMF_TYPE amfType = GetObjectType(value);
Console.WriteLine(amfType);
switch (amfType)
{
case AMF_TYPE.Invalid:
return(encodeNull(stream));
case AMF_TYPE.Bool:
return(encodeBool(stream, Convert.ToBoolean(value)));
case AMF_TYPE.Int:
return(encodeInt(stream, Convert.ToInt64(value)));
case AMF_TYPE.Uint:
return(encodeUint(stream, Convert.ToUInt64(value)));
case AMF_TYPE.Float64:
return(encodeFloat(stream, Convert.ToDouble(value)));
case AMF_TYPE.Array:
return(encodeArray(stream, (Array)value, refLog));
case AMF_TYPE.Struct:
break;
case AMF_TYPE.String:
break;
case AMF_TYPE.Default:
break;
}
return(0);
}
static int encodeByteArray(Stream stream, byte[] value, ReferenceLog refLog)
{
writeAmfType(stream, amf_byte_array);
bool isRef = false;
UInt32 l = Convert.ToUInt32(value.Length);
if (isRef)
{
l = l << 1;
}
else
{
l = (l << 1) | 1;
}
if (l > 0x1FFFFFFF)
{
throw new ArgumentOutOfRangeException();
}
int nl = encodeU29(stream, l);
int ns = 0;
if (!isRef)
{
stream.Write(value, 0, value.Length);
ns = value.Length;
}
return(ns + nl + 1);
}
static int encodeArrayWithStruct(Stream stream, object value, ReferenceLog refLog)
{
//写入数组类型
writeAmfType(stream, amf_array);
Type tp = value.GetType();
System.Reflection.FieldInfo[] infos = tp.GetFields();
int l = infos.Length;
UInt32 el = Convert.ToUInt32((l << 1) | 1);
if (el > 0x1FFFFFFF)
{
throw new ArgumentOutOfRangeException();
}
int nl = encodeU29(stream, el);
stream.Write(new Byte[] { 0x01 }, 0, 1);
int tl = nl + 2;
for (int i = 0; i < l; i += 1)
{
//
int nc = encodeWithRef(stream, refLog, infos[i].GetValue(value));
tl += nc;
}
//
return(tl);
}
public static bool Perform(object obj, GameObjectReference references, bool perform, bool reportFound)
{
bool immediate = false;
bool report = true;
if ((obj is RabbitHoleDoorJig) || (obj is PhoneCell))
{
report = ErrorTrap.kDebugging;
}
else if (obj is Lot)
{
immediate = true;
}
else if (obj is Sim)
{
Sim sim = obj as Sim;
if (sim.LotHome != null)
{
if ((RecoverMissingSimTask.FindPlaceholderForSim(sim.SimDescription) == null) &&
((sim.SimDescription.CreatedSim == null) || (sim.SimDescription.CreatedSim == sim)))
{
immediate = true;
}
}
}
ReferenceLog log = null;
if (!perform)
{
log = new ReferenceLog("Potential Object Found: " + ErrorTrap.GetQualifiedName(obj), report, immediate);
}
if (references == null)
{
return(false);
}
if ((!ErrorTrap.kDebugging) && (references.Count == 0))
{
return(false);
}
if (perform)
{
log = new ReferenceLog("Destroyed Object Found: " + ErrorTrap.GetQualifiedName(obj), report, immediate);
}
log.Perform = perform;
log.ReportFound = reportFound;
if ((!ErrorTrap.kDebugging) && (obj is Lot))
{
return(false);
}
List <DereferenceStack> stack = new List <DereferenceStack>();
foreach (KeyValuePair <object, FieldInfo> pair in references)
{
stack.Add(new DereferenceStack(pair, new Dictionary <ReferenceWrapper, bool>(), new List <ReferenceWrapper>(), new ReferenceWrapper(obj), false, false));
}
bool firstFailure = true;
int index = 0;
while (index < stack.Count)
{
DereferenceStack stackObject = stack[index];
index++;
ReferenceWrapper key = new ReferenceWrapper(stackObject.mReference.Key);
bool recursion = false;
if (stackObject.ContainsKey(key))
{
recursion = true;
}
if ((perform) && (stackObject.Count == 1))
{
log.DumpLog(false);
}
object reference = stackObject.mReference.Key;
string depth = "";
for (int i = 0; i < stackObject.Count - 1; i++)
{
depth += " ";
}
bool reset = false, success = false;
foreach (IDereference dereference in DereferenceManager.Dereferences)
{
DereferenceResult result = dereference.IPerform(stackObject.mReference, stackObject.mList, perform);
if (result == DereferenceResult.Found)
{
log.SetFoundSuccess();
}
if (result != DereferenceResult.Failure)
{
stackObject.mResult = depth + " Reference " + result + ": " + reference.GetType() + " " + stackObject.mReference.Value + " (Using " + dereference.GetType().Name + ")";
if (report)
{
log.Add(stackObject.mResult);
}
success = true;
bool checkSuccess = false;
if (reference is GameObject)
{
stackObject.mEndFound = true;
checkSuccess = true;
GameObject gameObject = reference as GameObject;
if ((perform) && (!HasBeenDestroyed(gameObject)) && (!reset) && (!(reference is Sim)))
{
try
{
reset = true;
gameObject.SetObjectToReset();
log.Add(depth + " Object Reset: " + ErrorTrap.GetQualifiedName(gameObject));
}
catch //(Exception e)
{
//Common.DebugException(gameObject, e);
}
}
}
else
{
switch (result)
{
case DereferenceResult.End:
case DereferenceResult.Found:
stackObject.mEndFound = true;
break;
case DereferenceResult.Continue:
case DereferenceResult.ContinueIfReferenced:
case DereferenceResult.Ignore:
bool unimportant = stackObject.mUnimportant;
switch (result)
{
case DereferenceResult.ContinueIfReferenced:
unimportant = true;
break;
case DereferenceResult.Ignore:
unimportant = true;
stackObject.mEndFound = true;
break;
}
if (!recursion)
{
if (ShouldRecurse(reference))
{
bool referenced = false;
GameObjectReference gameReference = ObjectLookup.GetReference(key);
if (gameReference != null)
{
foreach (KeyValuePair <object, FieldInfo> pair in gameReference)
{
stack.Insert(index, new DereferenceStack(pair, stackObject, key, unimportant, stackObject.mEndFound));
referenced = true;
}
}
if (!referenced)
{
checkSuccess = true;
if (result == DereferenceResult.ContinueIfReferenced)
{
stackObject.mEndFound = true;
}
}
else
{
stackObject.mBridge = true;
}
}
else
{
stackObject.mEndFound = true;
}
}
else if (result == DereferenceResult.ContinueIfReferenced)
{
stackObject.mEndFound = true;
}
else
{
checkSuccess = true;
}
break;
default:
if (recursion)
{
checkSuccess = true;
}
break;
}
}
if (checkSuccess)
{
switch (result)
{
case DereferenceResult.End:
case DereferenceResult.Ignore:
break;
default:
if (recursion)
{
if (!object.ReferenceEquals(key.mObject, obj))
{
log.SetFailure("A");
}
else
{
stackObject.mEndFound = true;
}
}
else
{
log.SetFailure("B");
}
break;
}
}
}
}
if (!success)
{
bool mustRecurse = false;
string priority = "UNHANDLED";
if (recursion)
{
priority = "Recursion";
if (object.ReferenceEquals(key.mObject, obj))
{
stackObject.mEndFound = true;
}
else
{
stackObject.mBridge = true;
}
}
else if ((reference.GetType().IsArray) ||
(reference is IList) ||
(reference is IDictionary) ||
(reference is ICollection) ||
(reference.GetType().Name.Contains("ForgetfulList")) ||
(reference.GetType().Name.Contains("PairedListDictionary")))
{
priority = "Bridge";
mustRecurse = true;
stackObject.mBridge = true;
}
else if (stackObject.mUnimportant)
{
priority = "Ancillary";
if ((reference is GameObject) || (reference is SimDescription))
{
recursion = true;
}
else
{
mustRecurse = true;
}
stackObject.mBridge = true;
}
else
{
log.ImportantFound();
log.SetFailure("C");
}
stackObject.mResult = depth + " " + priority + " Reference: " + ErrorTrap.GetQualifiedName(reference) + " " + stackObject.mReference.Value;
if (report)
{
log.Add(stackObject.mResult);
}
bool referenced = false;
if (!recursion)
{
if (ShouldRecurse(reference))
{
GameObjectReference gameReference = ObjectLookup.GetReference(key);
if (gameReference != null)
{
foreach (KeyValuePair <object, FieldInfo> pair in gameReference)
{
stack.Insert(index, new DereferenceStack(pair, stackObject, key, stackObject.mUnimportant, stackObject.mEndFound));
referenced = true;
}
}
}
else
{
stackObject.mEndFound = true;
mustRecurse = false;
}
}
if (!referenced)
{
if (mustRecurse)
{
log.SetFailure("D");
}
}
else
{
stackObject.mBridge = true;
}
}
if ((!perform) && (!log.IsTotalSuccess) && (firstFailure))
{
firstFailure = false;
log.Add(depth + " RETAINED " + log.FailureReason);
}
}
bool first = true;
foreach (DereferenceStack stackObject in stack)
{
if (stackObject.mEndFound)
{
continue;
}
if (stackObject.mBridge)
{
continue;
}
log.EndMissing();
if (first)
{
first = false;
log.Add(" OPEN ENDED");
}
log.Add(stackObject.mResult);
}
log.DumpLog(false);
Logger.ForceRecord();
return(log.IsTotalSuccess);
}
public int Encode(Stream stream, object v)
{
ReferenceLog reflog = new ReferenceLog();
return(this.encodeWithRef(stream, reflog, v));
}
