private void InitializeTerrain(TerrainType type) { terrain = TerrainFactory.GetTerrain(type, this); terrain.LoadHeightmap(Settings.Default.Heightmap); terrain.LoadTexture(Settings.Default.Texture); terrain.Bumpiness = Settings.Default.Bumpiness; terrain.FrustumCullingEnabled = Settings.Default.FrustumCullingEnabled; terrain.BruteForceEnabled = Settings.Default.BruteForceEnabled; terrain.TextureEnabled = Settings.Default.TextureEnabled; terrain.TextureResolution = Settings.Default.TextureResolution; terrain.HeightmapEnabled = Settings.Default.HeightmapEnabled; terrain.GeomorphEnabled = Settings.Default.GeomorphEnabled; terrain.LightEnabled = Settings.Default.LightEnabled; terrain.LightDiffuse = Settings.Default.LightDiffuse; terrain.LightDirection = Settings.Default.LightDirection; terrain.LightAmbient = Settings.Default.LightAmbient; terrain.LightSpecular = Settings.Default.LightSpecular; terrain.LightShininess = Settings.Default.LightShininess; terrain.Quality = Settings.Default.Quality; terrain.TerrainColor = Settings.Default.TerrainColor; terrain.BlockSize = Settings.Default.BlockSize; terrain.MinQuality = Settings.Default.MinQuality; terrain.Initialize(); }
/// <summary> /// Simple binary search /// </summary> /// <param name="start"> /// The start. /// </param> /// <param name="finish"> /// The finish. /// </param> /// <param name="ray"> /// The ray. /// </param> /// <param name="terrain"> /// The terrain. /// </param> /// <param name="intersectionFound"> /// Out parameter indicating whether any of the points /// found during search /// was in intersection range /// </param> /// <returns> /// The <see cref="Vector3"/>. /// </returns> private static Vector3 BinarySearch( float start, float finish, Ray ray, ITerrain terrain, out bool intersectionFound) { int count = 0; bool found = false; while (true) { float half = start + ((finish - start) / 2f); if (count >= SearchIterations) { intersectionFound = found; return(GetPointOnRay(ray, half)); } if (IsIntersectionInRange(start, half, ray, terrain)) { found = true; count += 1; finish = half; } else { count += 1; start = half; } } }
public EffectWater( Game game, RiemersFirstPersonCamera cam, ITerrain terrain, ReflectionMap reflex, RefractionMap refrax ) : base( game ) { mCamera = cam; mReflectionMap = reflex; mRefractionMap = refrax; mTerrain = terrain; }
public void Start(IScene scene) { m_scene = scene; m_scheduler = m_scene.Simian.GetAppModule <IScheduler>(); if (m_scheduler == null) { m_log.Error("OARLoader requires an IScheduler"); return; } m_assetClient = m_scene.Simian.GetAppModule <IAssetClient>(); if (m_assetClient == null) { m_log.Error("OARLoader requires an IAssetClient"); return; } m_primMesher = m_scene.GetSceneModule <IPrimMesher>(); m_terrain = m_scene.GetSceneModule <ITerrain>(); m_regionInfo = m_scene.GetSceneModule <RegionInfo>(); m_udp = m_scene.GetSceneModule <LLUDP>(); m_permissions = m_scene.GetSceneModule <LLPermissions>(); m_scene.AddCommandHandler("loadoar", LoadOARHandler); }
public NavigationModule(ITerrain terrain, IPosition startPosition, ICommandQueue <Command> commandQueue) { _terrain = terrain; _position = startPosition; _commandsQueue = commandQueue; }
private ITerrain GetTerrain(String terrainTypeName) { if (terrainTypeName == null) { XElement cells = GetCells(); terrainTypeName = cells.Attribute("defaultTerrain")?.Value ?? throw new Exception("Element cells must have attribute 'defaultTerrain'"); } IEnumerable <XElement> terrains = GetTerrains().Elements("terrain"); XElement terrainData = terrains.SingleOrDefault(t => t.Attribute("type")?.Value == terrainTypeName); if (terrainData == null) { throw new Exception($"Terrain {terrainTypeName} not found"); } String type = terrainData.Attribute("type")?.Value; var terrainType = (ETerrainTypes)Enum.Parse(typeof(ETerrainTypes), type, true); ITerrain terrain = CTerrainFactoryMethod.Create(terrainType); return(terrain); }
public void Start(IScene scene) { m_scene = scene; m_terrain = m_scene.GetSceneModule <ITerrain>(); if (m_terrain == null) { m_log.Error("LayerData requires an ITerrain module"); return; } m_udp = m_scene.GetSceneModule <LLUDP>(); if (m_udp != null) { m_udp.AddPacketHandler(PacketType.ModifyLand, ModifyLandHandler); m_scene.AddInterestListHandler(TERRAIN, new InterestListEventHandler { SendCallback = SendTerrainPacket }); m_scene.OnPresenceAdd += PresenceAddHandler; m_terrain.OnHeightmapChanged += HeightmapChangedHandler; m_terrain.OnHeightmapAreaChanged += HeightmapAreaChangedHandler; } }
private void CellTerrainChanged(Cell cell, ITerrain terrain) { if (CellIsInChunk(cell)) { _redraw = true; } }
private static ILevelObject getTree(XmlNode levelObjectNode, ITerrain terrain, Vector3 scale, Vector3 rotation) { float[] pos = TgcParserUtils.parseFloat2Array(levelObjectNode.InnerText); return new Tree(terrain.getPosition(pos[0], pos[1]), scale, rotation); }
/// <summary> /// Creates a new command for modifying a rectangular area of the texture-map in a <see cref="ITerrain"/>. /// </summary> /// <param name="terrain">The <see cref="ITerrain"/> to modify.</param> /// <param name="offset">The top-left coordinates of the area to modify.</param> /// <param name="oldPartialData">The texture-map data of the area before it was modified. Do not modify this array after calling this method!</param> /// <param name="newPartialData">The texture-map data of the area after it was modified. Do not modify this array after calling this method!</param> /// <param name="refreshHandler">Called when the <see cref="OmegaEngine.Graphics.Renderables.Terrain"/> needs to be reset.</param> public ModifyTextureMap(ITerrain terrain, Point offset, byte[,] oldPartialData, byte[,] newPartialData, Action refreshHandler) { #region Sanity checks if (terrain == null) { throw new ArgumentNullException(nameof(terrain)); } if (oldPartialData == null) { throw new ArgumentNullException(nameof(oldPartialData)); } if (newPartialData == null) { throw new ArgumentNullException(nameof(newPartialData)); } if (refreshHandler == null) { throw new ArgumentNullException(nameof(refreshHandler)); } if (oldPartialData.GetLength(0) != newPartialData.GetLength(0) || oldPartialData.GetLength(1) != newPartialData.GetLength(1)) { throw new ArgumentException(Resources.PartialDataArrayDimensionsNotEqual, nameof(newPartialData)); } #endregion _terrain = terrain; _start = offset; _oldPartialData = oldPartialData; _newPartialData = newPartialData; _refreshHandler = refreshHandler; }
public static bool CanStandOn(Vector3Int tile) { List <RaycastHit2D> hits = RaycastTile(tile); foreach (var hit in hits) { if (hit) { ITerrain terrain = hit.transform.parent.GetComponent <ITerrain>(); if (terrain != null) { return(false); } } } if (groundTilemap.HasTile(tile)) { return(true); } else { return(false); } }
public void OnCreated(ITerrain terrain) { this.terrain = terrain; GameObject terrainLoader = new GameObject("TerrainLoader"); terrainLoader.AddComponent <TerrainLoader>().terrain = terrain; }
private void ChangeTerrain(TerrainType type) { ITerrain previousTerrain = terrain; terrain = TerrainFactory.GetTerrain(type, this); terrain.Heightmap = previousTerrain.Heightmap; terrain.Texture = previousTerrain.Texture; terrain.Bumpiness = previousTerrain.Bumpiness; terrain.FrustumCullingEnabled = previousTerrain.FrustumCullingEnabled; terrain.BruteForceEnabled = previousTerrain.BruteForceEnabled; terrain.TextureEnabled = previousTerrain.TextureEnabled; terrain.TextureResolution = previousTerrain.TextureResolution; terrain.HeightmapEnabled = previousTerrain.HeightmapEnabled; terrain.GeomorphEnabled = previousTerrain.GeomorphEnabled; terrain.LightEnabled = previousTerrain.LightEnabled; terrain.LightDiffuse = previousTerrain.LightDiffuse; terrain.LightDirection = previousTerrain.LightDirection; terrain.LightAmbient = previousTerrain.LightAmbient; terrain.LightSpecular = previousTerrain.LightSpecular; terrain.LightShininess = previousTerrain.LightShininess; terrain.Quality = previousTerrain.Quality; terrain.TerrainColor = previousTerrain.TerrainColor; terrain.BlockSize = previousTerrain.BlockSize; terrain.MinQuality = previousTerrain.MinQuality; terrain.Initialize(); }
/// <summary> /// Busca la interseccion rayo-heightmap, y devuelve true si existe. /// </summary> public bool terrainIntersection(ITerrain terrain, out Vector3 position) { bool result; if (this.Ray.Direction.Y == 0) { //parche para evitar un ciclo infinito position = Vector3.Empty; return false; } if (this.Ray.Direction.Y >= 0) //hizo click en un sector del terreno mas alto que la camara result = this.skyToGroundAlgorithm(terrain, out position); else //hizo click en un sector del terreno mas bajo que la camara result = this.groundToSkyAlgorithm(terrain, out position); try { GuiController.Instance.UserVars.setValue("WorldX", position.X); } catch (Exception) { createVars(); GuiController.Instance.UserVars.setValue("WorldX", position.X); } GuiController.Instance.UserVars.setValue("WorldY", position.Y); GuiController.Instance.UserVars.setValue("WorldZ", position.Z); return result; }
public TextureTrees( Game game, Camera cam, ITerrain terrain ) : base( game ) { mCamera = cam; mTerrain = terrain; Visible = false; }
public PlutoRover(ITerrain terrain, Point start, OrientationEnum orientation) { Start = start; Terrain = terrain; CurrentLocation = new Location(start.X, start.Y, orientation); }
public Vector3[] GenerateWaypoints(ITerrain terrain, Vector3 lastPos, float radius) { var area = radius * radius; var count = (int)(Math.Min(1.0f, area) / 5) * 2; count = Math.Max(3, count); return GenerateWaypoints(terrain, lastPos, radius, count); }
public void Initialize(int x, int z, ITerrain terrain) { neighbours = new HexCell[6]; this.x = x; this.z = z; this.terrain = terrain; }
private void listView1_ItemChecked(object sender, ItemCheckedEventArgs e) { myListNode item = (myListNode)e.Item; if (e.Item.Checked) { switch (item.type) { case TreeNodeType.NT_TERRAINLAYER: ITerrain ted = item.obj as ITerrain; ted.VisibleMask = gviViewportMask.gviViewAllNormalView; break; case TreeNodeType.NT_IMAGELAYER: IImageryLayer img = item.obj as IImageryLayer; img.VisibleMask = gviViewportMask.gviViewAllNormalView; break; } } else { switch (item.type) { case TreeNodeType.NT_TERRAINLAYER: ITerrain ted = item.obj as ITerrain; ted.VisibleMask = gviViewportMask.gviViewNone; break; case TreeNodeType.NT_IMAGELAYER: IImageryLayer img = item.obj as IImageryLayer; img.VisibleMask = gviViewportMask.gviViewNone; break; } } }
public void GetTerrainForHeight_Returns_Lowland_When_Height_Is_From_145_To_170(byte height) { var terrainHelper = new TerrainHelper(); ITerrain terrain = terrainHelper.GetTerrainForHeight(height); Assert.IsInstanceOf <Lowland>(terrain); }
public TextureTrees(Game game, Camera cam, ITerrain terrain) : base(game) { mCamera = cam; mTerrain = terrain; Visible = false; }
private bool skyToGroundAlgorithm(ITerrain terrain, out Vector3 position) { Vector3 aPoint; Vector3 terrainPoint; float t = 0; while (true) { aPoint = this.Ray.Origin + t * this.Ray.Direction; if (terrain.getPosition(aPoint.X, aPoint.Z, out terrainPoint)) { if (GeneralMethods.isCloseTo(aPoint.Y, terrainPoint.Y, 1)) { //encontramos el punto de interseccion position = aPoint; return true; } } else if (aPoint.Y >= terrain.maxY || aPoint.Y < terrain.minY) { //ya nos fuimos o muy arriba o muy abajo position = Vector3.Empty; return false; } t++; } }
public Tile(ITerrain terrain, IGameObject actor, IGameItem item, IObject gameObj) { this.Terrain = terrain; this.Actor = actor; this.Item = item; this.GameObject = gameObj; }
public Vector3[] GenerateWaypoints(ITerrain terrain, Vector3 lastPos, float radius) { var area = radius * radius; var count = (int)(Math.Min(1.0f, area) / 5) * 2; count = Math.Max(3, count); return(GenerateWaypoints(terrain, lastPos, radius, count)); }
private static ILevelObject getWall(XmlNode levelObjectNode, ITerrain terrain) { float[] pos = TgcParserUtils.parseFloat2Array(levelObjectNode.InnerText); Vector3 size = TgcParserUtils.float3ArrayToVector3(TgcParserUtils.parseFloat3Array(levelObjectNode.Attributes.GetNamedItem("size").InnerText)); return new Wall(terrain.getPosition(pos[0], pos[1]), size); }
public void SetUp() { _mockTerrain = MockRepository.GenerateMock <ITerrain>(); _mockPosition = MockRepository.GenerateMock <IPosition>(); _mockCommandQueue = MockRepository.GenerateMock <ICommandQueue <Command> >(); _sut = new NavigationModule(_mockTerrain, _mockPosition, _mockCommandQueue); }
/* RegularGrid * Optimiza el renderizado dibujando solo los sectores del terreno que colisionan * con el frustum de la camara. * Si hablamos de los objetos, cada uno esta relacionado a un sector, de manera * que si un sector no se renderiza, sus objetos tampoco. * Por el lado de los personajes, se busca la colision punto-frustum de su posicion * para determinar si se renderiza o no. * * Resultados en mi pc 27/05/2013: * Sin optimizacion - 750fps * RegularGrid (grilla 3x3, viendo todo el mapa) - entre 700 y 750fps * RegularGrid (grilla 3x3, viendo de a 2 o 3 sectores) - entre 850 y 1000fps */ #region Constructor public RegularGrid(ITerrain terrain) : base() { sectors = new List<GridCell>(); foreach(TerrainPatch tp in terrain.Patches) sectors.Add(new GridCell(tp)); }
public EffectWater(Game game, RiemersFirstPersonCamera cam, ITerrain terrain, ReflectionMap reflex, RefractionMap refrax) : base(game) { mCamera = cam; mReflectionMap = reflex; mRefractionMap = refrax; mTerrain = terrain; }
public Battlefield(ITerrain terrain) { Terrain = terrain; AllTanks = new ObservableCollection<TankBase>(); AllTanks.ItemAdded += TankAdded; AllTanks.ItemRemoved += TankRemoved; }
public StructuralFactorCalculator( IStructure building, ITerrain terrain, IWindLoadData windLoadData, StructuralType structuralType) { _building = building; _terrain = terrain; _windLoadData = windLoadData; _structuralType = structuralType; }
public BoxSelection(ITerrain _terrain, List<Character> _selectableCharacters) { this.selectableCharacters = _selectableCharacters; this.terrain = _terrain; this.selectionBox = TgcBox.fromSize(new Vector3(3, SELECTION_BOX_HEIGHT, 3), Color.Red); this.selectionBox.AlphaBlendEnable = true; this.selectionBox.Color = Color.FromArgb(110, Color.CadetBlue); }
private static void ClearPlantBlocking(this ITerrain terrain, int x, int y) { terrain.Blocks.UpdateValue(x, y, bi => { bi.Height = 0; bi.Plant = false; return(bi); }); }
private void SetActiveTerrain() { if (Terrain != null) { Terrain.Visible = Terrain.Active = false; } Terrain = cubicTerrain ? TerrainCube : TerrainTile; Terrain.Visible = Terrain.Active = true; }
private void Start() { var camPos = Camera.main.transform.position; _terrain = new VoxelTerrain(new MeshChunkFactory(material), new Volume(terrainSize, 1, terrainSize), new Volume(chunkSize, chunkHeight, chunkSize), numberOfGenerators, new Vector3F(camPos.x, camPos.y, camPos.z)); }
/// <summary> /// Initializes a new instance of the <see cref="Tile" /> class. /// </summary> /// <param name="terrain">Terrain object.</param> /// <param name="fringe">List of Fringe objects.</param> /// <param name="itemList">to be implemented...</param> /// <param name="actor">Actor object.</param> public Tile(ITerrain terrain, List <IFringe> fringe, int itemList, IActor actor) { this.Terrain = terrain; this.FringeList = fringe; this.Actor = actor; // Set flags to cumulative from other flags (see Flags) this.Flags = Flags.None; }
public bool Equals(ITerrain other) { if (other == null) { return(false); } return(Name.Equals(other.Name)); }
public static Vector3[] GenerateWaypoints(MapId map, Vector3 lastPos) { ITerrain terrain = TerrainMgr.GetTerrain(map); if (terrain != null) { return(new RandomWaypointGenerator().GenerateWaypoints(terrain, lastPos)); } return(new Vector3[0]); }
void IMapMethod.Invoke(ref MapCell cell) { cell.NewTemperature = (byte)_terrainOptions.AmbientTemperature; ITerrain terrain = _terrainManager[3]; // Magically know this is soil! cell.NewTerrainId = 0; cell.NewMoisture = 0; cell.TerrainCost = (short)terrain[_terrainOptions.AmbientTemperature].PathingCost; }
public void Start(IScene scene) { m_httpServer = scene.Simian.GetAppModule<IHttpServer>(); m_assetClient = scene.Simian.GetAppModule<IAssetClient>(); m_terrain = scene.GetSceneModule<ITerrain>(); m_primMesher = scene.GetSceneModule<IPrimMesher>(); m_lslScriptEngine = scene.GetSceneModule<ILSLScriptEngine>(); m_messaging = scene.GetSceneModule<Messaging>(); m_sounds = scene.GetSceneModule<Sounds>(); }
public void Start(IScene scene) { m_assetClient = scene.Simian.GetAppModule<IAssetClient>(); m_terrain = scene.GetSceneModule<ITerrain>(); m_primMesher = scene.GetSceneModule<IPrimMesher>(); m_lslScriptEngine = scene.GetSceneModule<ILSLScriptEngine>(); int implemented = CountMethods(); m_log.Debug("Initializing LSL API with " + implemented + "/" + m_methods.Count + " implemented methods"); }
public void Dispatch(IUnit unit, ITerrain terrain) { Type unitType = unit.GetType(); Type terrainType = terrain.GetType(); // go through the list and find the action that corresponds to the // most-derived IUnit and ITerrain types that are in the ancestor // chain for unitType and terrainType. Action <IUnit, ITerrain> action = /* left as exercise for reader ;) */ action(unit, terrain); }
public void Start(IScene scene) { m_httpServer = scene.Simian.GetAppModule <IHttpServer>(); m_assetClient = scene.Simian.GetAppModule <IAssetClient>(); m_terrain = scene.GetSceneModule <ITerrain>(); m_primMesher = scene.GetSceneModule <IPrimMesher>(); m_lslScriptEngine = scene.GetSceneModule <ILSLScriptEngine>(); m_messaging = scene.GetSceneModule <Messaging>(); m_sounds = scene.GetSceneModule <Sounds>(); }
public void Equals_ReturnsFalse_BecauseTheTerrainsAreNotEqual(ITerrain first, ITerrain second) { // :::: ARRANGE :::: var comparer = new TerrainEqualityComparer(); // :::: ACT :::: var actualEquality = comparer.Equals(first, second); // :::: ASSERT :::: actualEquality.Should().BeFalse(); }
public Selection(List<Character> _selectableCharacters, ITerrain _terrain) { this.selectableCharacters = _selectableCharacters; this.selectedCharacters = new List<Character>(); this.selecting = false; this.selectionMethods = new List<SelectionMethod>(); this.selectionMethods.Add(new ScreenProjection(this.selectableCharacters)); this.selectionMethods.Add(new BoxSelection(_terrain, this.selectableCharacters)); GuiController.Instance.Modifiers.addInterval("Seleccion", this.selectionMethods.ToArray(), 0); }
public Planet(DoubleVector3 location, double radius, ITerrain terrain, IPlanetRenderer renderer, IHeightfieldGenerator generator, ISettings settings, Statistics statistics) { _location = location; _radius = radius; _terrain = terrain; _renderer = renderer; _generator = generator; _settings = settings; _statistics = statistics; }
public Planet(DoubleVector3 location, double radius, ITerrain terrain, IPlanetRenderer renderer, IHeightfieldGenerator generator, Statistics statistics) { _location = location; _radius = radius; _terrain = terrain; _renderer = renderer; _generator = generator; _statistics = statistics; _clippingPlanes = new ClippingPlanes(); }
private static Commando getDefault(XmlNode commandoNode, ITerrain terrain) { float[] pos = TgcViewer.Utils.TgcSceneLoader.TgcParserUtils.parseFloat2Array(commandoNode.InnerText); Commando commando = new Commando(terrain.getPosition(pos[0], pos[1])); XmlNode pic = commandoNode.Attributes.GetNamedItem("picture"); if (pic != null) { commando.Picture = new CharacterPicture(CommandosUI.Instance.MediaDir + pic.InnerText); } return commando; }
public void GetHashCode_ReturnsTheSameHashCodeForBothTerrains_BecauseTheTerrainsAreEqual(ITerrain first, ITerrain second) { // :::: ARRANGE :::: var comparer = new TerrainEqualityComparer(); // :::: ACT :::: var firstHashCode = comparer.GetHashCode(first); var secondHashCode = comparer.GetHashCode(second); // :::: ASSERT :::: firstHashCode.Should().Be(secondHashCode); }
public PCamera(Vector3 _center, ITerrain _terrain) { this.terrain = _terrain; this.setCenter(this.terrain.getPosition(_center.X, _center.Z)); this.ctpv = Vector3.Normalize(new Vector3(0, 2, 1)); this.distance = (DISTANCE_MAX - DISTANCE_MIN) / 2; this.updateViewMatrix(); GuiController.Instance.CurrentCamera = this; }
public void MoveTo_IsForwarded_BecauseTheTerrainIsImpassable(ITerrain terrain) { // :::: ARRANGE :::: var spyUnit = A.Fake<IUnit<Archer>>(); var stubTerrains = StubWorld.Terrains(new[] { terrain }); var unit = new NoEntranceToImpassableTerrain<Archer>(spyUnit, stubTerrains); // :::: ACT :::: var destination = terrain.Location; unit.MoveTo(destination); // :::: ASSERT :::: A.CallTo(() => spyUnit.MoveTo(destination)).MustNotHaveHappened(); }
public Vector3[] GenerateWaypoints(ITerrain terrain, Vector3 lastPos, int min, int max, float minDist, float maxDist) { if (min < 1) { throw new ArgumentException(@"The minimum point count must be greater than 1", "min"); } if (max < min) { throw new ArgumentException(@"The maximum point count must be greater than the minimum", "max"); } var count = Utility.Random(min, max); return GenerateWaypoints(terrain, lastPos, minDist, maxDist, count); }
public void TerrainAt_ReturnsTheTerrainOnTheTile(ITerrain terrain, string expectedTerrainType) { // :::: ARRANGE :::: var stubTerrainLayer = StubWorld.TerrainLayer(new[] { terrain }); var game = new ExtenCivGame(DummyCityLayer, stubTerrainLayer, DummyUnitLayer, DummyTurnTaking, DummyWorldAge, DummyWinnerStrategy, DummyProjects); // :::: ACT :::: var location = terrain.Location; var actualTerrainViewModel = game.TerrainAt(location); // :::: ASSERT :::: actualTerrainViewModel.Type.Should().Be(expectedTerrainType); }
private static Enemy getSoldier(XmlNode enemyNode, ITerrain terrain) { List<Vector3> waitpoints = new List<Vector3>(); foreach (XmlNode wn in enemyNode.ChildNodes) { if (wn.NodeType == XmlNodeType.Element) { float[] pos = TgcParserUtils.parseFloat2Array(wn.InnerText); waitpoints.Add(terrain.getPosition(pos[0], pos[1])); } } return new Soldier(waitpoints.ToArray<Vector3>()); }
public Vector3[] GenerateWaypoints(ITerrain terrain, Vector3 centrePos, float radius, int count) { var wps = new Vector3[count]; for (var i = 0; i < count; i++) { var angle = Utility.RandomFloat() * MathUtil.TwoPI; var dist = (float)Math.Sqrt(Utility.Random(0, radius)); var newPos = new Vector3(); newPos.X = centrePos.X + ((radius * dist) * (float)Math.Cos(angle)); newPos.Y = centrePos.Y + ((radius * dist) * (float)Math.Sin(angle)); newPos.Z = centrePos.Z; //consider flying units newPos.Z = terrain.GetGroundHeightUnderneath(newPos); wps[i] = newPos; } return wps; }
public static Commando getCommando(XmlNode commandoNode, ITerrain terrain) { string commandoClass; commandoClass = getClass(commandoNode); switch (commandoClass) { case "commando": return XMLCommando.getDefault(commandoNode, terrain); } return null; }
public static Enemy getEnemy(XmlNode enemyNode, ITerrain terrain) { string enemyClass; enemyClass = getClass(enemyNode); switch (enemyClass) { case "soldier": return XMLEnemy.getSoldier(enemyNode, terrain); } return null; }
/// <summary> /// Explores Martian terrain, might be salvaged by a potato farmer in the future. /// </summary> /// <param name="name">Name of the rover.</param> /// <param name="position">Starting position of the rover</param> /// <param name="orientation">Starting orientation of the rover</param> /// <param name="comModule">Communication module used by the rover.</param> /// <param name="terrain">Martian terrain the rover is stationed on</param> public Rover(string name, IPosition position, OrientationEnum orientation, IComModule comModule, ITerrain terrain) { ComModule = comModule; Terrain = terrain; ComModule.Rover = this; Name = name; Position = position; Orientation = orientation; if (Terrain.IsEmpty(Position.X, Position.Y)) { Terrain.Grid[Position.X, Position.Y] = this; } else { //There is an obstacle at the coordinates rover was meant to be placed throw new ObstacleInTheWayException(Terrain.Grid[Position.X, Position.Y]); } }
public Vector3[] GenerateWaypoints(ITerrain terrain, Vector3 lastPos, int min, int max, float minDist, float maxDist) { if (min < 1 || max < min || maxDist < minDist) { throw new ArgumentException("Invalid arguments"); } var count = Utility.Random(min, max); var wps = new Vector3[count]; for (var i = 0; i < count; i++) { var direction = Utility.Random(0, MathUtil.TwoPI); var dist = Utility.Random(minDist, maxDist); lastPos.GetPointYX(direction, dist, out lastPos); lastPos.Z = terrain.QueryWorldHeight(lastPos); wps[i] = lastPos; } return wps; }
public static Vector3[] GenerateWaypoints(ITerrain terrain, Vector3 lastPos, float minDist, float maxDist, int count) { if (maxDist < minDist) { throw new ArgumentException(@"The maximum waypoint distance must be greater than the minimum", "maxDist"); } var wps = new Vector3[count]; for (var i = 0; i < count; i++) { var direction = Utility.Random(0, MathUtil.TwoPI); var dist = Utility.Random(minDist, maxDist); var z = lastPos.Z; lastPos.GetPointYX(direction, dist, out lastPos); lastPos.Z = z; //consider flying units lastPos.Z = terrain.GetGroundHeightUnderneath(lastPos); wps[i] = lastPos; } return wps; }