/// <summary> /// Invokes a class method that doesn't take an instance as a receiver. /// </summary> /// <param name="vm">The environment in which to invoke the method.</param> /// <param name="value">The class the method belongs to.</param> /// <param name="methodName">The name of the method.</param> /// <returns>The method's return value.</returns> /// <exception cref="Exception"> /// If the methodName isn't a method of the class or /// if Rhs isn't a <see cref="Block"/>. /// </exception> private Value InvokeBoundMethodClass(VM vm, ClassValue value, string methodName) { if (!value.ClassMethods.ContainsKey(methodName)) { if (value.Methods.ContainsKey(methodName)) { throw new Exception(string.Format( "'{0}' is not a class method of '{1}'. Requires an instance of the class.", methodName, value.Name)); } else { throw new Exception(string.Format("'{0}' is not a method of '{1}'.", methodName, value.Name)); } } LambdaExpression method = value.ClassMethods[methodName].Lambda; Block args = Rhs as Block; if (args == null) { throw new Exception("Internal: 'rhs' of 'Invocation' was not a 'Block'."); } VM @new = new VM(null, vm.Global); SetArguments(vm, @new, method, args.Nodes); return(CallWith(method, @new)); }
/// <summary> /// Invokes a given class. /// </summary> /// <param name="vm">The environment in which to invoke the class.</param> /// <param name="value">The class to invoke.</param> /// <returns>A new <see cref="InstanceValue"/> of the given class.</returns> /// <exception cref="Exception"> /// If Rhs doesn't return a <see cref="Block"/> or /// if 'init()' doesn't return a <see cref="NilValue"/>. /// </exception> private Value InvokeClass(VM vm, ClassValue value) { var self = new InstanceValue(value); if (value.Methods.ContainsKey("init")) { var init = value.Methods["init"].Lambda; Block args = Rhs as Block; if (args == null) { throw new Exception("Internal: 'rhs' of 'Invocation' was not a 'Block'."); } VM @new = new VM(null, vm.Global); @new.Constants.Add(value.Name, value); @new.Constants.Add("self", self); SetArguments(vm, @new, init, args.Nodes); try { init.Body.Execute(@new); } catch (ReturnStatement.Signal sig) { if (!sig.Value.IsNil()) { throw new Exception("Cannot return a non-nil value from class initializer."); } } } return(self); }
/// <summary> /// 将一个场景物体转换为信息(string) /// </summary> /// <param name="root"></param> /// <returns></returns> public string GetSceneInfo() { MapWorld mapWorld = new MapWorld(); List <MapObject> mapobjs = new List <MapObject>(); int childCount = mapNameRoot.childCount; for (int i = 0; i < childCount; i++) { Transform item = mapNameRoot.GetChild(i); MapObject mop = new MapObject(); mop.name = item.name; mop.isStatic = item.gameObject.isStatic; mop.transformInfo.position = item.localPosition; mop.transformInfo.rotation = item.localRotation.eulerAngles; mop.transformInfo.scale = item.localScale; MonoBehaviour[] mos = item.GetComponents <MonoBehaviour>(); foreach (MonoBehaviour m in mos) { ClassValue cv = new ClassValue(m); mop.behavirComponets.Add(cv); } mapobjs.Add(mop); } mapWorld.mapObjects = mapobjs; mapWorld.lightPrefab = mapLightRoot.name; return(JsonUtils.ClassOrStructToJson(mapWorld)); }
public ClassValue(string name, ClassValue superClass) : base(ValueType.Class) { Name = name; Methods = new Dictionary <string, LambdaValue>(); ClassMethods = new Dictionary <string, LambdaValue>(); SuperClass = superClass; }
/// <summary> /// Adds a new <see cref="ClassValue"/> to <see cref="VM.Constants"/>. /// </summary> /// <param name="vm">The environment in which to add the new class.</param> /// <returns>A <see cref="NilValue"/>.</returns> /// <exception cref="Exception"> /// If there is an unresolved identifier for its super class. /// If super class identifier doesn't correspond to a <see cref="ClassValue"/>. /// </exception> public Value Execute(VM vm) { ClassValue super = null; if (superClass != null) { if (!vm.Constants.ContainsKey(superClass)) { throw new Exception(string.Format("Unresolved identifier '{0}'.", superClass)); } Value superClassValue = vm.Constants[superClass]; Value.AssertType(Value.ValueType.Class, superClassValue, "Cannot inherit from something of type '{0}'.", superClassValue.Type); super = superClassValue.Class; } var @class = new ClassValue(name, super); if (super != null) { foreach (var method in super.Methods) { string methodName = method.Key; if (methodName == "<SUPER>") { continue; } if (method.Key == "init") { methodName = "<SUPER>"; } @class.Methods[methodName] = method.Value; } foreach (var method in super.ClassMethods) { @class.ClassMethods[method.Key] = method.Value; } } foreach (var method in methods) { string methodName = method.Id; LambdaValue methodVal = method.Execute(vm) as LambdaValue; @class.Methods[methodName] = methodVal; } foreach (var method in classMethods) { string methodName = method.Id; LambdaValue methodVal = method.Execute(vm) as LambdaValue; @class.ClassMethods[methodName] = methodVal; } vm.Constants.Add(name, @class); return(new NilValue()); }
public override void OnClose() { ecs.ECSComponentData.Clear(); ecs.LS4ECS_Name = LS4ECS_Name; foreach (var item in componentData.Keys) { ClassValue classValue = new ClassValue(componentData[item]); ecs.ECSComponentData.Add(classValue); } }
private void Save() { config.allAppModuleSetting.Clear(); foreach (var item in allModules) { ClassValue value = new ClassValue(item.Value, false); config.allAppModuleSetting.Add(item.Key.Name, value); } GameBootConfig.Save(config); }
/// <summary> /// Calls the init method of an instance's superclass. /// </summary> /// <remarks> /// Expects a constant called 'self' to be present in the VM. /// Expects it to have a superclass with an 'init()' method. /// </remarks> /// <param name="vm">Used to access global scope.</param> /// <returns>A <see cref="NilValue"/>.</returns> /// <exception cref="Exception">If an expectation is not met or another runtime error occurs.</exception> public override Value Execute(VM vm) { if (!vm.Parent.Constants.ContainsKey("self") || !(vm.Parent.Constants["self"] is InstanceValue)) { throw new Exception("Can only call 'super()' inside a class."); } InstanceValue self = vm.Parent.Constants["self"].Instance; ClassValue selfClass = self.UpCast(); if (!selfClass.Methods.ContainsKey("<SUPER>")) { throw new Exception(string.Format("Cannot call 'super()'. '{0}' is not a subclass.", selfClass.Name)); } LambdaExpression super = selfClass.Methods["<SUPER>"].Lambda; if (Nodes.Count != super.Args.Count) { throw new Exception(string.Format( "Argument Mistmatch! {0}.super takes {1} argument(s) but was given {2}.", selfClass.Name, super.Args.Count, Nodes.Count)); } VM @new = new VM(null, vm.Global); @new.Constants.Add("self", self); for (int i = 0; i < super.Args.Count; i++) { string argId = super.Args[i]; Value arg = Nodes[i].Execute(vm); @new.Variables.Add(argId, arg); } try { super.Body.Execute(@new); } catch (ReturnStatement.Signal sig) { if (!sig.Value.IsNil()) { throw new Exception("Cannot return a value from class initializer."); } } self.Cast(selfClass); return(new NilValue()); }
protected override void Action() { Entity entity = WorldManager.CurrentRunWorld.CreateEntity(); for (int i = 0; i < ECSComponentData.Count; i++) { ClassValue cv = ECSComponentData[i]; IComponent component = (IComponent)cv.GetValue(); if (component != null) { entity.AddComponent(component); } } }
/// <summary> /// Invokes a method with an <see cref="InstanceValue"/> as the receiver. /// </summary> /// <param name="vm">The environment in which to invoke the method.</param> /// <param name="receiver">The receiver of the method.</param> /// <param name="methodName">The name of the method.</param> /// <returns>The method's return value.</returns> /// <exception cref="Exception"> /// If the methodName isn't a method of the class or /// if Rhs isn't a <see cref="Block"/>. /// </exception> private Value InvokeBoundMethodInstance(VM vm, InstanceValue receiver, string methodName) { ClassValue @class = receiver.Class; if ([email protected](methodName)) { throw new Exception(string.Format("'{0}' is not a method of '{1}'.", methodName, @class.Name)); } var method = @class.Methods[methodName].Lambda; Block args = Rhs as Block; if (args == null) { throw new Exception("Internal: 'rhs' of 'Invocation' was not a 'Block'."); } VM @new = new VM(null, vm.Global); @new.Constants.Add("self", receiver); SetArguments(vm, @new, method, args.Nodes); return(CallWith(method, @new)); }
public void ReadXml (XmlTextReader xtr) { while (xtr.Read ()) { switch (xtr.NodeType) { case XmlNodeType.Element: string name = xtr.GetAttribute ("name"); ClassValue class_value = classvalues_hashtable [name] as ClassValue; if (class_value == null) { class_value = new ClassValue (); class_value.Name = name; classvalues_hashtable [name] = class_value; } class_value.ReadXml (xtr); break; case XmlNodeType.EndElement: return; } } }
public void SetValue (string value_name, object value) { ClassValue class_value = classvalues_hashtable [value_name] as ClassValue; if (class_value == null) { class_value = new ClassValue (); class_value.Name = value_name; classvalues_hashtable [value_name] = class_value; } class_value.SetValue (value); }
/// <summary> /// 生成场景物体 /// </summary> /// <param name="id"></param> public static void CreateMapGameObjectInScene(int id) { List <GameObject> listObjs = new List <GameObject>(); LightMapObject lightMapObject; MapWorld mapWorld = GetMapObject(id, out lightMapObject); if (mapWorld == null) { mapWorld = new MapWorld(); } List <MapObject> mapObjs = mapWorld.mapObjects; if (mapRoot == null) { mapRoot = new GameObject(MapUseConstValues.MapRootObjectName); } Transform idRoot = mapRoot.transform.Find(id.ToString()); if (idRoot == null) { idRoot = new GameObject(id.ToString()).transform; idRoot.SetParent(mapRoot.transform); } if (mapObjs == null) { mapObjs = new List <MapObject>(); return; } GameObject mapObj = new GameObject(MapUseConstValues.MapObjectsObjectName); mapObj.transform.SetParent(idRoot); string lightPrefabName = MapUseConstValues.LightPrefabNamePrefix + MapInfosDic[id].mapFileName; GameObject mapLights = null; mapLights = PoolObjectManager.GetObject(lightPrefabName); if (mapLights == null) { mapLights = new GameObject(lightPrefabName); } mapLights.transform.SetParent(idRoot); string colliderPrefabName = MapUseConstValues.ColliderPrefabNamePrefix + MapInfosDic[id].mapFileName; GameObject mapColliderObj = null; mapColliderObj = PoolObjectManager.GetObject(colliderPrefabName); if (mapColliderObj == null) { mapColliderObj = new GameObject(colliderPrefabName); } mapColliderObj.transform.SetParent(idRoot); if (lightMapObject != null) { LightmapSettings.lightmapsMode = lightMapObject.lightmapsMode; RenderSettings.fog = lightMapObject.fogInfo.fog; RenderSettings.fogMode = lightMapObject.fogInfo.fogMode; RenderSettings.fogColor = lightMapObject.fogInfo.fogColor; RenderSettings.fogStartDistance = lightMapObject.fogInfo.fogStartDistance; RenderSettings.fogEndDistance = lightMapObject.fogInfo.fogEndDistance; RenderSettings.fogDensity = lightMapObject.fogInfo.fogDensity; List <Texture2D> lightmapDir = new List <Texture2D>(); for (int i = 0; i < lightMapObject.lightmapDir.Count; i++) { string name = lightMapObject.lightmapDir[i]; Texture2D tex = ResourcesManager.LoadUnityAssetByName <Texture2D>(name); lightmapDir.Add(tex); } List <Texture2D> lightmapColor = new List <Texture2D>(); for (int i = 0; i < lightMapObject.lightmapColor.Count; i++) { string name = lightMapObject.lightmapColor[i]; Texture2D tex = ResourcesManager.LoadUnityAssetByName <Texture2D>(name); lightmapColor.Add(tex); } LightmapData[] lightmapData = new LightmapData[lightmapDir.Count > lightmapColor.Count ? lightmapDir.Count : lightmapColor.Count]; for (int i = 0; i < lightmapData.Length; i++) { lightmapData[i] = new LightmapData(); lightmapData[i].lightmapColor = i < lightmapColor.Count ? lightmapColor[i] : null; lightmapData[i].lightmapDir = i < lightmapDir.Count ? lightmapDir[i] : null; } LightmapSettings.lightmaps = lightmapData; } for (int i = 0; i < mapObjs.Count; i++) { MapObject mp = mapObjs[i]; GameObject obj = PoolObjectManager.GetObject(mp.name); obj.isStatic = mp.isStatic; obj.transform.SetParent(mapObj.transform); obj.transform.localPosition = mp.transformInfo.position; obj.transform.localRotation = Quaternion.Euler(mp.transformInfo.rotation); obj.transform.localScale = mp.transformInfo.scale; for (int j = 0; j < mp.behavirComponets.Count; j++) { ClassValue cv = mp.behavirComponets[j]; cv.GetValue((type) => { object v = obj.GetComponent(type); if (v == null) { v = obj.AddComponent(type); } return(v); }); } listObjs.Add(obj); if (lightMapObject != null && obj.isStatic) { MapObjectRendererLightMapInfo renderInfo = lightMapObject.mapObjectRendererLightMapInfo[i]; MeshRenderer[] msR = obj.GetComponentsInChildren <MeshRenderer>(); for (int j = 0; j < msR.Length; j++) { RendererLightMapInfo r = renderInfo.renderLightMapInfos[j]; msR[j].lightmapIndex = r.lightmapIndex; msR[j].lightmapScaleOffset = r.lightmapScaleOffset; } } } if (lightMapObject != null) { Dictionary <string, string> reflectionProbesInfoDic = new Dictionary <string, string>(); for (int i = 0; i < lightMapObject.reflectionProbeInfos.Count; i++) { ReflectionProbeInfo info = lightMapObject.reflectionProbeInfos[i]; reflectionProbesInfoDic.Add(info.gameObjectName, info.reflectionProbeFileName); } ReflectionProbe[] reflectionProbes = mapLights.GetComponentsInChildren <ReflectionProbe>(); for (int i = 0; i < reflectionProbes.Length; i++) { ReflectionProbe re = reflectionProbes[i]; string name = reflectionProbesInfoDic[re.gameObject.name]; Texture tex = ResourcesManager.LoadUnityAssetByName <Texture>(name); re.bakedTexture = tex; } } if (!mapInstanceBuffer.ContainsKey(id)) { mapInstanceBuffer.Add(id, listObjs); } }
public ClassField(ClassValue value) { _value = value; }