public object UnstageValue(StageItem item, Type targetType)
{
Type elementType;
StageItem[] array = ((StageList)item).Items().ToArray <StageItem>();
if (targetType.IsArray)
{
elementType = targetType.GetElementType();
Array arrays = Array.CreateInstance(elementType, (int)array.Length);
for (int i = 0; i < (int)array.Length; i++)
{
object obj = SerializationMaster.Unstage(array[i], elementType);
arrays.SetValue(obj, i);
}
return(arrays);
}
elementType = (!targetType.IsGenericType ? typeof(object) : targetType.GetGenericArguments()[0]);
IList lists = Activator.CreateInstance(targetType, new object[] { (int)array.Length }) as IList;
for (int j = 0; j < (int)array.Length; j++)
{
object obj1 = SerializationMaster.Unstage(array[j], elementType);
lists.Add(obj1);
}
return(lists);
}
// Use this for initialization
void Start()
{
Regex monsterItem = new Regex("m (-?[0-9]+) (-?[0-9]+) ([0-9]+)");
Regex bossItem = new Regex("b ([0-9]+)");
string [] lines = StageInformation.text.Split('\n');
foreach (string line in lines)
{
StageItem item = new StageItem();
switch (line [0])
{
case 'm':
{
var match = monsterItem.Match(line);
item.IsBoss = false;
item.Position = int.Parse(match.Groups [1].Value) / 480.0f * 4 - 2;
item.Angle = float.Parse(match.Groups [2].Value);
item.RaiseTime = int.Parse(match.Groups [3].Value) / 1000.0f;
}
break;
case 'b':
{
var match = bossItem.Match(line);
item.IsBoss = true;
item.Position = 0;
item.Angle = 0;
item.RaiseTime = int.Parse(match.Groups [1].Value) / 1000.0f;
}
break;
}
stageItems.Enqueue(item);
}
}
public void WriteLabel(StageItem l)
{
_b.Append('"');
StringHandler.EscapeString(l.name, _b);
_b.Append('"');
_b.Append(':');
}
public void WriteLabel(StageItem l)
{
this._b.Append('\"');
StringHandler.EscapeString(l.name, this._b);
this._b.Append('\"');
this._b.Append(':');
}
// Update is called once per frame
void Update()
{
elapsedTime += Time.deltaTime;
do
{
if (stageItems.Count == 0)
{
break;
}
if (stageItems.Peek().RaiseTime <= elapsedTime)
{
StageItem currentItem = stageItems.Dequeue();
GameObject mob = Instantiate(currentItem.IsBoss ? EmittionBoss : EmittionEnemy);
mob.transform.position = new Vector3(currentItem.Position, currentItem.IsBoss ? 5.6f : 4.4f, 0);
if (!currentItem.IsBoss)
{
mob.GetComponent <EnemyController> ().Angle = currentItem.Angle;
}
else
{
bossName = mob.name;
Debug.Log(bossName);
}
}
else
{
break;
}
} while (true);
if (stageItems.Count == 0 && GameObject.Find(bossName) == null)
{
//Debug.Log ( "NextStage" );
if (!createdNextStage)
{
createdNextStage = true;
if (NextStage != null)
{
var nextStage = Instantiate(NextStage);
--nextStage.transform.GetChild(0).GetComponent <SpriteRenderer> ().sortingOrder;
nextStageName = nextStage.name;
}
}
var backgroundRenderer = gameObject.transform.GetChild(0).GetComponent <SpriteRenderer> ();
backgroundRenderer.color = new Color(1, 1, 1, backgroundRenderer.color.a - (0.3f * Time.deltaTime));
if (backgroundRenderer.color.a <= 0)
{
var nextStage = GameObject.Find(nextStageName);
if (nextStage != null)
{
++nextStage.transform.GetChild(0).GetComponent <SpriteRenderer> ().sortingOrder;
}
Destroy(gameObject);
}
}
}
/// <summary>
/// Unstages the value.
/// </summary>
/// <param name="item">The stage item to unstage.</param>
/// <param name="targetType">Type of the value.</param>
/// <returns>
/// The unstaged value.
/// </returns>
public object UnstageValue(StageItem item, Type targetType)
{
var el = (StageElement)item;
return(new Vector2(
el.AttributeValue <float>("x"),
el.AttributeValue <float>("y")));
}
private void RecordRepairedAIs()
{
var repaired = new List <StageElement>();
for (int i = 0; i < _typeResolution.Length; i++)
{
var tre = _typeResolution[i].elements;
for (int j = 0; j < tre.Length; j++)
{
StageItem el = tre[j];
while (el.parent != null)
{
el = el.parent;
}
var root = el as StageElement;
repaired.AddUnique(root);
}
}
for (int i = 0; i < _membersResolution.Length; i++)
{
var mre = _membersResolution[i].unresolvedMembers;
for (int j = 0; j < mre.Count; j++)
{
var items = mre[j].items;
for (int k = 0; k < items.Length; k++)
{
StageItem el = items[k];
while (el.parent != null)
{
el = el.parent;
}
var root = el as StageElement;
repaired.AddUnique(root);
}
}
}
for (int i = 0; i < _mismatchedMembers.Length; i++)
{
var el = _mismatchedMembers[i].item;
while (el.parent != null)
{
el = el.parent;
}
var root = el as StageElement;
repaired.AddUnique(root);
}
var ids = repaired.Select(el => el.ValueOrDefault("_id", string.Empty));
//Since the serialization uses a compact (N) format for guids but the AIStorage component does not, we have to do this rather lame conversion.
_repairedAIIds = ids.Where(id => !string.IsNullOrEmpty(id)).Select(id => new Guid(id).ToString()).ToArray();
}
public override void OnOpen(params object[] args)
{
var stageList = StageConfigManager.Instance.stageList;
foreach (var stage in stageList)
{
var item = new StageItem(tmp, stage);
list.Add(item);
}
}
/// <summary>
/// Unstages the value.
/// </summary>
/// <param name="item">The stage item to unstage.</param>
/// <param name="targetType">Type of the value.</param>
/// <returns>
/// The unstaged value.
/// </returns>
public object UnstageValue(StageItem item, Type targetType)
{
var el = (StageElement)item;
return(new Rect(
el.AttributeValue <float>("left"),
el.AttributeValue <float>("top"),
el.AttributeValue <float>("width"),
el.AttributeValue <float>("height")));
}
/// <summary>
/// Unstages the value.
/// </summary>
/// <param name="item">The stage item to unstage.</param>
/// <param name="targetType">Type of the value.</param>
/// <returns>
/// The unstaged value.
/// </returns>
public object UnstageValue(StageItem item, Type targetType)
{
var el = (StageElement)item;
return(new Color(
el.AttributeValue <float>("r"),
el.AttributeValue <float>("g"),
el.AttributeValue <float>("b"),
el.AttributeValue <float>("a")));
}
public string Serialize(StageItem item, bool pretty)
{
StageElement stageElement = item as StageElement;
if (stageElement == null)
{
throw new ArgumentException("Only StageElements can serve as the root of a serialized graph.");
}
return((new StagedToJson(pretty)).Serialize(stageElement));
}
public object UnstageValue(StageItem item, Type targetType)
{
return(new AnimationCurve((
from key in ((StageElement)item).Elements()
select new Keyframe()
{
time = key.AttributeValue <float>("time"),
@value = key.AttributeValue <float>("value"),
inTangent = key.AttributeValue <float>("inTangent"),
outTangent = key.AttributeValue <float>("outTangent"),
tangentMode = key.AttributeValue <int>("tangentMode")
}).ToArray <Keyframe>()));
}
public StageItem StageValue(string name, object value)
{
IList lists = value as IList;
int count = lists.Count;
StageList stageList = new StageList(name);
for (int i = 0; i < count; i++)
{
StageItem stageItem = SerializationMaster.Stage("Item", lists[i]);
stageList.Add(stageItem);
}
return(stageList);
}
/// <summary>
/// Serializes the specified staged object (or object graph).
/// </summary>
/// <param name="item">The staged representation of the object to serialize.</param>
/// <param name="pretty">Whether to serialize the data in a pretty (reader friendly) format.</param>
/// <returns>
/// The serialized representation of the object.
/// </returns>
/// <exception cref="System.ArgumentException">Only StageElements can serve as the root of a serialized graph.</exception>
public string Serialize(StageItem item, bool pretty)
{
var root = item as StageElement;
if (root == null)
{
throw new ArgumentException("Only StageElements can serve as the root of a serialized graph.");
}
var s = new StagedToJson(pretty);
return(s.Serialize(root));
}
static bool Prefix(Stage __instance, ref List <StageItem> ___orderList)
{
PropertyInfo property = typeof(Stage).GetProperty("CurDay", BindingFlags.Instance);
property.SetValue(__instance, Module <TimeManager> .Self.Days, null);
MethodInfo dynMethod = __instance.GetType().GetMethod("ClearDataButMaxAccept", BindingFlags.NonPublic | BindingFlags.Instance);
dynMethod.Invoke(__instance, new object[] { });
List <StageItemData> list = StageItemData.List;
for (int i = 0; i < list.Count; i++)
{
StageItem stageItem = new StageItem();
stageItem.Convert(list[i]);
___orderList.Add(stageItem);
}
List <TypePriceData> list2 = TypePriceData.List;
int num2 = 0;
List <IdCount> list3 = new List <IdCount>();
for (int j = 0; j < list2.Count; j++)
{
TypePriceData typePriceData = list2[j];
if (typePriceData.NumLimit != null && typePriceData.NumLimit.Length > 0 && typePriceData.NumLimit[0] > 0)
{
___orderList[num2].SetPriceType(typePriceData.Type);
list3.Add(typePriceData.Type, 1);
num2++;
}
if (num2 >= list.Count)
{
break;
}
}
num2 = 0;
list2 = GameUtils.RandomSortList <TypePriceData>(list2);
foreach (StageItem stageItem2 in ___orderList)
{
if (stageItem2.PriceType == 0)
{
TypePriceData typePriceData2 = list2[num2 % list2.Count];
stageItem2.SetPriceType(typePriceData2.Type);
num2++;
}
}
return(false);
}
private string GetParentTypeName(StageItem item)
{
var parent = item.parent;
if (parent is StageElement)
{
var parentTypeName = ((StageElement)parent).AttributeValueOrDefault <string>("type");
return(parentTypeName != null ? parentTypeName : string.Empty);
}
var listType = ResolveExpectedBaseType(item, false);
return(listType != null?listType.ProperName(false) : "List");
}
/// <summary>
/// Unstages the value.
/// </summary>
/// <param name="item">The stage item to unstage.</param>
/// <param name="targetType">Type of the value.</param>
/// <returns>
/// The unstaged value.
/// </returns>
public object UnstageValue(StageItem item, Type targetType)
{
var el = (StageElement)item;
return(new Bounds(
new Vector3(
SerializationMaster.FromString <float>(el.Attribute("center.x").value),
SerializationMaster.FromString <float>(el.Attribute("center.y").value),
SerializationMaster.FromString <float>(el.Attribute("center.z").value)),
new Vector3(
SerializationMaster.FromString <float>(el.Attribute("size.x").value),
SerializationMaster.FromString <float>(el.Attribute("size.y").value),
SerializationMaster.FromString <float>(el.Attribute("size.z").value))));
}
/// <summary>
/// Unstages the value.
/// </summary>
/// <param name="item">The stage item to unstage.</param>
/// <param name="targetType">Type of the value.</param>
/// <returns>
/// The unstaged value.
/// </returns>
public object UnstageValue(StageItem item, Type targetType)
{
var element = (StageElement)item;
var keys = (from key in element.Elements()
select new Keyframe
{
time = key.AttributeValue <float>("time"),
value = key.AttributeValue <float>("value"),
inTangent = key.AttributeValue <float>("inTangent"),
outTangent = key.AttributeValue <float>("outTangent"),
tangentMode = key.AttributeValue <int>("tangentMode")
}).ToArray();
return(new AnimationCurve(keys));
}
public object UnstageValue(StageItem item, Type targetType)
{
StageElement[] array = ((StageList)item).Elements().ToArray <StageElement>();
Type[] genericArguments = targetType.GetGenericArguments();
Type type = genericArguments[0];
Type type1 = genericArguments[1];
IDictionary dictionaries = Activator.CreateInstance(targetType, new object[] { (int)array.Length }) as IDictionary;
for (int i = 0; i < (int)array.Length; i++)
{
StageElement stageElement = array[i];
object obj = SerializationMaster.Unstage(stageElement.Item("key"), type);
object obj1 = SerializationMaster.Unstage(stageElement.Item("value"), type1);
dictionaries.Add(obj, obj1);
}
return(dictionaries);
}
/// <summary>
/// Unstages the value.
/// </summary>
/// <param name="item">The stage item to unstage.</param>
/// <param name="targetType">Type of the value.</param>
/// <returns>
/// The unstaged value.
/// </returns>
public object UnstageValue(StageItem item, Type targetType)
{
var el = (StageList)item;
var items = el.Items().ToArray();
Type itemType;
if (targetType.IsArray)
{
itemType = targetType.GetElementType();
var arr = Array.CreateInstance(itemType, items.Length);
for (int i = 0; i < items.Length; i++)
{
var itemValue = SerializationMaster.Unstage(items[i], itemType);
arr.SetValue(itemValue, i);
}
return(arr);
}
//A list
if (targetType.IsGenericType)
{
itemType = targetType.GetGenericArguments()[0];
}
else
{
itemType = typeof(object);
}
var list = Activator.CreateInstance(targetType, items.Length) as IList;
for (int i = 0; i < items.Length; i++)
{
var itemValue = SerializationMaster.Unstage(items[i], itemType);
list.Add(itemValue);
}
return(list);
}
/// <summary>
/// Unstages the value.
/// </summary>
/// <param name="item">The stage item to unstage.</param>
/// <param name="targetType">Type of the value.</param>
/// <returns>
/// The unstaged value.
/// </returns>
public object UnstageValue(StageItem item, Type targetType)
{
var el = (StageList)item;
var elements = el.Elements().ToArray();
var typeArgs = targetType.GetGenericArguments();
Type keyType = typeArgs[0];
Type valueType = typeArgs[1];
var dic = Activator.CreateInstance(targetType, elements.Length) as IDictionary;
for (int i = 0; i < elements.Length; i++)
{
var element = elements[i];
var key = SerializationMaster.Unstage(element.Item("key"), keyType);
var value = SerializationMaster.Unstage(element.Item("value"), valueType);
dic.Add(key, value);
}
return(dic);
}
private Type ResolveExpectedBaseType(StageItem el, bool elementType)
{
var parent = el.parent;
if (parent == null)
{
return(null);
}
var parentElement = parent as StageElement;
if (parentElement != null)
{
var parentTypeName = parentElement.AttributeValueOrDefault <string>("type");
if (parentTypeName == null)
{
/* For custom types that have no type attribute, the entire type will be validated at once, so we ignore individual members. */
return(null);
}
Type parentType;
if (!_identifiedTypes.TryGetValue(parentTypeName, out parentType))
{
return(null);
}
var prop = parentType.GetProperty(el.name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (prop != null)
{
return(prop.PropertyType);
}
var field = parentType.GetField(el.name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (field != null)
{
return(field.FieldType);
}
return(null);
}
var parentList = parent as StageList;
if (parentList == null)
{
return(null);
}
var listType = ResolveExpectedBaseType(parentList, elementType);
if (!elementType)
{
return(listType);
}
while (typeof(IList).IsAssignableFrom(listType))
{
if (listType.IsArray)
{
listType = listType.GetElementType();
}
else if (listType.IsGenericType)
{
listType = listType.GetGenericArguments()[0];
}
else
{
listType = null;
}
}
return(listType);
}
public object UnstageValue(StageItem item, Type targetType)
{
StageElement stageElement = (StageElement)item;
return(new Vector4(stageElement.AttributeValue <float>("x"), stageElement.AttributeValue <float>("y"), stageElement.AttributeValue <float>("z"), stageElement.AttributeValue <float>("w")));
}
