Exemple #1
0
		// TODO: Might need to pass in the owner entity, so that if a potion is used up, the player will get an empty bottle.
		public void Use(Level level, ChunkLayer layer, int blockX, int blockY)
		{
			var isConsumed = false;
			GetItem().Use(level, layer, blockX, blockY, out isConsumed);
			if (isConsumed)
			{
				StackSize--;
			}
		}
		public WorldManager(Viewport viewport, Level level)
		{
			Level = level;

			GeneratePlayer();

			Camera = GameCore.Camera.CreateOrthographicCamera(viewport);
			_chunkRenderer = new ChunkRenderer(viewport);
		}
		public GameplayState(GameStateManager manager, Level level)
			: base(manager)
		{
			var viewport = new Viewport(0, 0, manager.GameWindow.Width, manager.GameWindow.Height);

			_frameCount = 0;
			_totalGameTime = TimeSpan.Zero;
			_timer = Stopwatch.StartNew();

			_worldManager = new WorldManager(viewport, level);
			_uiManager = new UIManager(manager.GameWindow, viewport, _worldManager);

			_tessellator = new VertexBufferTessellator() { Mode = VertexTessellatorMode.Render };
		}
		// TODO: I can make farmland; now I need something to plant.

		/// <summary>
		/// You can only till dirt or grass.
		/// </summary>
		public override void Use(Level level, ChunkLayer layer, int blockX, int blockY, out bool isConsumed)
		{
			base.Use(level, layer, blockX, blockY, out isConsumed);

			layer = level.GetHighestVisibleLayer(blockX, blockY);
			var blockId = level[layer, blockX, blockY];
			if ((blockId == _tilledSoil))
			{
				level[layer, blockX, blockY] = _wheatPlant;
				isConsumed = true;
			}

			// TODO: If durability <= 0, isConsumed = true.
		}
		public override void Update(TimeSpan elapsed, Level level, ChunkLayer layer, int blockX, int blockY)
		{
			_totalElapsedTime += elapsed;
			if (_totalElapsedTime.TotalSeconds > 5)
			{
				_totalElapsedTime = TimeSpan.Zero;

				var oldMetadata = level.GetMetadata(layer, blockX, blockY);
				var newMetadata = oldMetadata + 1;
				if (newMetadata <= 7)
				{
					level.SetMetadata(layer, blockX, blockY, newMetadata);
				}
			}
		}
		public override void LoadContent(ContentManager content)
		{
			base.LoadContent(content);

			_ascii = content.Load<TileSet>("TileSets/ASCII.xml");
			
			var progress = new Progress<string>(message => _progressMessages.Push(message));
			content.Load<BlockRegistry>("Blocks/SampleBlockRegistry.xml");
			ItemRegistry.Instance.Initialize();

			_loadingTask = Task.Run(() =>
			{
				_level = new Level(ChunkType.Overworld);
				var chunk = _level[ChunkLayer.Floor, 0, 0]; // generate the first chunk
			}).ContinueWith(x => Thread.Sleep(100));
		}
Exemple #7
0
		// TODO: When farmland is broken, it should drop a dirt block.

		public override void Use(Level level, ChunkLayer layer, int blockX, int blockY, out bool isConsumed)
		{
			base.Use(level, layer, blockX, blockY, out isConsumed);

			var blockId = level[layer, blockX, blockY];
			if (blockId > 0)
			{
				level[layer, blockX, blockY] = 0;

				var blockEntity = new BlockEntity(blockId);
				blockEntity.MoveTo(level, new Vector2(blockX, blockY));
				level.AddEntity(blockEntity);
			}

			// TODO: If durability <= 0, isConsumed = true.
			isConsumed = false;
		}
Exemple #8
0
		private void Move(Level level)
		{
			Move(level, _orientation);
		}
Exemple #9
0
		private void Move(Level level, Direction direction)
		{
			// TODO: Modify speed according to the friction value of the current block.
			// TODO: Move slower if traveling on the background layer.
			// TODO: Don't allow walking through a position where all layers, including the background, are empty.
			MoveBy(level, direction, _speed);
		}
Exemple #10
0
		private void MoveBy(Level level, Direction direction, float speed)
		{
			var vi = direction.ToVector2I();
			MoveBy(level, new Vector2(vi.X * speed, vi.Y * speed));
		}
Exemple #11
0
		private void MoveBy(Level level, Vector2 delta)
		{
			MoveTo(level, _position + delta);
		}
Exemple #12
0
		/// <summary>
		/// This allows us to either update all of the entities in the level, or only the entities in the given chunk, i.e. the player's chunk.
		/// This may not be necessary, or it may need to be expanded to the nearest 3 chunks, etc.
		/// Looking up the player's chunk every frame may slow things down more than just updating every entity.  I'm not sure yet.
		/// </summary>
		private void UpdateEntities(TimeSpan elapsed, Level level)
		{
			var deadEntities = new List<Entity>();
			foreach (var entity in Entities)
			{
				entity.Update(level, elapsed);
				if (!entity.IsAlive)
				{
					deadEntities.Add(entity);
				}
			}

			foreach (var entity in deadEntities)
			{
				level.GetChunk(entity).RemoveEntity(entity);
			}
		}
Exemple #13
0
		/// <summary>
		/// Use this item on the selected location.
		/// </summary>
		public virtual void Use(Level level, ChunkLayer layer, int blockX, int blockY, out bool isConsumed)
		{
			isConsumed = false;
		}
		public virtual void Update(TimeSpan elapsed, Level level, ChunkLayer layer, int blockX, int blockY)
		{
		}
Exemple #15
0
		public override void Update(Level level, TimeSpan elapsed)
		{
			base.Update(level, elapsed);
			_rotation += Speed;
		}
Exemple #16
0
		public void Update(TimeSpan elapsed, Level level)
		{
			_ambientLightLevel = level.AmbientLightLevel;

			UpdateBlocks(elapsed, level, ChunkLayer.Background);
			UpdateBlocks(elapsed, level, ChunkLayer.Floor);

			UpdateEntities(elapsed, level);

			UpdateBlocks(elapsed, level, ChunkLayer.Blocking);
			UpdateBlocks(elapsed, level, ChunkLayer.Ceiling);
		}
Exemple #17
0
		public virtual void Update(Level level, TimeSpan elapsed)
		{
			if (_isMoving)
			{
				Move(level);
			}
		}
Exemple #18
0
		private void UpdateBlocks(TimeSpan elapsed, Level level, ChunkLayer layer)
		{
			for (var blockX = 0; blockX < Width; blockX++)
			{
				for (var blockY = 0; blockY < Height; blockY++)
				{
					var blockId = _blockIndex[(int)layer, blockY, blockX];
					if (blockId != NULL_BLOCK_ID)
					{
						BlockRegistry.Instance.GetById(blockId).Update(elapsed, level, layer, blockX, blockY);
					}
				}
			}
		}
Exemple #19
0
		public void MoveTo(Level level, Vector2 newPosition)
		{
			var center = new Vector2(newPosition.X + Size / 2.0f, newPosition.Y + Size / 2.0f);
			var impactEntities = level.GetEntitiesAt(center, new Vector2(Size / 2.0f, Size / 2.0f));
			if (impactEntities != null)
			{
				foreach (var impactEntity in impactEntities)
				{
					if (impactEntity != this)
					{
						impactEntity.Touched(this);
						//_isMoving = false; // TODO: Is it good to continue moving through an entity like this?  Should the Speed by modified at all?
					}
				}
			}

			if (CanMoveTo(level, newPosition))
			{
				var oldChunk = level.GetChunk(this); // (int)(_position.X + Size / 2), (int)(_position.Y + Size / 2));

				_position = newPosition;

				var newChunk = level.GetChunk(this);

				if (oldChunk != newChunk)
				{
					oldChunk.RemoveEntity(this);
					newChunk.AddEntity(this);
				}
			}
			else
			{
				_isMoving = false;
			}
		}
Exemple #20
0
		/// <summary>
		/// Is there a block blocking this position?
		/// </summary>
		protected bool CanMoveTo(Level level, Vector2 newPosition)
		{
			// This looks right, and visually it looks mostly right.
			var topLeft = new Vector2(newPosition.X, newPosition.Y);
			var bottomRight = new Vector2(topLeft.X + Size, topLeft.Y + Size);

			return
				!level.IsBlockedAt((int)Math.Floor(topLeft.X), (int)Math.Floor(topLeft.Y)) &&
				!level.IsBlockedAt((int)Math.Floor(topLeft.X), (int)Math.Floor(bottomRight.Y)) &&
				!level.IsBlockedAt((int)Math.Floor(bottomRight.X), (int)Math.Floor(bottomRight.Y)) &&
				!level.IsBlockedAt((int)Math.Floor(bottomRight.X), (int)Math.Floor(topLeft.Y));
		}
Exemple #21
0
		public override void Update(Level level, TimeSpan elapsed)
		{
			base.Update(level, elapsed);

			// Clear out empty item stacks.
			UpdateItems(Inventory);
			UpdateItems(Toolbelt);
		}