mirror of
https://github.com/Phantop/LADXHD.git
synced 2024-11-01 12:24:16 +00:00
503 lines
23 KiB
C#
503 lines
23 KiB
C#
using System;
|
|
using Microsoft.Xna.Framework;
|
|
using Microsoft.Xna.Framework.Graphics;
|
|
using ProjectZ.InGame.Controls;
|
|
using ProjectZ.InGame.SaveLoad;
|
|
using ProjectZ.InGame.Things;
|
|
|
|
namespace ProjectZ.InGame.Overlay
|
|
{
|
|
class InventoryOverlay
|
|
{
|
|
private const int Margin = 6;
|
|
|
|
private RenderTarget2D _renderTarget;
|
|
|
|
private readonly Rectangle _background0 = new Rectangle(0, 0, 268, 24);
|
|
private readonly Rectangle _background1 = new Rectangle(0, 26, 268, 182);
|
|
|
|
private readonly Rectangle _keyRectangle = new Rectangle(94, 6, 20, 114);
|
|
private readonly Rectangle[] _keyPositions = new Rectangle[5];
|
|
|
|
private readonly Rectangle _relictsRectangle = new Rectangle(118, 6, 144, 22);
|
|
private readonly Point _relictPosition = new Point(123, 9);
|
|
private readonly Rectangle[] _relicOffsets = new Rectangle[8];
|
|
|
|
private readonly DictAtlasEntry[] _ocarinaFaces = new DictAtlasEntry[3];
|
|
|
|
private readonly Point _heartsPosition = new Point(6, 5);
|
|
private readonly Point _rubeePosition;
|
|
|
|
private readonly Rectangle _flipperRectangle;
|
|
private readonly Rectangle _potionRectangle;
|
|
|
|
private readonly Rectangle _tradeStuffRectangle = new Rectangle(6, 6, 84, 22);
|
|
private Rectangle _tradeRectangle;
|
|
private Rectangle _shellRectangle;
|
|
private Rectangle _leafRectangle;
|
|
|
|
private readonly Point _skirtPosition;
|
|
private readonly Point _heartPiecePosition;
|
|
|
|
private readonly Point _itemSlotsPosition = new Point(14, 41);
|
|
|
|
private readonly Rectangle _skirtRectangle = new Rectangle(180, 31, 16, 15);
|
|
private readonly Rectangle _skirtColorRectangle = new Rectangle(198, 37, 14, 10);
|
|
private readonly Rectangle _heartPiecesRectangle = new Rectangle(4, 72, 16, 14);
|
|
|
|
private const int ItemSlotWidth = 4;
|
|
|
|
public static Rectangle RecItemselection = new Rectangle(0, 0, 30, 20);
|
|
|
|
public const int DistX = 8;
|
|
public const int DistY = 5;
|
|
|
|
private static string[] _itemSlotString = new[] { "A", "B", "X", "Y" };
|
|
|
|
// 3
|
|
// 2 1
|
|
// 0
|
|
private static Rectangle[] _itemSlots = {
|
|
new Rectangle(RecItemselection.Width + DistX / 2 - RecItemselection.Width / 2,
|
|
RecItemselection.Height * 2 + DistY * 2,
|
|
RecItemselection.Width, RecItemselection.Height),
|
|
new Rectangle(RecItemselection.Width + DistX, RecItemselection.Height + DistY,
|
|
RecItemselection.Width, RecItemselection.Height),
|
|
new Rectangle(0, RecItemselection.Height + DistY,
|
|
RecItemselection.Width, RecItemselection.Height),
|
|
new Rectangle(RecItemselection.Width + DistX / 2 - RecItemselection.Width / 2, 0,
|
|
RecItemselection.Width, RecItemselection.Height)
|
|
};
|
|
|
|
|
|
private int _selectedItemSlot;
|
|
|
|
private readonly Point _itemRectangleSize = new Point(27, 26);
|
|
private readonly Point _itemRecMargin = new Point(0, 0);
|
|
|
|
private readonly Point _equipmentPosition = new Point(6, 123);
|
|
private readonly Rectangle _itemsRectangle = new Rectangle(6, 124, 108, 52);
|
|
|
|
private readonly int _width;
|
|
private readonly int _height;
|
|
|
|
private float _selectionCounter;
|
|
private const int SelectionTime = 125;
|
|
private bool _selectionButtonPressed;
|
|
|
|
public InventoryOverlay(int width, int height)
|
|
{
|
|
_width = width;
|
|
_height = height;
|
|
|
|
_rubeePosition = new Point(width - ItemDrawHelper.RubeeSize.X - Margin, 10);
|
|
|
|
var blockPosition = 97;
|
|
_skirtPosition = new Point(blockPosition, 5);
|
|
_heartPiecePosition = new Point(blockPosition += 34, 6);
|
|
_flipperRectangle = new Rectangle(blockPosition += 18, 0, 12, _background0.Height);
|
|
_potionRectangle = new Rectangle(blockPosition += 12, 0, 12, _background0.Height);
|
|
|
|
// key positions
|
|
for (var i = 0; i < 5; i++)
|
|
_keyPositions[i] = new Rectangle(96, 12 + i * 21, 16, 16);
|
|
|
|
// relict positions
|
|
for (var i = 0; i < 8; i++)
|
|
_relicOffsets[i] = new Rectangle(i * 17, 0, 16, 16);
|
|
|
|
_ocarinaFaces[0] = Resources.GetSprite("ocarina1");
|
|
_ocarinaFaces[1] = Resources.GetSprite("ocarina2");
|
|
_ocarinaFaces[2] = Resources.GetSprite("ocarina3");
|
|
}
|
|
|
|
public void UpdateRenderTarget()
|
|
{
|
|
if (_renderTarget == null || _renderTarget.Width != _width * Game1.UiScale || _renderTarget.Height != _height * Game1.UiScale)
|
|
_renderTarget = new RenderTarget2D(Game1.Graphics.GraphicsDevice, _width * Game1.UiScale, _height * Game1.UiScale);
|
|
}
|
|
|
|
public void UpdateMenu()
|
|
{
|
|
for (var i = 0; i < 4; i++)
|
|
{
|
|
if (ControlHandler.ButtonPressed((CButtons)((int)CButtons.A * Math.Pow(2, i))))
|
|
{
|
|
Game1.GameManager.PlaySoundEffect("D360-19-13");
|
|
Game1.GameManager.ChangeItem(i, _selectedItemSlot + Values.HandItemSlots);
|
|
}
|
|
}
|
|
|
|
var selectionOffset = 0;
|
|
|
|
var direction = ControlHandler.GetMoveVector2();
|
|
if (direction.Length() > Values.ControllerDeadzone)
|
|
{
|
|
_selectionCounter -= Game1.DeltaTime;
|
|
if (_selectionCounter <= 0 || !_selectionButtonPressed)
|
|
{
|
|
_selectionCounter += SelectionTime;
|
|
|
|
var dir = AnimationHelper.GetDirection(direction);
|
|
if (dir == 0)
|
|
selectionOffset -= 1;
|
|
else if (dir == 1)
|
|
selectionOffset -= ItemSlotWidth;
|
|
else if (dir == 2)
|
|
selectionOffset += 1;
|
|
else if (dir == 3)
|
|
selectionOffset += ItemSlotWidth;
|
|
}
|
|
|
|
_selectionButtonPressed = true;
|
|
}
|
|
else
|
|
{
|
|
_selectionButtonPressed = false;
|
|
_selectionCounter = SelectionTime;
|
|
}
|
|
|
|
// update the selected ocarina song
|
|
var selectedItem = Game1.GameManager.Equipment[Values.HandItemSlots + _selectedItemSlot];
|
|
if (selectedItem != null && selectedItem.Name == "ocarina")
|
|
{
|
|
if ((selectionOffset == -1 || selectionOffset == 1) &&
|
|
MoveOcarinaSelection(selectionOffset))
|
|
selectionOffset = 0;
|
|
}
|
|
|
|
_selectedItemSlot += selectionOffset;
|
|
|
|
var slots = GameManager.EquipmentSlots - 4;
|
|
if (_selectedItemSlot < 0)
|
|
_selectedItemSlot += slots;
|
|
if (_selectedItemSlot >= slots)
|
|
_selectedItemSlot = _selectedItemSlot % slots;
|
|
}
|
|
|
|
private bool MoveOcarinaSelection(int direction)
|
|
{
|
|
var previousSong = Game1.GameManager.SelectedOcarinaSong;
|
|
|
|
for (var i = 0; i < Game1.GameManager.Equipment.Length; i++)
|
|
{
|
|
Game1.GameManager.SelectedOcarinaSong += direction;
|
|
if (Game1.GameManager.SelectedOcarinaSong < 0 ||
|
|
Game1.GameManager.SelectedOcarinaSong >= _ocarinaFaces.Length)
|
|
{
|
|
Game1.GameManager.SelectedOcarinaSong = previousSong;
|
|
return false;
|
|
}
|
|
|
|
if (Game1.GameManager.SelectedOcarinaSong != -1 &&
|
|
Game1.GameManager.OcarinaSongs[Game1.GameManager.SelectedOcarinaSong] == 1)
|
|
return Game1.GameManager.SelectedOcarinaSong != previousSong;
|
|
}
|
|
|
|
Game1.GameManager.SelectedOcarinaSong = -1;
|
|
return false;
|
|
}
|
|
|
|
public void Draw(SpriteBatch spriteBatch, Rectangle drawPosition, Color color)
|
|
{
|
|
spriteBatch.Draw(_renderTarget, drawPosition, color);
|
|
}
|
|
|
|
public void DrawRT(SpriteBatch spriteBatch)
|
|
{
|
|
Game1.Graphics.GraphicsDevice.SetRenderTarget(_renderTarget);
|
|
Game1.Graphics.GraphicsDevice.Clear(Color.Transparent);
|
|
|
|
Resources.RoundedCornerEffect.Parameters["scale"].SetValue(Game1.UiRtScale);
|
|
Resources.RoundedCornerEffect.Parameters["radius"].SetValue(3f);
|
|
|
|
// draw the background
|
|
spriteBatch.Begin(SpriteSortMode.Immediate, null, null, null, null, Resources.RoundedCornerEffect, Matrix.CreateScale(Game1.UiRtScale));
|
|
|
|
Resources.RoundedCornerEffect.Parameters["width"].SetValue(_background0.Width);
|
|
Resources.RoundedCornerEffect.Parameters["height"].SetValue(_background0.Height);
|
|
spriteBatch.Draw(Resources.SprWhite, _background0, Values.InventoryBackgroundColorTop);
|
|
|
|
Resources.RoundedCornerEffect.Parameters["width"].SetValue(_background1.Width);
|
|
Resources.RoundedCornerEffect.Parameters["height"].SetValue(_background1.Height);
|
|
spriteBatch.Draw(Resources.SprWhite, _background1, Values.InventoryBackgroundColor);
|
|
|
|
spriteBatch.End();
|
|
|
|
// draw the backgrounds of the items
|
|
{
|
|
spriteBatch.Begin(SpriteSortMode.Immediate, null, null, null, null, Resources.RoundedCornerEffect, Matrix.CreateScale(Game1.UiRtScale));
|
|
|
|
var offset = new Point(_background1.X, _background1.Y);
|
|
|
|
for (var i = 0; i < _itemSlots.Length; i++)
|
|
DrawBackground(spriteBatch, offset + _itemSlotsPosition, _itemSlots[i]);
|
|
|
|
DrawBackground(spriteBatch, offset, _keyRectangle);
|
|
DrawBackground(spriteBatch, offset, _relictsRectangle);
|
|
DrawBackground(spriteBatch, offset, _itemsRectangle);
|
|
DrawBackground(spriteBatch, offset, _tradeStuffRectangle);
|
|
|
|
// draw the item selection
|
|
var selectionPosition = new Point(
|
|
(_itemsRectangle.X + _selectedItemSlot % ItemSlotWidth * (_itemRectangleSize.X + _itemRecMargin.X)),
|
|
(_itemsRectangle.Y + _selectedItemSlot / ItemSlotWidth * (_itemRectangleSize.Y + _itemRecMargin.Y)));
|
|
DrawBackground(spriteBatch, offset + selectionPosition, new Rectangle(0, 0, _itemRectangleSize.X, _itemRectangleSize.Y));
|
|
|
|
// draw the collected items
|
|
for (var i = 0; i < Game1.GameManager.Equipment.Length - Values.HandItemSlots; i++)
|
|
{
|
|
var slotRectangle = new Rectangle(
|
|
i % ItemSlotWidth * (_itemRectangleSize.X + _itemRecMargin.X) + _itemRectangleSize.X / 2 - 2,
|
|
i / ItemSlotWidth * (_itemRectangleSize.Y + _itemRecMargin.Y) + _itemRectangleSize.Y - 8, 4, 2);
|
|
|
|
if (Game1.GameManager.Equipment[Values.HandItemSlots + i] == null)
|
|
DrawBackground(spriteBatch, offset + _equipmentPosition, slotRectangle, 1);
|
|
}
|
|
|
|
// key background dots
|
|
for (var i = 0; i < 5; i++)
|
|
{
|
|
var slotRectangle = new Rectangle(
|
|
_keyPositions[i].X + _keyPositions[i].Width / 2 - 2,
|
|
_keyPositions[i].Y + _keyPositions[i].Height - 2, 4, 2);
|
|
|
|
var itemKey = Game1.GameManager.GetItem("dkey" + (i + 1));
|
|
if (itemKey == null)
|
|
DrawBackground(spriteBatch, offset, slotRectangle, 1);
|
|
}
|
|
|
|
for (var i = 0; i < _relicOffsets.Length; i++)
|
|
{
|
|
var name = "instrument" + i;
|
|
var hasItem = Game1.GameManager.GetItem(name) != null;
|
|
|
|
if (!hasItem)
|
|
{
|
|
var position = new Point(_relictPosition.X + _relicOffsets[i].X + _relicOffsets[i].Width / 2 - 2, _relictPosition.Y + _relicOffsets[i].Bottom - 2);
|
|
DrawBackground(spriteBatch, offset + position, new Rectangle(0, 0, 4, 2), 1);
|
|
}
|
|
}
|
|
|
|
spriteBatch.End();
|
|
}
|
|
|
|
// draw the map
|
|
spriteBatch.Begin(SpriteSortMode.Deferred, null, SamplerState.PointClamp, null, null, null, Matrix.CreateScale(Game1.UiRtScale));
|
|
|
|
{
|
|
var heartOffset = new Point(0, Game1.GameManager.MaxHearths > 7 ? 0 : 4);
|
|
ItemDrawHelper.DrawHearts(spriteBatch, _heartsPosition + heartOffset, 1, Color.White);
|
|
|
|
// draw the skirt
|
|
DrawSkirt(spriteBatch, _skirtPosition);
|
|
|
|
DrawHeartContainer(spriteBatch, _heartPiecePosition);
|
|
|
|
ItemDrawHelper.DrawItemWithInfo(spriteBatch, Game1.GameManager.GetItem("flippers"), Point.Zero, _flipperRectangle, 1, Color.White);
|
|
|
|
ItemDrawHelper.DrawItemWithInfo(spriteBatch, Game1.GameManager.GetItem("potion"), Point.Zero, _potionRectangle, 1, Color.White);
|
|
|
|
ItemDrawHelper.DrawRubee(spriteBatch, _rubeePosition, 1, Color.Black);
|
|
|
|
var offsetBottom = new Point(_background1.X, _background1.Y);
|
|
|
|
// center the items
|
|
{
|
|
var width = 0;
|
|
var hasTradeItem = false;
|
|
for (var i = 0; i < 15; i++)
|
|
{
|
|
hasTradeItem = Game1.GameManager.GetItem("trade" + i) != null;
|
|
if (hasTradeItem)
|
|
{
|
|
width += 28;
|
|
break;
|
|
}
|
|
}
|
|
var itemShell = Game1.GameManager.GetItem("shell");
|
|
var itemLeaf = Game1.GameManager.GetItem("goldLeaf");
|
|
if (itemShell != null)
|
|
width += 28;
|
|
if (itemLeaf != null)
|
|
width += 28;
|
|
|
|
var posX = _tradeStuffRectangle.Width / 2 - width / 2;
|
|
_tradeRectangle = new Rectangle(6 + posX, 6, 28, 22);
|
|
|
|
if (hasTradeItem)
|
|
posX += 28;
|
|
_shellRectangle = new Rectangle(6 + posX, 6, 28, 22);
|
|
|
|
if (itemShell != null)
|
|
posX += 28;
|
|
_leafRectangle = new Rectangle(6 + posX, 6, 28, 22);
|
|
|
|
// draw the current trade item
|
|
DrawTradeItem(spriteBatch, offsetBottom, 1);
|
|
ItemDrawHelper.DrawItemWithInfo(spriteBatch, Game1.GameManager.GetItem("shell"), offsetBottom, _shellRectangle, 1, Color.White);
|
|
ItemDrawHelper.DrawItemWithInfo(spriteBatch, Game1.GameManager.GetItem("goldLeaf"), offsetBottom, _leafRectangle, 1, Color.White);
|
|
}
|
|
|
|
// draw the collected equipment
|
|
DrawEquipment(spriteBatch, offsetBottom + _equipmentPosition);
|
|
|
|
// draw the item slots
|
|
for (var i = 0; i < _itemSlots.Length; i++)
|
|
{
|
|
ItemDrawHelper.DrawItemWithInfo(spriteBatch, Game1.GameManager.Equipment[i], offsetBottom + _itemSlotsPosition, _itemSlots[i], 1, Color.White);
|
|
|
|
spriteBatch.DrawString(Resources.GameFont, _itemSlotString[i], new Vector2(
|
|
offsetBottom.X + _itemSlotsPosition.X + _itemSlots[i].Right - 4,
|
|
offsetBottom.Y + _itemSlotsPosition.Y + _itemSlots[i].Bottom - 4), Color.Black);
|
|
}
|
|
|
|
// draw the collected keys
|
|
for (var i = 0; i < 5; i++)
|
|
ItemDrawHelper.DrawItemWithInfo(spriteBatch, Game1.GameManager.GetItem("dkey" + (i + 1)), offsetBottom, _keyPositions[i], 1, Color.White);
|
|
|
|
DrawRelicts(spriteBatch, offsetBottom + _relictPosition);
|
|
}
|
|
|
|
spriteBatch.End();
|
|
}
|
|
|
|
private void DrawBackground(SpriteBatch spriteBatch, Point offset, Rectangle rectangle, float radius = 3f)
|
|
{
|
|
Resources.RoundedCornerEffect.Parameters["radius"].SetValue(radius);
|
|
Resources.RoundedCornerEffect.Parameters["width"].SetValue(rectangle.Width);
|
|
Resources.RoundedCornerEffect.Parameters["height"].SetValue(rectangle.Height);
|
|
|
|
spriteBatch.Draw(Resources.SprWhite, new Rectangle(offset.X + rectangle.X, offset.Y + rectangle.Y, rectangle.Width, rectangle.Height), Color.Black * 0.15f);
|
|
}
|
|
|
|
public void DrawEquipment(SpriteBatch spriteBatch, Point drawPosition)
|
|
{
|
|
// draw the collected items
|
|
for (var i = 0; i < Game1.GameManager.Equipment.Length - Values.HandItemSlots; i++)
|
|
{
|
|
var slotRectangle = new Rectangle(
|
|
i % ItemSlotWidth * (_itemRectangleSize.X + _itemRecMargin.X),
|
|
i / ItemSlotWidth * (_itemRectangleSize.Y + _itemRecMargin.Y),
|
|
_itemRectangleSize.X, _itemRectangleSize.Y);
|
|
|
|
// draw the item
|
|
var itemIndex = i + Values.HandItemSlots;
|
|
var offsetY = _selectedItemSlot == i ? -1 : 0;
|
|
|
|
if (_selectedItemSlot == i &&
|
|
Game1.GameManager.Equipment[itemIndex] != null &&
|
|
Game1.GameManager.Equipment[itemIndex].Name == "ocarina")
|
|
{
|
|
var hasSong = false;
|
|
for (var j = 0; j < Game1.GameManager.OcarinaSongs.Length; j++)
|
|
if (Game1.GameManager.OcarinaSongs[j] != 0)
|
|
{
|
|
hasSong = true;
|
|
break;
|
|
}
|
|
|
|
if (hasSong)
|
|
continue;
|
|
}
|
|
|
|
ItemDrawHelper.DrawItemWithInfo(spriteBatch, Game1.GameManager.Equipment[itemIndex], new Point(drawPosition.X, drawPosition.Y + offsetY + 1), slotRectangle, 1, Color.White);
|
|
}
|
|
|
|
// draw the ocarina face selection
|
|
var selectedItem = Game1.GameManager.Equipment[4 + _selectedItemSlot];
|
|
if (selectedItem != null && selectedItem.Name == "ocarina")
|
|
{
|
|
var selectedSong = Game1.GameManager.SelectedOcarinaSong;
|
|
if (selectedSong != -1)
|
|
{
|
|
var hasSong = Game1.GameManager.OcarinaSongs[selectedSong] == 1;
|
|
var position = new Vector2(
|
|
drawPosition.X + (_selectedItemSlot % ItemSlotWidth * (_itemRectangleSize.X + _itemRecMargin.X)) +
|
|
_itemRectangleSize.X / 2 - _ocarinaFaces[selectedSong].ScaledRectangle.Width / 2,
|
|
drawPosition.Y + (_selectedItemSlot / ItemSlotWidth * (_itemRectangleSize.Y + _itemRecMargin.Y)) +
|
|
_itemRectangleSize.Y / 2 - _ocarinaFaces[selectedSong].ScaledRectangle.Height / 2);
|
|
|
|
DrawHelper.DrawNormalized(spriteBatch, _ocarinaFaces[selectedSong], position, hasSong ? Color.White : Color.Gray);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void DrawRelicts(SpriteBatch spriteBatch, Point drawPosition)
|
|
{
|
|
// draw the relicts
|
|
for (var i = 0; i < _relicOffsets.Length; i++)
|
|
{
|
|
var name = "instrument" + i;
|
|
var hasItem = Game1.GameManager.GetItem(name) != null;
|
|
var item = Game1.GameManager.ItemManager[name];
|
|
|
|
if (hasItem)
|
|
ItemDrawHelper.DrawInstrument(spriteBatch, item.Sprite, new Vector2(
|
|
drawPosition.X + _relicOffsets[i].X, drawPosition.Y + _relicOffsets[i].Y));
|
|
}
|
|
}
|
|
|
|
public void DrawHeartContainer(SpriteBatch spriteBatch, Point drawPosition)
|
|
{
|
|
// heartMeter
|
|
var item = Game1.GameManager.GetItem("heartMeter");
|
|
var count = 0;
|
|
|
|
if (item != null)
|
|
count = item.Count;
|
|
|
|
// draw the heart container
|
|
spriteBatch.Draw(Resources.SprItem, new Rectangle(
|
|
drawPosition.X, drawPosition.Y, _heartPiecesRectangle.Width, _heartPiecesRectangle.Height),
|
|
new Rectangle(_heartPiecesRectangle.X + (_heartPiecesRectangle.Width + 2) * count,
|
|
_heartPiecesRectangle.Y, _heartPiecesRectangle.Width, _heartPiecesRectangle.Height), Color.White);
|
|
}
|
|
|
|
public void DrawTradeItem(SpriteBatch spriteBatch, Point drawPosition, int scale)
|
|
{
|
|
// draw the current trade item
|
|
for (var i = 0; i < 15; i++)
|
|
{
|
|
var hasItem = Game1.GameManager.GetItem("trade" + i) != null;
|
|
|
|
if (!hasItem)
|
|
continue;
|
|
|
|
// draw the key
|
|
DrawHelper.DrawCenter(spriteBatch, Resources.SprItem,
|
|
drawPosition, _tradeRectangle, Game1.GameManager.ItemManager["trade" + i].SourceRectangle.Value, scale);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void DrawSkirt(SpriteBatch spriteBatch, Point drawPosition)
|
|
{
|
|
// draw GBR
|
|
spriteBatch.Draw(Resources.SprItem, new Rectangle(
|
|
drawPosition.X,
|
|
drawPosition.Y + 2,
|
|
_skirtColorRectangle.Width, _skirtColorRectangle.Height),
|
|
new Rectangle(
|
|
_skirtColorRectangle.X,
|
|
_skirtColorRectangle.Y + Game1.GameManager.CloakType * (_skirtColorRectangle.Height + 1),
|
|
_skirtColorRectangle.Width, _skirtColorRectangle.Height), Color.White);
|
|
|
|
var skirtPosition = new Point(drawPosition.X + _skirtColorRectangle.Width + 1, drawPosition.Y);
|
|
|
|
// draw the skirt
|
|
spriteBatch.Draw(Resources.SprItem, new Rectangle(
|
|
skirtPosition.X, skirtPosition.Y,
|
|
_skirtRectangle.Width, _skirtRectangle.Height), _skirtRectangle, Color.White);
|
|
|
|
// draw the skirt color
|
|
spriteBatch.Draw(Resources.SprItem, new Rectangle(
|
|
skirtPosition.X, skirtPosition.Y,
|
|
_skirtRectangle.Width, _skirtRectangle.Height),
|
|
new Rectangle(_skirtRectangle.X, _skirtRectangle.Y + _skirtRectangle.Height,
|
|
_skirtRectangle.Width, _skirtRectangle.Height), Values.SkirtColors[Game1.GameManager.CloakType]);
|
|
}
|
|
}
|
|
}
|