public void Draw(ref SpriteBatch sb, ref Vector2 viewport_loc)
{
Vector2 offset = MapSprite.mapDrawOrigin - viewport_loc;
//MapSprite.Draw(sb, new Vector2(mapPosition.X - (int)viewport_loc.X, mapPosition.Y - (int)viewport_loc.Y), 0f);
MapSprite.Draw(sb, new Vector2(mapPosition.X + (int)offset.X, mapPosition.Y + (int)offset.Y), 0f);
}
public Player(ref ContentManager contentMan, string name, Point start, Directions dir, Character character)
: base(name, start, dir)
{
LoadCharacter(character);
pStats = new PrimStats(21, 17, 28, 34, 22, 19, 25);
sStats = new SecStats(127, 10, 2, 43, 56);
MapSprite.PlayAnimation("Idle");
}
public SmallNpc(MapNpc npc)
{
_npc = npc ?? throw new ArgumentNullException(nameof(npc));
_sprite = AttachChild(new MapSprite(npc.SpriteOrGroup, DrawLayer.Underlay - 1, 0, SpriteFlags.BottomAligned)
{
SelectionCallback = registerHit => { registerHit(this); return(false); }
});
On <ShowMapMenuEvent>(OnRightClick);
On <SlowClockEvent>(e =>
{
_frameCount += e.Delta;
_sprite.Frame = _frameCount;
});
}
void Core_LoadTestView()
{
try
{
GBA.Palette palette = new GBA.Palette(CurrentPalette);
palette[0] = palette[0].SetAlpha(true);
GBA.Tileset tileset = null;
byte size = (byte)CurrentIdle["Size"];
int frame = Test_TrackBar.Value * 16;
GBA.TileMap tilemap = new TileMap(4, 4);
if (Test_Idle.Checked)
{
tilemap.Map(MapSprite.Map_Test(frame, size));
tileset = CurrentMapSprite.Sprites[MapSprite.IDLE].Sheet;
}
frame++;
if (Test_MoveSide.Checked)
{
tilemap.Map(MapSprite.Map_Test(frame));
tileset = CurrentMapSprite.Sprites[MapSprite.WALK].Sheet;
}
frame += 16 * 4;
if (Test_MoveDown.Checked)
{
tilemap.Map(MapSprite.Map_Test(frame));
tileset = CurrentMapSprite.Sprites[MapSprite.WALK].Sheet;
}
frame += 16 * 4;
if (Test_MoveUp.Checked)
{
tilemap.Map(MapSprite.Map_Test(frame));
tileset = CurrentMapSprite.Sprites[MapSprite.WALK].Sheet;
}
frame += 16 * 4;
if (Test_Selected.Checked)
{
tilemap.Map(MapSprite.Map_Test(frame));
tileset = CurrentMapSprite.Sprites[MapSprite.WALK].Sheet;
}
TestSprite = new GBA.Sprite(palette, tileset, tilemap);
Test_ImageBox.Load(TestSprite);
}
catch (Exception ex)
{
Program.ShowError("Could not load the map sprite test image.", ex);
}
}
void Core_Insert(MapSprite insert)
{
Core.SuspendUpdate();
try
{
byte[] data_idle = insert.Sprites[MapSprite.IDLE].Sheet.ToBytes(true);
byte[] data_move = insert.Sprites[MapSprite.WALK].Sheet.ToBytes(true);
bool cancel = Prompt.ShowRepointDialog(this, "Repoint Map Sprite",
"The Map Sprite to insert might need to be repointed.",
CurrentIdleEntry,
new Tuple <string, Pointer, int>[] {
Tuple.Create("Idle Sprite", (Pointer)CurrentIdle["Sprite"], data_idle.Length),
Tuple.Create("Move Sprite", (Pointer)CurrentMove["Sprite"], data_move.Length)
},
new Pointer[] {
CurrentIdle.GetAddress(CurrentIdle.EntryIndex, "Sprite"),
CurrentMove.GetAddress(CurrentMove.EntryIndex, "Sprite")
});
if (cancel)
{
return;
}
Core.WriteData(this,
(Pointer)CurrentIdle["Sprite"],
data_idle,
CurrentIdleEntry + "Idle Sprite changed");
Core.WriteData(this,
(Pointer)CurrentMove["Sprite"],
data_move,
CurrentMoveEntry + "Move Sprite changed");
Core.WriteByte(this,
CurrentIdle.GetAddress(CurrentIdle.EntryIndex, "Size"),
insert.IdleSize,
CurrentIdleEntry + "Size changed");
}
catch (Exception ex)
{
Program.ShowError("Could not insert the map sprite.", ex);
}
Core.ResumeUpdate();
Core.PerformUpdate();
}
public void PlaceSprite(MapSprite ps, Vector3 pos, bool flipX = false)
{
if (ps.Sprite == null)
{
return;
}
if (ps.ValidColors.Count > 0)
{
m_mesh_sprites.Add(ps.Sprite, pos, ps.ValidColors.GetRandom(), flipX);
m_winter_mesh_sprites.Add(ps.WinterSprite, pos, ps.ValidWinterColors.GetRandom(), flipX);
}
else
{
m_mesh_sprites.Add(ps.Sprite, pos, flipX);
m_winter_mesh_sprites.Add(ps.WinterSprite, pos, flipX);
}
}
void Core_LoadImage()
{
try
{
CurrentMapSprite = new MapSprite(CurrentPalette,
Core.ReadData((Pointer)CurrentIdle["Sprite"], 0),
Core.ReadData((Pointer)CurrentMove["Sprite"], 0),
(byte)CurrentIdle["Size"]);
Edit_ImageBox.Load(CurrentMapSprite);
}
catch (Exception ex)
{
Program.ShowError("Could not load the map sprite image.", ex);
Edit_ImageBox.Reset();
Test_ImageBox.Reset();
}
}
public object Clone()
{
Player player = new Player();
player.activePortraitTexture = activePortraitTexture;
player.activePortraitTextureName = activePortraitTextureName;
player.AssetName = AssetName;
player.CharacterClass = CharacterClass;
player.CharacterClassContentName = CharacterClassContentName;
player.CharacterLevel = CharacterLevel;
player.CombatAnimationInterval = CombatAnimationInterval;
player.CombatSprite = CombatSprite.Clone() as AnimatingSprite;
player.Direction = Direction;
player.EquippedEquipment.AddRange(EquippedEquipment);
player.Experience = Experience;
player.gold = gold;
player.inactivePortraitTexture = inactivePortraitTexture;
player.inactivePortraitTextureName = inactivePortraitTextureName;
player.InitialEquipmentContentNames.AddRange(InitialEquipmentContentNames);
player.introductionDialogue = introductionDialogue;
player.Inventory.AddRange(Inventory);
player.joinAcceptedDialogue = joinAcceptedDialogue;
player.joinRejectedDialogue = joinRejectedDialogue;
player.MapIdleAnimationInterval = MapIdleAnimationInterval;
player.MapPosition = MapPosition;
player.MapSprite = MapSprite.Clone() as AnimatingSprite;
player.MapWalkingAnimationInterval = MapWalkingAnimationInterval;
player.Name = Name;
player.ShadowTexture = ShadowTexture;
player.State = State;
player.unselectablePortraitTexture = unselectablePortraitTexture;
player.unselectablePortraitTextureName = unselectablePortraitTextureName;
player.WalkingSprite = WalkingSprite.Clone() as AnimatingSprite;
player.RecalculateEquipmentStatistics();
player.RecalculateTotalDefenseRanges();
player.RecalculateTotalTargetDamageRange();
player.ResetAnimation(false);
player.ResetBaseStatistics();
return(player);
}
void Core_InsertData(string filepath)
{
string idle_path = null;
string move_path = null;
if (filepath.EndsWith("idle.chr", StringComparison.OrdinalIgnoreCase))
{
idle_path = filepath;
move_path = filepath.Substring(0, filepath.Length - 8) + "move.chr";
}
if (filepath.EndsWith("move.chr", StringComparison.OrdinalIgnoreCase))
{
idle_path = filepath.Substring(0, filepath.Length - 8) + "idle.chr";
move_path = filepath;
}
if (idle_path == null || move_path == null)
{
Program.ShowError("Selected file has invalid name.\r\n" +
"Image data files must end with either 'idle.chr' or 'move.chr').");
return;
}
byte[] idle = File.ReadAllBytes(idle_path);
byte[] move = File.ReadAllBytes(move_path);
byte size = 0xFF;
if (idle.Length == Tile.LENGTH * 4 * 3)
{
size = 0x00;
}
else if (idle.Length == Tile.LENGTH * 8 * 3)
{
size = 0x01;
}
else if (idle.Length == Tile.LENGTH * 16 * 3)
{
size = 0x02;
}
MapSprite result = new MapSprite(CurrentPalette, idle, move, size);
Core_Insert(result);
}
public void CreateSpritesInGame(Cell[,] map)
{
var LastX = transform.position.x;
var LastY = transform.position.y;
foreach (Cell cell in map)
{
MapSprite mapSrite = mapSpritesFactory.Create(cell.Render);
mapSrite.name = cell.Render + "_" + cell.Position.X + "_" + cell.Position.Y;
mapSrite.transform.position = new Vector2(LastX + cell.Position.X, LastY - cell.Position.Y);
mapSrite.transform.parent = transform;
mapSrite.Config();
cell.IsTrigger = mapSrite.ColliderIsTrigger();
mapSrite.Cell = cell;
if (cell.Render.Contains("Pacman"))
{
PacmanOfMap pacman = (PacmanOfMap)mapSrite;
pacman.SetInputStrategy(GetComponent <InputStragety>());
}
}
}
private IEnumerable <FogItem> GetSplitItem(MapSprite mapSprite)
{
var yCount = mapSprite.Rectangle.Height / Map.TileHeight;
var xCount = mapSprite.Rectangle.Width / Map.TileWidth;
for (int y = 0; y < yCount; y++)
{
for (int x = 0; x < xCount; x++)
{
var xPos = mapSprite.Rectangle.X + (x * Map.TileWidth);
var yPos = mapSprite.Rectangle.Y + (y * Map.TileHeight);
yield return(new FogItem(_fogTexture)
{
Rectangle = new Rectangle(xPos, yPos, Map.TileWidth, Map.TileHeight),
Colour = mapSprite.MapColour,
Layer = mapSprite.Layer,
});
}
}
}
void Core_InsertImage(string filepath)
{
MapSprite mapsprite;
try
{
GBA.Image image = new GBA.Image(filepath, CurrentPalette);
if (image.Width != MapSprite.W_TILES * 8 || image.Height != MapSprite.H_TILES * 8)
{
throw new Exception("Image given has invalid dimensions. It must be 160x128");
}
mapsprite = new MapSprite(image);
}
catch (Exception ex)
{
Program.ShowError("Could not load the image file.", ex);
return;
}
Core_Insert(mapsprite);
}
public void AddItem(MapSprite mapSprite)
{
var items = GetSplitItem(mapSprite);
foreach (var item in items)
{
if (item.Rectangle.X < 0 || item.Rectangle.X >= _gameModel.ScreenWidth ||
item.Rectangle.Y < 0 || item.Rectangle.Y >= _gameModel.ScreenHeight)
{
continue;
}
bool canAdd = true;
for (int i = 0; i < FogItems.Count; i++)
{
var fItem = FogItems[i];
if (item.Rectangle.X == fItem.Rectangle.X &&
item.Rectangle.Y == fItem.Rectangle.Y)
{
if (item.Layer > fItem.Layer)
{
FogItems.RemoveAt(i);
i--;
}
else
{
canAdd = false;
}
}
}
if (canAdd)
{
FogItems.Add(item);
}
}
}
public MapObject(SpriteId id, Vector3 initialPosition, Vector2 size, bool onFloor, bool backAndForth, SpriteKeyFlags keyFlags = 0)
{
_sprite = AttachChild(new MapSprite(
id,
DrawLayer.Underlay,
keyFlags,
SpriteFlags.FlipVertical |
(onFloor
? SpriteFlags.Floor | SpriteFlags.MidAligned
: SpriteFlags.Billboard))
{
Size = size,
Position = initialPosition,
SelectionCallback = registerHit => { registerHit(this); return(false); }
});
On <SlowClockEvent>(e =>
{
if (_sprite.FrameCount == 1)
{
Exchange.Unsubscribe <SlowClockEvent>(this);
}
_frame += e.Delta;
if (backAndForth && _sprite.FrameCount > 2)
{
int maxFrame = _sprite.FrameCount - 1;
int frame = _frame % (2 * maxFrame) - maxFrame;
_sprite.Frame = Math.Abs(frame);
}
else
{
_sprite.Frame = _frame;
}
});
}
public RightButtonHeldMouseMode()
{
On <InputEvent>(OnInput);
_cursor = AttachChild(new MapSprite((SpriteId)Base.CoreSprite.Select, DrawLayer.MaxLayer, 0, SpriteFlags.LeftAligned));
}
public void SetSprite(MapSprite ms)
{
MapSprite = ms;
SetSeason(GenerationManager.s_generation_manager.Season);
}
public void Update(GameTime gt)
{
MapSprite.UpdateAnimation(gt.ElapsedGameTime.Milliseconds);
}
public Map(DungeonLevel dungeonlevel)
{
MapSprite = new MapSprite();//need to know about the factory
direction = -1;
this.dungeonlevel = dungeonlevel;
}
public void Draw(SpriteBatch spriteBatch)
{
MapSprite.Draw(spriteBatch);
}
public void UpdateMap()
{
rects.Clear();
m_triangles.Clear();
m_uv.Clear();
posList.Clear();
m_vertices.Clear();
offsetList.Clear();
int count = generatePrefabItems.Count;
for (int i = 0; i < count; i++)
{
GameObject.DestroyImmediate(generatePrefabItems[i]);
}
generatePrefabItems.Clear();
for (int i = 0; i < 3; i++)
{
int index = layers.IndexOf((MapEditorSortLayer)i);
if (index != -1)
{
MapLayerItem mapLayerItem = layerItems[index];
count = mapLayerItem.items.Count;
for (int j = 0; j < count; j++)
{
int x = mapLayerItem.posList[j] / 10000;
int y = mapLayerItem.posList[j] % 10000;
if (mapLayerItem.items[j].isPrefab)
{
GameObject go = GameObject.Instantiate(mapLayerItem.items[j].gameObject);
go.transform.position = MapManager.GetPos(x + offsetX, y + offsetY);
generatePrefabItems.Add(go);
}
else
{
List <MapSprite> list = new List <MapSprite>();
if (mapLayerItem.items[j].isNine)
{
list = GetSpriteList(x, y, mapGird);
}
else
{
list = mapLayerItem.items[j].normalList;
}
int random = Random.Range(0, 10000);
MapSprite mapSprite = list.Where(s => random < s.sRate).FirstOrDefault();
rects.Add(mapSprite.sprite.rect);
posList.Add(new Vector2((x + offsetX) * MapManager.textSize + MapManager.textSize / 2.0f, (y + offsetY) * MapManager.textSize + MapManager.textSize / 2.0f));
offsetList.Add(new Vector2(mapSprite.offsetX, mapSprite.offsetY) * MapManager.textSize * 0.05f);
}
}
}
}
if (Application.isPlaying)
{
CombineMesh();
}
else
{
#if UNITY_EDITOR
CombineMeshFromEditor();
#endif
}
}
