public static void FinalizeEnv(EnvironmentObject env) { // Add gems to random locs for (int i = 0; i < 6; ++i) { CreateItem(env, ItemID.Gem, GetRandomMaterial(MaterialCategory.Gem), env.GetRandomEnterableSurfaceLocation()); } // Add rocks to random locs for (int i = 0; i < 6; ++i) { CreateItem(env, ItemID.Rock, GetRandomMaterial(MaterialCategory.Rock), env.GetRandomEnterableSurfaceLocation()); } CreateWorkbenches(env); CreateStartItems(env); CreateDebugItems(env); { var gen = FoodGenerator.Create(env.World); gen.MoveToMustSucceed(env, env.GetSurfaceLocation(env.Width / 2 - 2, env.Height / 2 - 2)); } AddMonsters(env); }
private void Start() { if (NetworkClient.active) { return; } // Check if this instance was started as a client. EnvironmentVariables environmentVariables = EnvironmentVariables.singleton; if (environmentVariables.isServer) { return; } // Show the loading screen and connect to the server. GameServerModel gameServerModel = environmentVariables.gameServerModel; // Override Access and Refresh Tokens. TokenManager.singleton.accessToken = environmentVariables.accessToken; TokenManager.singleton.refreshToken = environmentVariables.refreshToken; // Set the port. kcpTransport.Port = Convert.ToUInt16(gameServerModel.port); // Set the URL. EnvironmentObject environment = EnvironmentManager.singleton.environmentObject; string host = new Uri(environment.gameServerApiBaseUrl).Host; Uri uri = new Uri(string.Format("tcp4://{0}", host)); // Start the client. networkManager.StartClient(uri); }
protected override void Insert(EnvironmentObject obj) { if (obj != null) { base.Insert(obj); } }
static void SetArea(EnvironmentObject env, IntGrid3 area, TileData data) { foreach (var p in area.Range()) { env.SetTileData(p, data); } }
private void SelectObject() { var hit = new RaycastHit(); var ray = Camera.main.ScreenPointToRay(Input.mousePosition); if (Physics.Raycast(ray, out hit, 1000)) { var obj = hit.collider.GetComponent <EnvironmentObject>(); if (obj != null) { CurrentObjectToEdit = obj; _innerState = AnimState.CHOOSE_ANIM; Debug.Log("Object selected! You can now chhose animation for it!"); GameController.Instance.AnimController.DisplayToUser("Object selected! You can now chhose animation for it!"); particle.transform.position = CurrentObjectToEdit.transform.position; particle.SetActive(true); particle.GetComponent <ParticleSystem>().Play(); if (CurrentObjectToEdit.unityChan) { CurrentObjectToEdit.gameObject.GetComponent <UChanVoice>().PlayHuhu(); } if (objectChosenEvent != null) { objectChosenEvent(obj); } } } else { // CurrentObjectToEdit = null; // _innerState = AnimState.NO_OBJECT; } }
public void InitializeWorld(World world, IntSize3 size) { CreateTerrain(size); IntVector3? stairs = null; foreach (var p2 in m_terrainData.Size.Plane.Range()) { var p = new IntVector3(p2, m_terrainData.Size.Depth - 1); var td = m_terrainData.GetTileData(p.Down); if (td.ID == TileID.Stairs) { stairs = p; break; } } if (stairs.HasValue == false) throw new Exception(); m_env = EnvironmentObject.Create(world, m_terrainData, VisibilityMode.LivingLOS, stairs.Value); CreateMonsters(); CreateDebugMonsterAtEntry(); }
void SetItemActive(EnvironmentObject id, bool isactive) { if (items.ContainsKey(id)) { items[id].SetActive(isactive); } }
public GameObject GetEnvironmentObject() { if (useDebugPlatform) { return(debugPlatform); } float total = 0; foreach (GameObject obj in levelEnvironmentObjects) { total += obj.GetComponentInChildren <EnvironmentObject>().SpawnChances[level]; } float randomPoint = Random.value * total; for (int i = 0; i < levelEnvironmentObjects.Length; i++) { EnvironmentObject eoScript = levelEnvironmentObjects[i].GetComponentInChildren <EnvironmentObject>(); if (randomPoint < eoScript.SpawnChances[level]) { return(levelEnvironmentObjects[i]); } else { randomPoint -= eoScript.SpawnChances[level]; } } return(levelEnvironmentObjects[levelEnvironmentObjects.Length - 1]); }
public EnvironmentObject InitializeObject(EnvironmentType elemtype, Vector3 startpos) { EnvironmentObject tempObj = null; if (ObjectPool.Instance.HasObject(elemtype)) { tempObj = ObjectPool.Instance.DepoolObject(elemtype); // tempBullet.gameObject.transform.position = startpos; } else { switch (elemtype) { case EnvironmentType.Tower: tempObj = GameObject.Instantiate(tower).GetComponent <EnvironmentObject>(); break; case EnvironmentType.Statue: tempObj = GameObject.Instantiate(statue).GetComponent <EnvironmentObject>(); break; //case Attacks.AtkDefElement.Scissors: // tempEnemy = GameObject.Instantiate(scissors).GetComponent<RPSEnemy>(); // break; } } tempObj.gameObject.transform.position = startpos; tempObj.gameObject.transform.parent = EnvironmentParent.transform; tempObj.gameObject.SetActive(true); return(tempObj); }
public void SecondCaseTest() { var container = TestConfiguration.GetContainer(); var subjectRepository = container.Resolve <ISubjectRepository>(); var resourceRepository = container.Resolve <IResourceRepository>(); var service = container.Resolve <PrivacyService>(); var user = JObject.Parse(@" {'name': 'Alice'} "); var environment = JObject.Parse("{}"); var builder = Builders <BsonDocument> .Filter; var filter = builder.Eq("headers.From", "*****@*****.**"); var resource = resourceRepository.GetCollectionDataWithCustomFilter(collectionName, filter); var action = "read"; var subject = new Subject(user); var data = new Resource(resource, collectionName); var env = new EnvironmentObject(environment); var stopwatch = new Stopwatch(); stopwatch.Start(); var result = service.ExecuteProcess(subject, data, action, env); stopwatch.Stop(); File.WriteAllText(@"C:\Users\ttqnguyet\Downloads\test.txt", stopwatch.ElapsedMilliseconds.ToString() + " " + result.JsonObjects.Count + result.JsonObjects.ElementAt(0).ToString()); }
void SpawnEnvironmentObject() { EnvironmentObject newEnvironmentObject = Instantiate(newEnvironmentObjectsRef[Random.Range(0, newEnvironmentObjectsRef.Count)], environmentContainer); newEnvironmentObject.SetPosition(new Vector3(Random.Range(0, maxBounds.x), Random.Range(0, maxBounds.y), Random.Range(0, maxBounds.z))); currentObjects.Add(newEnvironmentObject); }
IntGrid2Z?FindStartLocation(EnvironmentObject env) { const int size = 2; var center = env.StartLocation; foreach (var p in IntVector2.SquareSpiral(center.ToIntVector2(), env.Width / 2)) { if (env.Size.Plane.Contains(p) == false) { continue; } var z = env.GetSurfaceLevel(p); var r = new IntGrid2Z(p.X - size, p.Y - size, size * 2, size * 2, z); if (TestStartArea(env, r)) { return(r); } } return(null); }
public virtual void OnShow(EnvironmentObject id) { if (id == EnvironmentObject.None) { SetAllItemActive(false); #if COMMAND uicontroller.exmanager.el.envmanager.UpdateScene(); #endif } else { if (items.ContainsKey(id)) { SetAllItemActiveExceptOtherWise(id, false); #if COMMAND uicontroller.exmanager.el.envmanager.UpdateScene(); #endif } else { #if COMMAND var go = LoadItem(id); uicontroller.exmanager.el.envmanager.UpdateScene(); uicontroller.exmanager.el.envmanager.SetParams(uicontroller.exmanager.el.ex.EnvParam, go.name); uicontroller.exmanager.InheritEnv(go.name); NetworkServer.Spawn(go); uicontroller.exmanager.el.envmanager.ForcePushParams(); #endif } } Show = id; #if COMMAND uicontroller.envpanel.UpdateEnv(uicontroller.exmanager.el.envmanager); #endif }
private EnvironmentObject GetTree() { const int treeHeigth = 4; var tree = new EnvironmentObject(); for (int i = 0; i < treeHeigth; i++) { var anchor = new Vector3(0, i, 0); tree.Parts.Add((anchor, Oak)); } var crownSize = 2; for (int i = -crownSize; i < crownSize; i++) { for (int j = -crownSize; j < crownSize; j++) { for (int k = -crownSize; k < crownSize; k++) { if (i * i + j * j + k * k <= crownSize) { var anchor = new Vector3(i, treeHeigth + j, k); tree.Parts.Add((anchor, OakLeaves)); } } } } return(tree); }
public void InitializeWorld(World world) { CreateTerrain(); IntPoint3? stairs = null; foreach (var p2 in m_terrainData.Size.Plane.Range()) { var z = m_terrainData.GetHeight(p2); var p = new IntPoint3(p2, z); var td = m_terrainData.GetTileData(p); if (td.TerrainID == TerrainID.StairsDown) { stairs = p; break; } } if (stairs.HasValue == false) throw new Exception(); m_env = EnvironmentObject.Create(world, m_terrainData, VisibilityMode.LivingLOS, stairs.Value); CreateMonsters(); CreateDebugMonsterAtEntry(); }
//创建环境 readUnity为真时读取当前Unity中数值 public void CreateEnviornment(bool readUnity) { GameObject envObj = new GameObject("EnvObject" + envObjects.Length); EnvironmentObject env = envObj.AddComponent <EnvironmentObject>(); envObj.transform.parent = this.transform; GameObject lightObj = new GameObject("SceneDirLight" + envObjects.Length); lightObj.transform.parent = envObj.transform; Light scenelight = lightObj.AddComponent <Light>(); scenelight.shadows = LightShadows.Soft; scenelight.transform.eulerAngles = new Vector3(130, 33, 10); scenelight.type = LightType.Directional; env.data.sceneSunLight = scenelight; envObj.SetActive(false); if (readUnity) { UnityToEnvironmentObject(env); } if (curEnv == null) { curEnv = env; } UpdateActiveEnviornment(); }
public void SetContext(EnvironmentObject env, IntGrid2Z area) { this.Environment = env; this.Area = area; areaTextBox.Text = String.Format("{0},{1} {2}x{3}", area.X, area.Y, area.Columns, area.Rows); }
public void addObject(EnvironmentObject o) { if (!(alreadyContains(o))) { objects.Add(o); } }
private static void CreateColliders(Level level, LevelBuildData buildData) { //This contains the bounds of the level. Projectiles can pass these colliders, but entities cannot. EnvironmentObject edgeEnvironment = CreateEnvironment("Edges"); edgeEnvironment.GameObject.layer = LayerMask.NameToLayer("EnvironmentNoBlock"); foreach (List <Vector2> list in LevelBuilderUtility.CreateCollisionEdges(level, buildData.Tiles.Where(x => x.Value.IsWalkable))) { AddEdgeCollider(edgeEnvironment, list); } level.AddEnvironment(edgeEnvironment.GameObject); //This contains tiles that have walls. No entities can pass through these EnvironmentObject wallEnvironments = CreateEnvironment("Walls"); wallEnvironments.GameObject.layer = LayerMask.NameToLayer("Environment"); foreach (List <Vector2> list in LevelBuilderUtility.CreateCollisionEdges(level, buildData.Tiles.Where(x => !x.Value.IsWalkable))) { AddEdgeCollider(wallEnvironments, list); } level.AddEnvironment(wallEnvironments.GameObject); void AddEdgeCollider(EnvironmentObject environment, List <Vector2> list) { EdgeCollider2D edgeCollider = environment.GameObject.AddComponent <EdgeCollider2D>(); edgeCollider.points = list.ToArray(); } }
public void InitializeWorld(World world, IntSize3 size) { CreateTerrain(size); IntVector3?stairs = null; foreach (var p2 in m_terrainData.Size.Plane.Range()) { var p = new IntVector3(p2, m_terrainData.Size.Depth - 1); var td = m_terrainData.GetTileData(p.Down); if (td.ID == TileID.Stairs) { stairs = p; break; } } if (stairs.HasValue == false) { throw new Exception(); } m_env = EnvironmentObject.Create(world, m_terrainData, VisibilityMode.LivingLOS, stairs.Value); CreateMonsters(); CreateDebugMonsterAtEntry(); }
private static void CreateShadowCasters(Level level, LevelBuildData buildData) { EnvironmentObject environment = CreateEnvironment("Shadow Caster", EnvironmentObjectComponent.MeshFilter | EnvironmentObjectComponent.MeshRenderer); LevelEnvironmentData data = new LevelEnvironmentData(); data.Triangles.Add(0, new List <int>()); foreach (var pair in buildData.Tiles) { if (!pair.Value.CastsShadows) { continue; } Vector2 worldPosition = Utility.AxialToWorldPosition(pair.Key); byte bitmask = Utility.GetBitmask(pair.Key, level.TilePositions); List <Line> lines = pair.Value.Brush.GetCollisionCoordinates(bitmask); foreach (Line line in lines) { AddLineToMeshData(data, line, worldPosition); } } Mesh mesh = data.BuildMesh("Shadow Caster Mesh"); environment.Filter.mesh = mesh; environment.Renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.ShadowsOnly; environment.Renderer.material = new Material(Shader.Find("Standard")); level.AddEnvironment(environment.GameObject); }
private string ChangeEnvObjToString(EnvironmentObject envObj) { try { switch (envObj.Type) { case EnvironmentObjectType.Sun: return(((Sun)envObj).ToString()); case EnvironmentObjectType.Satellite: return(((Satellite)envObj).ToString()); case EnvironmentObjectType.ParticleEmitter: return(((ParticleEmitter)envObj).ToString()); case EnvironmentObjectType.EnvironmentSprite: return(((EnvironmentSprite)envObj).ToString()); default: return(defaultTextBoxMessage); } } catch { if (!calledErrorAlready) { ErrorMessage("There was an issue during the creation process! Make sure all your values are formatted correctly."); } calledErrorAlready = true; return(defaultTextBoxMessage); } }
public void CreateObject(EnvironmentType envtype, Vector3 startPos) { EnvironmentObject e = Factory.Instance.InitializeObject(envtype, startPos); Vector3 tempCoord = e.transform.position - terr.gameObject.transform.position; Vector3 terrainCoord; terrainCoord.x = tempCoord.x / terr.terrainData.size.x; terrainCoord.y = tempCoord.y / terr.terrainData.size.y; terrainCoord.z = tempCoord.z / terr.terrainData.size.z; e.Initialize(); enemyList.Add(e); int X = (int)(terrainCoord.x * terr.terrainData.heightmapWidth); int Y = (int)(terrainCoord.z * terr.terrainData.heightmapHeight); if (X < 0 || Y < 0 || X > terr.terrainData.heightmapWidth - 2 || Y > terr.terrainData.heightmapHeight - 2) { BugFinished(e); } else { float height = terr.terrainData.GetHeights(X, Y, 1, 1)[0, 0]; Vector3 newHeightPos = e.transform.position; newHeightPos.y = height * terr.terrainData.size.y; e.transform.position = newHeightPos; } }
public void PoolObject(EnvironmentType elemtype, EnvironmentObject envObject) { if (!EnvObjPool.ContainsKey(elemtype)) { EnvObjPool.Add(elemtype, new Queue <EnvironmentObject>()); } EnvObjPool[elemtype].Enqueue(envObject); }
protected override void Insert(EnvironmentObject obj) { if (obj == null) { throw new ArgumentNullException("Object cannot be null."); } base.Insert(obj); }
static ItemObject CreateItem(EnvironmentObject env, ItemID itemID, MaterialID materialID, IntVector3 p) { var builder = new ItemObjectBuilder(itemID, materialID); var item = builder.Create(env.World); item.MoveToMustSucceed(env, p); return(item); }
public void InitializeWorld(IntSize3 size) { CreateTerrain(size); var p = new IntVector2(m_terrainData.Width / 2, m_terrainData.Height / 2); var start = m_terrainData.GetSurfaceLocation(p); m_env = EnvironmentObject.Create(m_world, m_terrainData, VisibilityMode.AllVisible, start); }
//选择环境,forceToUnity为真时将数值设置入Unity中 public void ChooseEnviornment(EnvironmentObject env, bool forceToUnity) { if (forceToUnity || curEnv != env) { curEnv = env; EnvironmentObjectToUnity(env); } UpdateActiveEnviornment(); }
public void moveObjectToAbsoluteLocation(EnvironmentObject eo, XYLocation loc) { // Ensure the object is not already at a location envState.moveObjectToAbsoluteLocation(eo, loc); // Ensure is added to the environment addEnvironmentObject(eo); }
private AccessControlEffect CollectionAccessControlProcess( Subject subject, Resource resource, string action, EnvironmentObject environment, ref List <AccessControlPolicy> permitPolicies, ref List <AccessControlPolicy> denyPolicies) { AccessControlEffect result = AccessControlEffect.Deny; ICollection <AccessControlPolicy> collectionPolicies = _accessControlPolicyRepository.Get(resource.Name, action, false); string policyCombining = _policyCombiningRepository.GetRuleCombining(collectionPolicies); var targetPolicies = new List <AccessControlPolicy>(); foreach (var policy in collectionPolicies) { bool isTarget = _expressionService.Evaluate(policy.Target, subject.Data, null, environment.Data); if (isTarget) { targetPolicies.Add(policy); } } foreach (var policy in targetPolicies) { string policyEffect = String.Empty; foreach (var rule in policy.Rules) { bool isApplied = _expressionService.Evaluate(rule.Condition, subject.Data, null, environment.Data); if (isApplied && rule.Effect.Equals("Permit") && policy.RuleCombining.Equals(AlgorithmCombining.PERMIT_OVERRIDES)) { policyEffect = "Permit"; break; } if (isApplied && rule.Effect.Equals("Deny") && policy.RuleCombining.Equals(AlgorithmCombining.DENY_OVERRIDES)) { policyEffect = "Deny"; break; } } if (policyEffect.Equals("Permit") && policyCombining.Equals(AlgorithmCombining.PERMIT_OVERRIDES)) { result = AccessControlEffect.Permit; break; } else if (policyEffect.Equals("Deny") && policyCombining.Equals(AlgorithmCombining.DENY_OVERRIDES)) { result = AccessControlEffect.Deny; break; } // add retaive policy here } return(result); }
public ChunkBuilder(EnvironmentObject tree, EnvironmentObject building, EnvironmentObject bigBuilding, EnvironmentObject lamp, EnvironmentObject character, EnvironmentObject car) { treeFactroy = new EnvObjFactory(tree); buildingFactory = new EnvObjFactory(building); bigBuildingFactory = new EnvObjFactory(bigBuilding); lampFactory = new EnvObjFactory(lamp); characterFactory = new EnvObjFactory(character); carFactory = new EnvObjFactory(car); }
public void addObject(EnvironmentObject o, string attributeName, Object attributeValue) { if (!(alreadyContains(o))) { o.setAttribute(attributeName, attributeValue); objects.Add(o); } }
public void SetContext(EnvironmentObject env, IntVector3 location) { m_env = env; m_location = location; var items = m_env.ItemTracker.GetItemsByDistance(m_location, i => i.ItemInfo.IsInstallable && i.IsReserved == false && i.IsInstalled == false); listBox.ItemsSource = items; }
public void addEnvironmentObject(EnvironmentObject eo) { envObjects.Add(eo); if (eo is IAgent) { IAgent a = (IAgent)eo; if (!agents.Contains(a)) { agents.Add(a); this.updateEnvironmentViewsAgentAdded(a); } } }
public void moveObject(EnvironmentObject eo, XYLocation.Direction direction) { XYLocation presentLocation = envState.getCurrentLocationFor(eo); if (null != presentLocation) { XYLocation locationToMoveTo = presentLocation.locationAt(direction); if (!(isBlocked(locationToMoveTo))) { moveObjectToAbsoluteLocation(eo, locationToMoveTo); } } }
static IntVector3? GetLocNearEntry(EnvironmentObject env) { foreach (var p in IntVector2.SquareSpiral(env.StartLocation.ToIntVector2(), env.Width / 2)) { if (env.Size.Plane.Contains(p) == false) continue; var p3 = env.GetSurfaceLocation(p); if (env.CanEnter(p3)) return p3; } return null; }
static IntPoint3? GetLocNearEntry(EnvironmentObject env) { foreach (var p in IntPoint2.SquareSpiral(env.StartLocation.ToIntPoint(), env.Width / 2)) { if (env.Size.Plane.Contains(p) == false) continue; var z = env.GetDepth(p); var p3 = new IntPoint3(p, z); if (EnvironmentHelpers.CanEnter(env, p3)) return p3; } return null; }
static IntPoint3? GetRandomRoomLoc(EnvironmentObject env, ref IntGrid2Z grid) { int x = grid.X + Helpers.GetRandomInt(grid.Columns); int y = grid.Y + Helpers.GetRandomInt(grid.Rows); foreach (var p in IntPoint2.SquareSpiral(new IntPoint2(x, y), Math.Max(grid.Columns, grid.Rows))) { if (env.Size.Plane.Contains(p) == false) continue; var p3 = new IntPoint3(p, grid.Z); if (EnvironmentHelpers.CanEnter(env, p3) == false) continue; return p3; } return null; }
public FortressPlayer(int playerID, GameEngine engine, EnvironmentObject env) : base(playerID, engine) { this.EnvObserver = new EnvObserver(env); }
public void ScrollTo(EnvironmentObject env, IntPoint3 p) { this.Environment = env; this.Z = p.Z; ScrollTo(new Point(p.X, p.Y)); }
void OnEnvironmentChanged(EnvironmentObject env) { this.Selection = new MapSelection(); UpdateHoverTileInfo(false); }
public XYLocation getCurrentLocationFor(EnvironmentObject eo) { foreach (XYLocation loc in objsAtLocation.keySet()) { if (objsAtLocation.get(loc).contains(eo)) { return loc; } } return null; }
public void SetContext(EnvironmentObject env, IntGrid3 area) { this.Environment = env; this.Area = area; }
public void removeEnvironmentObject(EnvironmentObject eo) { envObjects.Remove(eo); //agents.Remove(eo); }
public void SetTarget(EnvironmentObject env, IntVector3 p) { SetTarget(env, new IntGrid3(p, new IntSize3(1, 1, 1))); }
protected virtual void Insert(EnvironmentObject obj) { this.objects.Add(obj); }
public void moveObjectToAbsoluteLocation(EnvironmentObject eo, XYLocation loc) { // Ensure is not already at another location foreach (Set<EnvironmentObject> eos in objsAtLocation.values()) { if (eos.remove(eo)) { break; // Should only every be at 1 location } } // Add it to the location specified getObjectsAt(loc).Add(eo); }
public XYLocation getCurrentLocationFor(EnvironmentObject eo) { return envState.getCurrentLocationFor(eo); }
public void addObject(EnvironmentObject o, XYLocation loc) { base.addObject(o, LOCATION, loc); }
public void SetTarget(EnvironmentObject env, IntGrid3 box) { if (env == m_environment && m_box == box) return; if (env != m_environment) { if (m_environment != null) { m_environment.MapTileTerrainChanged -= OnMapTerrainChanged; m_environment.MapTileObjectChanged -= OnMapObjectChanged; } m_environment = env; if (m_environment != null) { m_environment.MapTileTerrainChanged += OnMapTerrainChanged; m_environment.MapTileObjectChanged += OnMapObjectChanged; } Notify("Environment"); NotifyTileObjectChanges(); } if (box != m_box) { var old = m_box; m_box = box; if (m_box.IsNull || m_environment == null) m_adjustedBox = m_box; else m_adjustedBox = m_box.Intersect(new IntGrid3(m_environment.Size)); Notify("Box"); NotifyTileObjectChanges(old, m_box); } NotifyTileTerrainChanges(); Notify("IsNotEmpty"); }
void OnEnvironmentChanged(EnvironmentObject env) { if (m_env != null) ((INotifyCollectionChanged)m_env.AreaElements).CollectionChanged -= OnElementCollectionChanged; m_env = env; if (m_env != null) ((INotifyCollectionChanged)m_env.AreaElements).CollectionChanged += OnElementCollectionChanged; UpdateElements(); }
public bool alreadyContains(EnvironmentObject o) { bool retval = false; foreach (EnvironmentObject eo in objects) { if (eo.Equals(o)) { retval = true; } } return retval; }
public void SetTarget(EnvironmentObject environment, IntPoint3 location) { bool update = false; var oldEnv = m_environment; var newEnv = environment; if (oldEnv != newEnv) { if (oldEnv != null) { oldEnv.MapTileTerrainChanged -= OnMapTerrainChanged; oldEnv.MapTileObjectChanged -= OnMapObjectChanged; } m_environment = newEnv; if (newEnv != null) { newEnv.MapTileTerrainChanged += OnMapTerrainChanged; newEnv.MapTileObjectChanged += OnMapObjectChanged; } update = true; } var newLoc = location; var oldLoc = m_location; if (oldLoc != newLoc) { m_location = newLoc; update = true; } if (update) { if (newEnv != null) m_tileData = newEnv.GetTileData(newLoc); else m_tileData = TileData.UndefinedTileData; UpdateObjectList(); if (oldEnv != newEnv) Notify("Environment"); if (oldLoc != newLoc) Notify("Location"); NotifyTileTerrainChanges(); if ((oldEnv == null) != (newEnv == null)) Notify("IsEnabled"); } }
public void addObjectToLocation(EnvironmentObject eo, XYLocation loc) { moveObjectToAbsoluteLocation(eo, loc); }