示例#1
0
        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();
        }
示例#2
0
        /// <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;
                }
            }
        }
示例#3
0
		public EffectWater( Game game, RiemersFirstPersonCamera cam, ITerrain terrain, ReflectionMap reflex, RefractionMap refrax )
			: base( game ) {
			mCamera = cam;
			mReflectionMap = reflex;
			mRefractionMap = refrax;
			mTerrain = terrain;
		}
示例#4
0
        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);
        }
示例#5
0
        public NavigationModule(ITerrain terrain, IPosition startPosition, ICommandQueue <Command> commandQueue)
        {
            _terrain  = terrain;
            _position = startPosition;

            _commandsQueue = commandQueue;
        }
示例#6
0
        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);
        }
示例#7
0
        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;
        }
示例#11
0
    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);
        }
    }
示例#12
0
        public void OnCreated(ITerrain terrain)
        {
            this.terrain = terrain;
            GameObject terrainLoader = new GameObject("TerrainLoader");

            terrainLoader.AddComponent <TerrainLoader>().terrain = terrain;
        }
示例#13
0
        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;
        }
示例#15
0
		public TextureTrees( Game game, Camera cam, ITerrain terrain )
			: base( game ) {
			mCamera = cam;
			mTerrain = terrain;
			Visible = false;

		}
示例#16
0
        public PlutoRover(ITerrain terrain, Point start, OrientationEnum orientation)
        {
            Start   = start;
            Terrain = terrain;

            CurrentLocation = new Location(start.X, start.Y, orientation);
        }
示例#17
0
 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);
 }
示例#18
0
文件: HexCell.cs 项目: v-free/hexMap
 public void Initialize(int x, int z, ITerrain terrain)
 {
     neighbours   = new HexCell[6];
     this.x       = x;
     this.z       = z;
     this.terrain = terrain;
 }
示例#19
0
        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);
        }
示例#21
0
 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++;
            }
        }
示例#23
0
 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);
        }
示例#26
0
        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));
        }
示例#28
0
 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;
        }
示例#30
0
 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);
     });
 }
示例#33
0
文件: World.cs 项目: iZakaroN/Terrain
 private void SetActiveTerrain()
 {
     if (Terrain != null)
     {
         Terrain.Visible = Terrain.Active = false;
     }
     Terrain         = cubicTerrain ? TerrainCube : TerrainTile;
     Terrain.Visible = Terrain.Active = true;
 }
示例#34
0
 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));
 }
示例#35
0
        /// <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;
        }
示例#36
0
        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]);
        }
示例#38
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;
            }
示例#39
0
文件: LindenApi.cs 项目: thoys/simian
 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>();
 }
示例#40
0
        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");
        }
示例#41
0
 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);
 }
示例#42
0
        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));
        }
示例#43
0
 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);
        }
示例#46
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;
        }
示例#47
0
        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();
        }
示例#52
0
        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);
        }
示例#53
0
        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>());
        }
示例#55
0
 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;

        }
示例#58
0
 /// <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]);
     }
 }
示例#59
0
		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;
		}
示例#60
0
        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;
        }