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);
}
}
protected override void Insert(EnvironmentObject obj)
{
if (obj != null)
{
base.Insert(obj);
}
}
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 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 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 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);
}
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);
}
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 addObject(EnvironmentObject o, string attributeName,
Object attributeValue)
{
if (!(alreadyContains(o)))
{
o.setAttribute(attributeName, attributeValue);
objects.Add(o);
}
}
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 addObject(EnvironmentObject o)
{
if (!(alreadyContains(o)))
{
objects.Add(o);
}
}
public void addObjectToLocation(EnvironmentObject eo, XYLocation loc)
{
moveObjectToAbsoluteLocation(eo, loc);
}
