Changeset 4581 for 2013/30


Ignore:
Timestamp:
2013-07-23 14:56:43 (6 years ago)
Author:
dezhidki
Message:

Talletus.

Location:
2013/30/DenisZ
Files:
23 added
13 edited

Legend:

Unmodified
Added
Removed
  • 2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/CastleMaster.csproj

    r4550 r4581  
    7474  </ItemGroup> 
    7575  <ItemGroup> 
     76    <Compile Include="Ai\AStar.cs" /> 
     77    <Compile Include="Ai\Node.cs" /> 
     78    <Compile Include="Ai\Orders\Order.cs" /> 
     79    <Compile Include="Ai\Orders\OrderMove.cs" /> 
    7680    <Compile Include="Entities\Entity.cs" /> 
    77     <Compile Include="Entities\EntityTestMob.cs" /> 
    7881    <Compile Include="Entities\TileEntities\TileEntity.cs" /> 
    7982    <Compile Include="Entities\TileEntities\TileEntityBlock.cs" /> 
     
    9598    <Compile Include="Program.cs" /> 
    9699    <Compile Include="Game.cs" /> 
     100    <Compile Include="Units\Mobs\Mob.cs" /> 
     101    <Compile Include="Units\Mobs\MobWoodcutter.cs" /> 
    97102    <Compile Include="Units\Unit.cs" /> 
    98103    <Compile Include="World\Level.cs" /> 
     
    142147    </BootstrapperPackage> 
    143148  </ItemGroup> 
     149  <ItemGroup /> 
    144150  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" /> 
    145151  <Import Project="$(MSBuildExtensionsPath)\Microsoft\XNA Game Studio\Microsoft.Xna.GameStudio.targets" /> 
  • 2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Entities/Entity.cs

    r4550 r4581  
    1717        protected Vector2 renderOffset, screenPos; 
    1818        protected bool isSolid = true; 
     19        protected float moveSpeed = 0.0F; 
    1920 
    2021        public Entity(Level level) 
     
    4041            set { z = value; } 
    4142        } 
     43 
     44        public float Width { get { return width; } } 
     45 
     46        public float Depth { get { return depth; } } 
    4247 
    4348        public BoundingRectangle BoundingRectangle { get { return boundingRect; } } 
     
    6873        public bool Blocks(Entity ent) 
    6974        { 
    70             return isSolid || ent.isSolid || IsSolidTo(ent) || ent.IsSolidTo(this); 
     75            return isSolid && ent.isSolid && IsSolidTo(ent) && ent.IsSolidTo(this); 
    7176        } 
    7277 
     
    9196                screenPos.X = (x - z) * Viewport.X_SCALE - renderOffset.X; 
    9297                screenPos.Y = (x + z) * Viewport.Y_SCALE - renderOffset.Y; 
    93                 BoundingRectangle.Update(x, z, x, z).AddSelf(rectOffset); 
    9498            } 
    9599 
     
    99103        private bool MovePart(float xd, float zd) 
    100104        { 
     105            if (xd != 0 && zd != 0) return false; 
     106 
    101107            List<BoundingRectangle> collidables = level.GetCollidables(this, BoundingRectangle + new Vector2(xd, zd)); 
    102108 
  • 2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Game.cs

    r4550 r4581  
    8282 
    8383            input.RegisterMouseKey(MouseButtons.Middle); 
     84            input.RegisterMouseKey(MouseButtons.Right); 
     85            input.RegisterMouseKey(MouseButtons.Left); 
    8486        } 
    8587 
     
    118120            camera = new Camera(level); 
    119121            AddPlayer(new PlayerReal(new Team("The men", 0), level, camera)); 
     122            level.InitLevel(); 
     123            camera.CenterOn(level.Width / 2 * Viewport.TILESIZE, level.Height / 2 * Viewport.TILESIZE); 
    120124        } 
    121125 
  • 2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Graphics/Camera.cs

    r4550 r4581  
    4646            set { yOffs = value - Game.HEIGHT; } 
    4747        } 
     48 
     49        public Vector2 MouseWorldPos { get { return mouseWorldPos; } } 
    4850        #endregion 
    4951 
  • 2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Physics/BoundingRectangle.cs

    r4550 r4581  
    3939        public bool Intersects(float x0, float z0, float x1, float z1) 
    4040        { 
    41             if (x0 >= this.x1 && x1 <= this.x0 && z0 >= this.z1 && z1 <= this.z0) return false; 
     41            if (x0 >= this.x1 || x1 <= this.x0 || z0 >= this.z1 || z1 <= this.z0) return false; 
    4242            return true; 
    4343        } 
     
    7272            return new BoundingRectangle(br.x0 + vec.X, br.z0 + vec.Y, br.x1 + vec.X, br.z1 + vec.Y, br.owner); 
    7373        } 
     74 
     75        public BoundingRectangle Scale(float s) 
     76        { 
     77            this.x0 *= s; 
     78            this.z0 *= s; 
     79            this.x1 *= s; 
     80            this.z1 *= s; 
     81 
     82            return this; 
     83        } 
    7484    } 
    7585} 
  • 2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Players/Player.cs

    r4550 r4581  
    2121        } 
    2222 
     23        public Level Level { get { return level; } } 
     24 
     25        public Camera Camera { get { return camera; } } 
     26 
    2327        public Team Team { get { return team; } } 
    2428 
  • 2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Players/PlayerReal.cs

    r4550 r4581  
    88using System.Windows.Forms; 
    99using Microsoft.Xna.Framework; 
     10using CastleMaster.Units; 
    1011 
    1112namespace CastleMaster.Players 
     
    1516        private bool moveWorldWithMouse = false; 
    1617        private Point oldMousePos; 
     18        private Unit selectedUnit; 
    1719 
    1820        public PlayerReal(Team team, Level level, Camera camera) 
     
    4143                else moveWorldWithMouse = false; 
    4244            } 
     45 
     46            if (InputHandler.HasMouseButtonBeenPressed(MouseButtons.Right)) 
     47            { 
     48                Unit u = SelectUnit(); 
     49                if (selectedUnit != null) 
     50                    selectedUnit.OnSelectLost(); 
     51                selectedUnit = u; 
     52                if (selectedUnit != null) 
     53                    selectedUnit.OnSelectGain(); 
     54            } 
     55 
     56            if (InputHandler.HasMouseButtonBeenPressed(MouseButtons.Left)) 
     57            { 
     58                if (selectedUnit != null) 
     59                    selectedUnit.OnFunctionClick(); 
     60            } 
     61        } 
     62 
     63        public Unit SelectUnit() 
     64        { 
     65            float mouseX = InputHandler.MouseX + camera.XLeft; 
     66            float mouseY = InputHandler.MouseY + camera.YTop; 
     67 
     68            float r = 1.0F; 
     69            List<Unit> units = level.GetUnitsWithinScreenSpace(mouseX - r, mouseY - r, mouseX + r, mouseY + r, this); 
     70 
     71            Unit current = null; 
     72            float dist = 0.0F; 
     73            foreach (Unit u in units) 
     74            { 
     75                float udist = u.DistanceFromScreenSpaceSqr(mouseX, mouseY); 
     76                if (current == null || udist < dist) 
     77                { 
     78                    current = u; 
     79                    dist = udist; 
     80                } 
     81            } 
     82 
     83            return current; 
    4384        } 
    4485    } 
  • 2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Units/Unit.cs

    r4550 r4581  
    66using CastleMaster.World; 
    77using CastleMaster.Players; 
     8using CastleMaster.Physics; 
     9using Microsoft.Xna.Framework; 
     10using CastleMaster.Graphics; 
    811 
    912namespace CastleMaster.Units 
     
    1215    { 
    1316        protected bool isSelectable, isSelected; 
     17        protected BoundingRectangle screenRect; 
     18        protected BoundingRectangle screenRectOffset; 
     19        protected Vector2 highlightOffset = Vector2.Zero; 
     20        protected Point spriteSize; 
     21        private float timer = -MathHelper.TwoPi, arrowSpeed = 0.1F; 
     22        private Vector2 arrowOffs = Vector2.Zero; 
     23        private Player owner; 
    1424 
    1525        public Unit(Level level, Player owner) 
    1626            : base(level) 
    1727        { 
     28            this.owner = owner; 
     29 
     30            spriteSize = new Point(32, 32); 
     31            screenRectOffset = new BoundingRectangle(0, 0, spriteSize.X, spriteSize.Y, null); 
    1832            isSelectable = true; 
    1933            isSelected = false; 
    2034        } 
     35 
     36        public bool IsSelectable { get { return isSelectable; } } 
     37 
     38        public Player Owner { get { return owner; } } 
     39 
     40        public override void Init() 
     41        { 
     42            base.Init(); 
     43        } 
     44 
     45        public virtual void OnSelectGain() 
     46        { 
     47            isSelected = true; 
     48        } 
     49 
     50        public virtual void OnSelectLost() 
     51        { 
     52            isSelected = false; 
     53        } 
     54 
     55        public virtual void OnFunctionClick() { } 
     56 
     57        public override void Update() 
     58        { 
     59            if (isSelected) 
     60            { 
     61                timer += arrowSpeed; 
     62                if (timer >= MathHelper.TwoPi) timer = -MathHelper.TwoPi; 
     63                arrowOffs.Y = (float)Math.Sin(timer) * 2.0F; 
     64            } 
     65        } 
     66 
     67        public bool IntersectsWithScreenSpace(float x0, float y0, float x1, float y1) 
     68        { 
     69            if (!isSelectable) return false; 
     70            screenRect = new BoundingRectangle(screenPos.X, screenPos.Y, screenPos.X, screenPos.Y, this).AddSelf(screenRectOffset).Scale(Viewport.ZOOM); 
     71            return screenRect.Intersects(x0, y0, x1, y1); 
     72        } 
     73 
     74        public float DistanceTo(float x, float z) 
     75        { 
     76            float xd = X - x; 
     77            float zd = Z - z; 
     78 
     79            return (float)(Math.Sqrt(xd * xd + zd * zd)); 
     80        } 
     81 
     82        public float DistanceFromScreenSpaceSqr(float x, float y) 
     83        { 
     84            float dx = screenPos.X * Viewport.ZOOM - x; 
     85            float dy = screenPos.Y * Viewport.ZOOM - y; 
     86 
     87            return dx * dx + dy * dy; 
     88        } 
     89 
     90        public virtual void RenderHighLight(RenderHelper renderer) 
     91        { 
     92            renderer.Render((screenPos + highlightOffset + arrowOffs) * Viewport.ZOOM, 1, 0, Resources.SPRITESHEET_ICONS, Viewport.ZOOM); 
     93        } 
     94 
     95        public override void Render(RenderHelper renderer) 
     96        { 
     97            if (isSelected) 
     98                RenderHighLight(renderer); 
     99        } 
    21100    } 
    22101} 
  • 2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/World/Level.cs

    r4550 r4581  
    99using Viewport = CastleMaster.Graphics.Viewport; 
    1010using CastleMaster.Players; 
     11using CastleMaster.Units; 
     12using CastleMaster.Units.Mobs; 
    1113 
    1214namespace CastleMaster.World 
     
    5355        private List<TileEntity> tileEntities; 
    5456        private List<Entity>[] entitiesInTiles; 
    55         private SortedSet<Entity> entitesToRender; 
     57        private List<Entity> entitesToRender; 
     58        private List<Unit>[] units; 
    5659        private int width, height; 
    5760        protected Texture2D tileMap; 
     
    7477            InitTiles(); 
    7578 
     79            units = new List<Unit>[2]; 
     80            units[0] = new List<Unit>(); 
     81            units[1] = new List<Unit>(); 
     82 
    7683            entities = new List<Entity>(); 
    7784            tileEntities = new List<TileEntity>(); 
     
    7986            for (int i = 0; i < width * height; i++) 
    8087                entitiesInTiles[i] = new List<Entity>(); 
    81             entitesToRender = new SortedSet<Entity>(comparer); 
    82  
    83             InitLevel(); 
     88            entitesToRender = new List<Entity>(); 
    8489        } 
    8590 
     
    96101        protected virtual void InitTiles() { } 
    97102 
    98         protected virtual void InitLevel() { } 
     103        public virtual void InitLevel() { } 
    99104 
    100105        public void RenderBackground(Camera camera, RenderHelper renderer) 
     
    135140            if (entitesToRender.Count > 0) 
    136141            { 
     142                entitesToRender.Sort(comparer); 
     143 
    137144                renderer.SetOffset(camera); 
    138145 
     
    168175                ent.Update(); 
    169176 
    170                 if (ent.Removed) 
    171                 { 
    172                     RemoveEntity(ent); 
    173                     TakeEntity(ent, xTile_old, zTile_old); 
    174                     continue; 
    175                 } 
     177                //if (ent.Removed) 
     178                //{ 
     179                //    RemoveEntity(ent); 
     180                //    TakeEntity(ent, xTile_old, zTile_old); 
     181                //    continue; 
     182                //} 
    176183 
    177184                int xTile = (int)(ent.X / Viewport.TILESIZE); 
     
    230237                entities.Add(ent); 
    231238 
     239            if(typeof(Unit).IsAssignableFrom(ent.GetType())) 
     240            { 
     241                Unit u = (Unit)ent; 
     242                units[u.Owner.Team.ID].Add(u); 
     243            } 
     244 
    232245            InsertEntity(ent, xTile, zTile); 
    233246        } 
     
    252265        } 
    253266 
    254         public List<BoundingRectangle> GetCollidables(Entity ent, BoundingRectangle entBR) 
     267        public List<Unit> GetUnitsWithinScreenSpace(float x0, float y0, float x1, float y1, Player player) 
     268        { 
     269            List<Unit> result = new List<Unit>(); 
     270 
     271            foreach (Unit u in units[player.Team.ID]) 
     272            { 
     273                if (u.IsSelectable && u.IntersectsWithScreenSpace(x0, y0, x1, y1)) 
     274                    result.Add(u); 
     275            } 
     276 
     277            return result; 
     278        } 
     279 
     280        public List<BoundingRectangle> GetCollidables(Entity ent, BoundingRectangle br = null) 
    255281        { 
    256282            List<BoundingRectangle> result = new List<BoundingRectangle>(); 
    257283 
    258             int x0 = (int)(entBR.XLeft / Viewport.TILESIZE); 
    259             int z0 = (int)(entBR.ZFar / Viewport.TILESIZE); 
    260             int x1 = (int)(entBR.XRight / Viewport.TILESIZE); 
    261             int z1 = (int)(entBR.ZNear / Viewport.TILESIZE); 
     284            BoundingRectangle entBR = br == null ? ent.BoundingRectangle : br; 
     285 
     286            int x0 = (int)(entBR.XLeft / Viewport.TILESIZE) - 1; 
     287            int z0 = (int)(entBR.ZFar / Viewport.TILESIZE) - 1; 
     288            int x1 = (int)(entBR.XRight / Viewport.TILESIZE) + 1; 
     289            int z1 = (int)(entBR.ZNear / Viewport.TILESIZE) + 1; 
    262290 
    263291            for (int z = z0; z <= z1; z++) 
     
    268296                    if (x < 0 || x >= width) continue; 
    269297 
    270                     foreach (Entity e in entitiesInTiles[x + z * width]) 
     298                    List<Entity> entits = entitiesInTiles[x + z * width]; 
     299 
     300                    foreach (Entity e in entits) 
    271301                    { 
    272302                        if (e != ent && entBR.Intersects(e.BoundingRectangle)) 
     
    275305 
    276306                    Tile t = registeredTiles[tiles[x + z * width]]; 
    277                     if (t.ID != TILE_VOID && t.IsSolid && t.GetBoundingRect(x, z).Intersects(entBR)) 
     307                    if (t.IsSolid && t.GetBoundingRect(x, z).Intersects(entBR)) 
    278308                        t.AddBoundingRect(ref result, x, z); 
    279309                } 
     
    287317            return (tileX >= 0 && tileZ >= 0 && tileX < width && tileZ < height); 
    288318        } 
     319 
     320        public bool[] BuildSolidnessTable(Mob mob) 
     321        { 
     322            bool[] result = new bool[tiles.Length]; 
     323 
     324            for (int i = 0; i < tiles.Length; i++) 
     325            { 
     326                result[i] = tiles[i] == TILE_VOID || registeredTiles[tiles[i]].IsSolid; 
     327 
     328                List<Entity> entInTiles = entitiesInTiles[i]; 
     329 
     330                if (entInTiles.Count > 0) 
     331                { 
     332                    TileEntity te = entInTiles[0] as TileEntity; 
     333                    result[i] = te != null && te.Blocks(mob); 
     334                } 
     335            } 
     336 
     337            return result; 
     338        } 
    289339    } 
    290340} 
  • 2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/World/LevelTest.cs

    r4550 r4581  
    33using Microsoft.Xna.Framework.Graphics; 
    44using CastleMaster.Entities; 
     5using CastleMaster.Units; 
     6using CastleMaster.Units.Mobs; 
    57 
    68namespace CastleMaster.World 
     
    2123        } 
    2224 
    23         protected override void InitLevel() 
     25        public override void InitLevel() 
    2426        { 
    2527            LevelBuilder lb = new LevelBuilder(this, tileMap); 
     
    4446            lb.AddEntity(0xFF00E500, typeof(TileEntityBlock), 8.0F, 8.0F, this, 0, 2); 
    4547            lb.AddEntity(0xFF00FF00, typeof(TileEntityBlock), 8.0F, 8.0F, this, 6, 0); 
    46             lb.AddEntity(0xFFFF0000, typeof(EntityTestMob), 0.0F, 0.0F, this); 
     48            lb.AddEntity(0xFFFF0000, typeof(MobWoodcutter), 8.0F, 8.0F, this, Players[0]); 
    4749 
    4850            lb.BuildLevel(); 
  • 2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/World/Tiles/Tile.cs

    r4550 r4581  
    2424        public virtual BoundingRectangle GetBoundingRect(int xTile, int zTile) 
    2525        { 
    26             return new BoundingRectangle(xTile * Viewport.ZOOM, zTile * Viewport.ZOOM, (xTile + 1) * Viewport.ZOOM, (zTile + 1) * Viewport.ZOOM, this); 
     26            float x = xTile * Viewport.TILESIZE; 
     27            float z = zTile * Viewport.TILESIZE; 
     28 
     29            return new BoundingRectangle(x, z, x + Viewport.TILESIZE, z + Viewport.TILESIZE, this); 
    2730        } 
    2831 
    2932        public virtual void AddBoundingRect(ref List<BoundingRectangle> list, int xTile, int zTile) 
    3033        { 
    31             list.Add(new BoundingRectangle(xTile * Viewport.ZOOM, zTile * Viewport.ZOOM, (xTile + 1) * Viewport.ZOOM, (zTile + 1) * Viewport.ZOOM, this)); 
     34            list.Add(GetBoundingRect(xTile, zTile)); 
    3235        } 
    3336 
  • 2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/World/Tiles/TileWater.cs

    r4535 r4581  
    99            : base(level) 
    1010        { 
     11            IsSolid = true; 
    1112        } 
    1213 
Note: See TracChangeset for help on using the changeset viewer.