private void validate_screens(data_sets_manager.EScreenDataType _scr_type,
tiles_data _data)
{
int scr_n;
int tile_n;
ushort tile_val;
screen_data scr;
int blocks_cnt = _data.blocks.Length >> 2;
for (scr_n = 0; scr_n < _data.screen_data_cnt(); scr_n++)
{
scr = _data.get_screen_data(scr_n);
for (tile_n = 0; tile_n < scr.m_arr.Length; tile_n++)
{
tile_val = scr.m_arr[tile_n];
if (_scr_type == data_sets_manager.EScreenDataType.sdt_Tiles4x4)
{
if (tile_val >= _data.tiles.Length)
{
scr.m_arr[tile_n] = 0;
}
}
else
{
if (tile_val >= blocks_cnt)
{
scr.m_arr[tile_n] = 0;
}
}
}
}
}
public void set_screen_data_type(data_sets_manager.EScreenDataType _type)
{
m_screen_data_type = _type;
reset_active_pattern();
reset_state();
}
public virtual void load_screens(BinaryReader _br,
project_data_desc _prj_data,
data_sets_manager.EScreenDataType _scr_type,
tiles_data _data)
{
int prj_scr_tiles_width = (_prj_data.m_scr_blocks_width == 0xff) ? platform_data.get_screen_tiles_width_by_file_ext_uni(_prj_data.m_file_ext, _scr_type, true):(_scr_type == data_sets_manager.EScreenDataType.sdt_Tiles4x4 ? ((_prj_data.m_scr_blocks_width + 1) >> 1):_prj_data.m_scr_blocks_width);
int prj_scr_tiles_height = (_prj_data.m_scr_blocks_height == 0xff) ? platform_data.get_screen_tiles_height_by_file_ext_uni(_prj_data.m_file_ext, _scr_type, true):(_scr_type == data_sets_manager.EScreenDataType.sdt_Tiles4x4 ? ((_prj_data.m_scr_blocks_height + 1) >> 1):_prj_data.m_scr_blocks_height);
load_screens(_br, _prj_data.m_ver, _scr_type, _prj_data.m_scr_align, prj_scr_tiles_width, prj_scr_tiles_height, _data);
}
public static int get_screen_tiles_cnt_uni(data_sets_manager.EScreenDataType _type)
{
if (_type == data_sets_manager.EScreenDataType.sdt_Tiles4x4)
{
return(get_screen_tiles_cnt(get_platform_type()));
}
else
{
return(get_screen_blocks_cnt(get_platform_type()));
}
}
// MISC
public static int get_screen_tiles_size_uni(data_sets_manager.EScreenDataType _type)
{
if (_type == data_sets_manager.EScreenDataType.sdt_Tiles4x4)
{
return(utils.CONST_SCREEN_TILES_SIZE);
}
else
{
return(utils.CONST_SCREEN_BLOCKS_SIZE);
}
}
public static screen_editor.EFillMode get_screen_fill_mode_uni(data_sets_manager.EScreenDataType _type)
{
if (_type == data_sets_manager.EScreenDataType.sdt_Tiles4x4)
{
return(screen_editor.EFillMode.efm_Tile);
}
else
{
return(screen_editor.EFillMode.efm_Block);
}
}
public void update_screens(List <tiles_data> _tiles_data, data_sets_manager.EScreenDataType _scr_type, bool _update_images, utils.ETileViewType _view_type, int _bank_id = -1)
{
m_listview_screens.BeginUpdate();
m_listview_screens.Items.Clear();
tiles_data data;
ListViewItem lst;
int img_ind;
int screens_cnt;
int screens_ind = 0;
int banks_cnt = _tiles_data.Count;
for (int bank_n = 0; bank_n < banks_cnt; bank_n++)
{
data = _tiles_data[bank_n];
screens_cnt = data.screen_data_cnt();
if ((_bank_id >= 0 && _bank_id == bank_n) || _bank_id < 0)
{
palette_group.Instance.set_palette(data);
for (int screen_n = 0; screen_n < screens_cnt; screen_n++)
{
img_ind = screens_ind + screen_n;
if (_update_images)
{
m_scr_list.get(img_ind).Dispose();
m_scr_list.replace(img_ind, create_screen_image(screen_n, data, _scr_type, _view_type));
}
lst = new ListViewItem();
lst.Name = lst.Text = utils.get_screen_id_str(bank_n, screen_n);
lst.ImageIndex = img_ind;
m_listview_screens.Items.Add(lst);
}
}
screens_ind += screens_cnt;
}
m_listview_screens.EndUpdate();
}
public void update_all_screens(List <tiles_data> _tiles_data, data_sets_manager.EScreenDataType _scr_type, utils.ETileViewType _view_type)
{
m_listview_screens.BeginUpdate();
// clear items
{
m_scr_list.clear();
m_listview_screens.Items.Clear();
}
tiles_data data;
ListViewItem lst;
int screens_cnt;
int img_ind = 0;
int banks_cnt = _tiles_data.Count;
for (int bank_n = 0; bank_n < banks_cnt; bank_n++)
{
data = _tiles_data[bank_n];
palette_group.Instance.set_palette(data);
screens_cnt = data.screen_data_cnt();
for (int screen_n = 0; screen_n < screens_cnt; screen_n++)
{
m_scr_list.add(create_screen_image(screen_n, data, _scr_type, _view_type));
lst = new ListViewItem();
lst.Name = lst.Text = utils.get_screen_id_str(bank_n, screen_n);
lst.ImageIndex = img_ind;
++img_ind;
m_listview_screens.Items.Add(lst);
}
}
m_listview_screens.EndUpdate();
}
public void load(BinaryReader _br,
byte _ver,
Func <string, entity_data> _get_ent,
data_sets_manager.EScreenDataType _scr_type)
{
string base_ent_name;
base_ent_name = _br.ReadString();
base_entity = _get_ent(base_ent_name);
if (base_entity == null)
{
throw new Exception("Can't find base entity: " + base_ent_name + "\n\nEntity instance loading error!");
}
properties = _br.ReadString();
x = _br.ReadInt32();
y = _br.ReadInt32();
m_uid = _br.ReadInt32();
target_uid = _br.ReadInt32();
{
int CHRs_in_tile = (_scr_type == data_sets_manager.EScreenDataType.sdt_Tiles4x4) ? 32:16;
Rectangle prj_scr_rect = project_data_converter_provider.get_converter().get_prj_scr_rect();
y += prj_scr_rect.Y * CHRs_in_tile;
x += prj_scr_rect.X * CHRs_in_tile;
y = y < 0 ? 0:y;
y = (y >= platform_data.get_screen_height_pixels()) ? (platform_data.get_screen_height_pixels() - 1):y;
x = x < 0 ? 0:x;
x = (x >= platform_data.get_screen_width_pixels()) ? (platform_data.get_screen_width_pixels() - 1):x;
}
// extra data ( reserved for future purposes )
int extra_data_size = _br.ReadInt32();
}
public void set_screen_data_type(data_sets_manager.EScreenDataType _type)
{
PanelPaletteTiles.Enabled = (_type == data_sets_manager.EScreenDataType.sdt_Tiles4x4);
reset();
}
public void load(BinaryReader _br, byte _ver, Func <string, entity_data> _get_ent, data_sets_manager.EScreenDataType _scr_type)
{
int i;
int j;
m_start_scr_ind = _br.ReadInt32();
int width = _br.ReadInt32();
int height = _br.ReadInt32();
m_layout.Clear();
for (i = 0; i < height; i++)
{
m_layout.Add(allocate_row(width));
}
for (i = 0; i < height; i++)
{
for (j = 0; j < width; j++)
{
m_layout[i][j].load(_br, _ver, _get_ent, _scr_type);
}
}
}
public void set_screen_data_type(data_sets_manager.EScreenDataType _type)
{
CheckBoxOptimizeTiles.Enabled = (_type == data_sets_manager.EScreenDataType.sdt_Tiles4x4);
CheckBoxOptimizeTiles.Checked = (_type == data_sets_manager.EScreenDataType.sdt_Blocks2x2) ? false:CheckBoxOptimizeTiles.Checked;
}
protected void load_screens(BinaryReader _br,
byte _ver,
data_sets_manager.EScreenDataType _scr_type,
data_conversion_options_form.EScreensAlignMode _scr_align_mode,
int _prj_scr_tiles_width,
int _prj_scr_tiles_height,
tiles_data _data)
{
screen_data scr;
int tile_x;
int tile_y;
int tile_y_offset;
int scr_data_len = platform_data.get_screen_tiles_cnt_uni(_scr_type);
int native_scr_tiles_width = platform_data.get_screen_tiles_width_uni(_scr_type);
int native_scr_tiles_height = platform_data.get_screen_tiles_height_uni(_scr_type);
m_native_scr_rect.X = 0;
m_native_scr_rect.Y = 0;
m_native_scr_rect.Width = native_scr_tiles_width;
m_native_scr_rect.Height = native_scr_tiles_height;
m_prj_scr_rect.X = 0;
m_prj_scr_rect.Y = 0;
m_prj_scr_rect.Width = _prj_scr_tiles_width;
m_prj_scr_rect.Height = _prj_scr_tiles_height;
// calc aligned prj screen pos
{
int scr_align_data = ( int )_scr_align_mode;
if ((scr_align_data & data_conversion_options_form.CONST_ALIGN_X_MID) != 0)
{
m_prj_scr_rect.X = (m_native_scr_rect.Width >> 1) - (_prj_scr_tiles_width >> 1);
}
else
if ((scr_align_data & data_conversion_options_form.CONST_ALIGN_X_RIGHT) != 0)
{
m_prj_scr_rect.X = m_native_scr_rect.Width - m_prj_scr_rect.Width;
}
if ((scr_align_data & data_conversion_options_form.CONST_ALIGN_Y_MID) != 0)
{
m_prj_scr_rect.Y = (m_native_scr_rect.Height >> 1) - (_prj_scr_tiles_height >> 1);
}
else
if ((scr_align_data & data_conversion_options_form.CONST_ALIGN_Y_BOTTOM) != 0)
{
m_prj_scr_rect.Y = m_native_scr_rect.Height - m_prj_scr_rect.Height;
}
}
bool native_scr_data = ((native_scr_tiles_width == _prj_scr_tiles_width) && (native_scr_tiles_height == _prj_scr_tiles_height));
int scr_cnt = _br.ReadInt32();
Action <int> skip_tiles = tiles_cnt => { if (_ver < 5)
{
_br.ReadBytes(tiles_cnt);
}
else
{
_br.ReadBytes(tiles_cnt << 1);
} };
for (int i = 0; i < scr_cnt; i++)
{
scr = _data.create_screen(_scr_type);
if (native_scr_data)
{
scr.load(_br, _ver, scr_data_len, -1);
}
else
{
for (tile_y = m_prj_scr_rect.Y; tile_y < (m_prj_scr_rect.Y + m_prj_scr_rect.Height); tile_y++)
{
if (tile_y < 0 || tile_y >= native_scr_tiles_height)
{
skip_tiles(_prj_scr_tiles_width);
continue;
}
tile_y_offset = native_scr_tiles_width * tile_y;
for (tile_x = m_prj_scr_rect.X; tile_x < (m_prj_scr_rect.X + m_prj_scr_rect.Width); tile_x++)
{
if (tile_x < 0 || tile_x >= native_scr_tiles_width)
{
skip_tiles(1);
}
else
{
scr.load(_br, _ver, 1, tile_y_offset + tile_x);
}
}
}
}
}
validate_screens(_scr_type, _data);
}
public void update_tiles(utils.ETileViewType _view_type, tiles_data _tiles_data, data_sets_manager.EScreenDataType _scr_type)
{
Image img;
Graphics gfx;
if (_scr_type == data_sets_manager.EScreenDataType.sdt_Tiles4x4)
{
for (int i = 0; i < platform_data.get_max_tiles_cnt(); i++)
{
img = m_imagelist_tiles.Images[i];
gfx = Graphics.FromImage(img);
if (_tiles_data != null)
{
update_tile(i, _view_type, _tiles_data, gfx, img, _scr_type);
}
else
{
gfx.Clear(utils.CONST_COLOR_TILE_CLEAR);
}
m_imagelist_tiles.Images[i] = img;
gfx.Dispose();
}
m_panel_tiles.Refresh();
}
}
public screen_data(data_sets_manager.EScreenDataType _type)
{
alloc(platform_data.get_screen_tiles_width_uni(_type), platform_data.get_screen_tiles_height_uni(_type));
}
public static int get_screen_tiles_height_by_platform_type_uni(EPlatformType _platform_type, data_sets_manager.EScreenDataType _type, bool _native = false)
{
if (_type == data_sets_manager.EScreenDataType.sdt_Tiles4x4)
{
return(get_screen_tiles_height(_platform_type, _native));
}
else
{
return(get_screen_blocks_height(_platform_type, _native));
}
}
public void update_tile(int _tile_ind, utils.ETileViewType _view_type, tiles_data _tiles_data, Graphics _gfx, Image _img, data_sets_manager.EScreenDataType _scr_type)
{
#if DEF_TILE_DRAW_FAST
Image block_img;
#else
ushort[] blocks_arr = null;
byte[] CHR_data = null;
// draw a block from CHR bank sprites
if (_tiles_data != null)
{
blocks_arr = _tiles_data.blocks;
CHR_data = _tiles_data.CHR_bank;
}
#endif //DEF_TILE_DRAW_FAST
Image img;
if (_img != null)
{
img = _img;
}
else
{
img = m_imagelist_tiles.Images[_tile_ind];
}
Graphics gfx;
if (_gfx != null)
{
gfx = _gfx;
}
else
{
gfx = Graphics.FromImage(img);
}
gfx.InterpolationMode = InterpolationMode.NearestNeighbor;
gfx.PixelOffsetMode = PixelOffsetMode.None;
#if DEF_TILE_DRAW_FAST
for (int j = 0; j < utils.CONST_TILE_SIZE; j++)
{
block_img = m_imagelist_blocks.Images[_tiles_data.get_tile_block(_tile_ind, j)];
gfx.DrawImage(block_img, ((j % 2) << 5), ((j >> 1) << 5), block_img.Width, block_img.Height);
}
#else
// draw a block from CHR bank sprites
for (int j = 0; j < utils.CONST_TILE_SIZE; j++)
{
utils.update_block_gfx(_tiles_data.get_tile_block(_tile_ind, j), blocks_arr, CHR_data, gfx, utils.CONST_BLOCKS_IMG_SIZE >> 1, utils.CONST_BLOCKS_IMG_SIZE >> 1, ((j % 2) << 5), ((j >> 1) << 5));
}
#endif //DEF_TILE_DRAW_FAST
if (_scr_type == data_sets_manager.EScreenDataType.sdt_Tiles4x4)
{
if (_view_type == utils.ETileViewType.tvt_Number) // tile id
{
draw_tile_info(String.Format("{0:X2}", _tile_ind), gfx);
}
else
if (_view_type == utils.ETileViewType.tvt_TilesUsage) // usage
{
draw_tile_info(String.Format("{0}", _tiles_data.get_tile_usage(( ushort )_tile_ind, _scr_type)), gfx);
}
}
if (_img == null)
{
m_imagelist_tiles.Images[_tile_ind] = img;
}
if (_gfx == null)
{
gfx.Dispose();
}
}
// SCREEN HEIGHT TILES \ BLOCKS
public static int get_screen_tiles_height_uni(data_sets_manager.EScreenDataType _scr_type)
{
return(get_screen_tiles_height_by_platform_type_uni(get_platform_type(), _scr_type));
}
public static int get_screen_tiles_height_by_file_ext_uni(string _file_ext, data_sets_manager.EScreenDataType _scr_type, bool _native = false)
{
return(get_screen_tiles_height_by_platform_type_uni(get_platform_type_by_file_ext(_file_ext), _scr_type, _native));
}
public void update_blocks(utils.ETileViewType _view_type, tiles_data _tiles_data, bool _prop_per_block, data_sets_manager.EScreenDataType _scr_type)
{
Image img;
Graphics gfx;
m_block_rect.Width = m_block_rect.Height = (_view_type == utils.ETileViewType.tvt_ObjectId && !_prop_per_block) ? (utils.CONST_BLOCKS_IMG_SIZE >> 1):utils.CONST_BLOCKS_IMG_SIZE;
for (int i = 0; i < platform_data.get_max_blocks_cnt(); i++)
{
img = m_imagelist_blocks.Images[i];
gfx = Graphics.FromImage(img);
if (_tiles_data != null)
{
update_block(i, _view_type, _tiles_data, _prop_per_block, gfx, img, _scr_type);
}
else
{
gfx.Clear(utils.CONST_COLOR_BLOCK_CLEAR);
}
m_imagelist_blocks.Images[i] = img;
gfx.Dispose();
}
m_panel_blocks.Refresh();
}
public void load(BinaryReader _br, byte _ver, Func <string, entity_data> _get_ent, data_sets_manager.EScreenDataType _scr_type)
{
m_marks = _br.ReadUInt16();
m_scr_ind = _br.ReadByte();
int ents_cnt = _br.ReadInt32();
entity_instance ent_inst;
for (int ent_n = 0; ent_n < ents_cnt; ent_n++)
{
ent_inst = new entity_instance();
ent_inst.load(_br, _ver, _get_ent, _scr_type);
m_ents.Add(ent_inst);
}
}
public void insert_screen(bool _all_banks_list, int _CHR_bank_ind, int _scr_local_ind, int _scr_global_ind, List <tiles_data> _tiles_data, data_sets_manager.EScreenDataType _scr_type, utils.ETileViewType _view_type)
{
int i;
int size;
m_listview_screens.BeginUpdate();
Bitmap bmp = create_screen_image(_scr_local_ind, _tiles_data[_CHR_bank_ind], _scr_type, _view_type);
if (_scr_global_ind == m_scr_list.count())
{
// add image
m_scr_list.add(bmp);
}
else
{
// insert image
m_scr_list.add(bmp);
size = m_scr_list.count();
for (i = size - 1; i > _scr_global_ind; i--)
{
m_scr_list.replace(i, m_scr_list.get(i - 1));
}
m_scr_list.replace(_scr_global_ind, bmp);
}
ListViewItem lst = new ListViewItem();
lst.Name = lst.Text = utils.get_screen_id_str(_CHR_bank_ind, _scr_local_ind);
lst.ImageIndex = _scr_global_ind;
int insert_ind = _all_banks_list ? _scr_global_ind:_scr_local_ind;
m_listview_screens.Items.Insert(insert_ind, lst);
size = m_listview_screens.Items.Count;
for (i = insert_ind + 1; i < size; i++)
{
lst = m_listview_screens.Items[i];
++lst.ImageIndex;
}
m_listview_screens.EndUpdate();
}
private Bitmap create_screen_image(int _screen_n, tiles_data _data, data_sets_manager.EScreenDataType _scr_type, utils.ETileViewType _view_type)
{
#if DEF_SCREEN_DRAW_FAST
Image block_img;
#endif
int tile_n;
int block_n;
ushort tile_id;
int tile_offs_x;
int tile_offs_y;
palette_group.Instance.set_palette(_data);
Bitmap bmp = new Bitmap(platform_data.get_screen_width_pixels(), platform_data.get_screen_height_pixels(), PixelFormat.Format32bppPArgb);
Graphics gfx = Graphics.FromImage(bmp);
gfx.InterpolationMode = InterpolationMode.NearestNeighbor;
gfx.PixelOffsetMode = PixelOffsetMode.None;
gfx.Clear(utils.CONST_COLOR_SCREEN_CLEAR);
if (_scr_type == data_sets_manager.EScreenDataType.sdt_Tiles4x4)
{
for (tile_n = 0; tile_n < platform_data.get_screen_tiles_cnt(); tile_n++)
{
tile_id = _data.get_screen_tile(_screen_n, tile_n);
tile_offs_x = (tile_n % platform_data.get_screen_tiles_width()) << 5;
tile_offs_y = (tile_n / platform_data.get_screen_tiles_width()) << 5;
for (block_n = 0; block_n < utils.CONST_BLOCK_SIZE; block_n++)
{
#if DEF_SCREEN_DRAW_FAST
block_img = m_imagelist_blocks.Images[_data.get_tile_block(tile_id, block_n)];
gfx.DrawImage(block_img, ((block_n % 2) << 4) + tile_offs_x, ((block_n >> 1) << 4) + tile_offs_y, block_img.Width >> 1, block_img.Height >> 1);
#else
#if DEF_ZX
utils.update_block_gfx(_data.get_tile_block(tile_id, block_n), _data, gfx, 8, 8, ((block_n % 2) << 4) + tile_offs_x, ((block_n >> 1) << 4) + tile_offs_y, utils.get_draw_block_flags_by_view_type(_view_type));
#else
utils.update_block_gfx(_data.get_tile_block(tile_id, block_n), _data, gfx, 8, 8, ((block_n % 2) << 4) + tile_offs_x, ((block_n >> 1) << 4) + tile_offs_y);
#endif
#endif
}
}
}
else
{
for (tile_n = 0; tile_n < platform_data.get_screen_blocks_cnt(); tile_n++)
{
#if DEF_SCREEN_DRAW_FAST
block_img = m_imagelist_blocks.Images[_data.get_screen_tile(_screen_n, tile_n)];
gfx.DrawImage(block_img, ((tile_n % platform_data.get_screen_blocks_width()) << 4), ((tile_n / platform_data.get_screen_blocks_width()) << 4), block_img.Width >> 1, block_img.Height >> 1);
#else
#if DEF_ZX
utils.update_block_gfx(_data.get_screen_tile(_screen_n, tile_n), _data, gfx, 8, 8, ((tile_n % platform_data.get_screen_blocks_width()) << 4), ((tile_n / platform_data.get_screen_blocks_width()) << 4), utils.get_draw_block_flags_by_view_type(_view_type));
#else
utils.update_block_gfx(_data.get_screen_tile(_screen_n, tile_n), _data, gfx, 8, 8, ((tile_n % platform_data.get_screen_blocks_width()) << 4), ((tile_n / platform_data.get_screen_blocks_width()) << 4));
#endif
#endif
}
}
return(bmp);
}
public void update_block(int _block_ind, utils.ETileViewType _view_type, tiles_data _tiles_data, bool _prop_per_block, Graphics _gfx, Image _img, data_sets_manager.EScreenDataType _scr_type)
{
int obj_id;
Image img;
if (_img != null)
{
img = _img;
}
else
{
img = m_imagelist_blocks.Images[_block_ind];
}
Graphics gfx;
if (_gfx != null)
{
gfx = _gfx;
}
else
{
gfx = Graphics.FromImage(img);
}
gfx.InterpolationMode = InterpolationMode.NearestNeighbor;
gfx.PixelOffsetMode = PixelOffsetMode.Half;
#if DEF_ZX
utils.update_block_gfx(_block_ind, _tiles_data, gfx, img.Width >> 1, img.Height >> 1, 0, 0, utils.get_draw_block_flags_by_view_type(_view_type));
#else
utils.update_block_gfx(_block_ind, _tiles_data, gfx, img.Width >> 1, img.Height >> 1);
#endif
if (_view_type == utils.ETileViewType.tvt_ObjectId) // obj id
{
if (_prop_per_block)
{
obj_id = tiles_data.get_block_flags_obj_id(_tiles_data.blocks[_block_ind << 2]);
utils.brush.Color = Color.FromArgb((CONST_ALPHA << 24) | m_clrs_arr[obj_id]);
draw_block_info(String.Format("{0}", obj_id), gfx);
}
else
{
for (int chr_n = 0; chr_n < utils.CONST_BLOCK_SIZE; chr_n++)
{
obj_id = tiles_data.get_block_flags_obj_id(_tiles_data.blocks[(_block_ind << 2) + chr_n]);
utils.brush.Color = Color.FromArgb((CONST_ALPHA << 24) | m_clrs_arr[obj_id]);
m_block_rect.X = ((chr_n & 0x01) == 0x01) ? m_block_rect.Width:0;
m_block_rect.Y = ((chr_n & 0x02) == 0x02) ? m_block_rect.Height:0;
gfx.FillRectangle(utils.brush, m_block_rect);
}
}
}
else
if (_view_type == utils.ETileViewType.tvt_BlocksUsage) // usage
{
utils.brush.Color = Color.FromArgb((CONST_ALPHA << 24) | 0x00ffffff);
draw_block_info(String.Format("{0}", _tiles_data.get_block_usage(( ushort )_block_ind, _scr_type)), gfx);
}
else
if (_scr_type == data_sets_manager.EScreenDataType.sdt_Blocks2x2)
{
if (_view_type == utils.ETileViewType.tvt_Number) // block id
{
utils.brush.Color = Color.FromArgb((CONST_ALPHA << 24) | 0x00ffffff);
draw_block_info(String.Format("{0:X2}", _block_ind), gfx);
}
}
if (_img == null)
{
m_imagelist_blocks.Images[_block_ind] = img;
}
if (_gfx == null)
{
gfx.Dispose();
}
}
