public void paste_spr()
{
if (m_copy_spr_ind >= 0 && m_data != null)
{
if (m_sel_ind >= 0)
{
m_data.from_CHR_bank_to_spr8x8(m_copy_spr_ind, utils.tmp_spr8x8_buff);
m_data.from_spr8x8_to_CHR_bank(m_sel_ind, utils.tmp_spr8x8_buff);
MainForm.set_status_msg(String.Format("CHR Bank: Sprite #{0:X2} copied to #{1:X2}", m_copy_spr_ind, m_sel_ind));
update();
dispatch_event_need_gfx_update();
#if DEF_ZX
dispatch_event_CHR_selected();
#else
dispatch_event_data_changed();
#endif
}
else
{
MainForm.message_box("Please, select a CHR!", "Paste CHR", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
int CHRs_optimization(tiles_data _data, bool _check)
{
int deleted_CHRs_cnt = 0;
int CHR_data_sum;
byte[] img_buff = new byte[utils.CONST_SPR8x8_TOTAL_PIXELS_CNT];
int size_offs;
int size = _data.get_first_free_spr8x8_id(false);
for (int CHR_n = 0; CHR_n < size; CHR_n++)
{
if (check_blocks_CHR(CHR_n, _data) == false)
{
CHR_data_sum = _data.spr8x8_sum(CHR_n);
if (CHR_data_sum != 0)
{
++deleted_CHRs_cnt;
}
if (_check == true)
{
continue;
}
// delete useless CHR
{
size_offs = platform_data.get_CHR_bank_max_sprites_cnt() - 1;
for (int i = CHR_n; i < size_offs; i++)
{
_data.from_CHR_bank_to_spr8x8(i + 1, img_buff, 0);
_data.from_spr8x8_to_CHR_bank(i, img_buff);
}
}
// the last CHR is an empty space
{
#if DEF_ZX
for (int i = 0; i < img_buff.Length; i++)
{
img_buff[i] = utils.CONST_ZX_DEFAULT_PAPER_COLOR;
}
#else
Array.Clear(img_buff, 0, utils.CONST_SPR8x8_TOTAL_PIXELS_CNT);
#endif
_data.from_spr8x8_to_CHR_bank(platform_data.get_CHR_bank_max_sprites_cnt() - 1, img_buff);
}
shift_CHRs_data(CHR_n, _data);
--CHR_n;
--size;
}
}
return(deleted_CHRs_cnt);
}
bool check_blocks_CHR(int _CHR_id, tiles_data _data)
{
int i;
int block_n;
uint block_data;
byte[] img_buff = new byte[utils.CONST_SPR8x8_TOTAL_PIXELS_CNT];
_data.from_CHR_bank_to_spr8x8(_CHR_id, img_buff, 0);
// check duplicate(s)
for (int CHR_n = 0; CHR_n < _CHR_id; CHR_n++)
{
_data.from_CHR_bank_to_spr8x8(CHR_n, utils.tmp_spr8x8_buff, 0);
if (System.Linq.Enumerable.SequenceEqual(img_buff, utils.tmp_spr8x8_buff) == true)
{
// remove duplicate(s)
for (block_n = 0; block_n < platform_data.get_max_blocks_UINT_cnt(); block_n += utils.CONST_BLOCK_SIZE)
{
for (i = 0; i < utils.CONST_BLOCK_SIZE; i++)
{
block_data = _data.blocks[block_n + i];
if (_CHR_id == tiles_data.get_block_CHR_id(block_data))
{
_data.blocks[block_n + i] = tiles_data.set_block_CHR_id(CHR_n, block_data);
}
}
}
}
}
for (block_n = 0; block_n < platform_data.get_max_blocks_UINT_cnt(); block_n += utils.CONST_BLOCK_SIZE)
{
for (i = 0; i < utils.CONST_BLOCK_SIZE; i++)
{
if (_CHR_id == tiles_data.get_block_CHR_id(_data.blocks[block_n + i]))
{
return(true);
}
}
}
return(false);
}
public static void update_block_gfx(int _block_id, tiles_data _data, Graphics _gfx, int _img_half_width, int _img_half_height, int _x_offs = 0, int _y_offs = 0, uint _flags = 0)
{
Bitmap bmp;
uint chr_data;
byte flip_flag = 0;
int plt_ind = -1;
#if DEF_ZX
palette16_data zx_plt = get_draw_block_palette_by_draw_block_flags(_flags);
#endif
palette16_data plt16 = null;
for (int j = 0; j < utils.CONST_BLOCK_SIZE; j++)
{
chr_data = _data.blocks[(_block_id << 2) + j];
#if DEF_FLIP_BLOCKS_SPR_BY_FLAGS
flip_flag = tiles_data.get_block_flags_flip(chr_data);
#endif
#if DEF_NES
plt_ind = tiles_data.get_block_flags_palette(chr_data);
#endif
#if DEF_PALETTE16_PER_CHR
plt16 = _data.palettes_arr[tiles_data.get_block_flags_palette(chr_data)];
#if DEF_ZX
plt16 = (zx_plt != null) ? zx_plt:plt16;
#endif
#else
plt16 = _data.palettes_arr[_data.palette_pos];
#endif
_data.from_CHR_bank_to_spr8x8(tiles_data.get_block_CHR_id(chr_data), utils.tmp_spr8x8_buff);
bmp = utils.create_bitmap(utils.tmp_spr8x8_buff, 8, 8, flip_flag, false, plt_ind, plt16);
_gfx.DrawImage(bmp, _x_offs + ((j % 2) * _img_half_width), _y_offs + ((j >> 1) * _img_half_height), _img_half_width, _img_half_height);
bmp.Dispose();
}
}
public byte[] get_CHR(int _bank_ind, int _CHR_ind)
{
tiles_data data = m_data_mngr.get_tiles_data(_bank_ind);
if (data != null)
{
if (_CHR_ind >= 0 && _CHR_ind < platform_data.get_CHR_bank_max_sprites_cnt())
{
byte[] CHR_data = new byte[utils.CONST_SPR8x8_TOTAL_PIXELS_CNT];
data.from_CHR_bank_to_spr8x8(_CHR_ind, CHR_data, 0);
return(CHR_data);
}
else
{
throw new Exception(CONST_PREFIX + "get_CHRs_cnt error! Invalid argument: _CHR_ind!\n");
}
}
return(null);
}
private static void check_matched_blocks(tiles_data _data, float _mfactor)
{
if (_data != null)
{
float match_factor;
int diff_pix_n;
string res = "";
byte[] A_CHR_buff = new byte[utils.CONST_SPR8x8_TOTAL_PIXELS_CNT];
byte[] B_CHR_buff = new byte[utils.CONST_SPR8x8_TOTAL_PIXELS_CNT];
int ff_block_id = _data.get_first_free_block_id(false);
for (int blockA_n = 0; blockA_n < ff_block_id; blockA_n++)
{
for (int blockB_n = blockA_n; blockB_n < ff_block_id; blockB_n++)
{
if (blockA_n != blockB_n)
{
match_factor = 0.0f;
for (int CHR_n = 0; CHR_n < 4; CHR_n++)
{
uint blockA = _data.blocks[(blockA_n << 2) + CHR_n];
uint blockB = _data.blocks[(blockB_n << 2) + CHR_n];
#if !DEF_SMS
if (tiles_data.get_block_flags_palette(blockA) != tiles_data.get_block_flags_palette(blockB))
{
continue;
}
#endif
int A_CHR_id = tiles_data.get_block_CHR_id(blockA);
int B_CHR_id = tiles_data.get_block_CHR_id(blockB);
if (A_CHR_id != B_CHR_id)
{
_data.from_CHR_bank_to_spr8x8(A_CHR_id, A_CHR_buff, 0);
_data.from_CHR_bank_to_spr8x8(B_CHR_id, B_CHR_buff, 0);
diff_pix_n = 0;
for (int pix_n = 0; pix_n < utils.CONST_SPR8x8_TOTAL_PIXELS_CNT; pix_n++)
{
if (A_CHR_buff[pix_n] != B_CHR_buff[pix_n])
{
++diff_pix_n;
}
}
match_factor += 25.0f * (1.0f - (diff_pix_n / ( float )utils.CONST_SPR8x8_TOTAL_PIXELS_CNT));
}
else
{
match_factor += 25.0f;
}
}
if (match_factor >= _mfactor)
{
res += utils.hex("#", blockA_n) + " <-> " + utils.hex("#", blockB_n) + " [" + ( int )match_factor + "%]\n";
}
}
}
}
if (res.Length > 0)
{
MainForm.message_box(res, "Matched Blocks", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
MainForm.message_box("No matches found!", "Matched Blocks", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
}
public void shift_colors(bool _shift_transp)
{
if (m_data != null)
{
m_CHR_ids.Clear();
if (edit_mode == EMode.bem_CHR_select)
{
m_CHR_ids.Add(tiles_data.get_block_CHR_id(m_data.blocks[(m_sel_block_id << 2) + m_sel_quad_ind]));
}
else
{
int CHR_id;
for (int quad_n = 0; quad_n < utils.CONST_BLOCK_SIZE; quad_n++)
{
CHR_id = tiles_data.get_block_CHR_id(m_data.blocks[(m_sel_block_id << 2) + quad_n]);
if (!m_CHR_ids.Contains(CHR_id))
{
m_CHR_ids.Add(CHR_id);
}
}
}
int CHR_n;
int pix_n;
int size = m_CHR_ids.Count;
byte clr_ind;
++clr_ind_remap_arr_pos;
clr_ind_remap_arr_pos %= _shift_transp ? (clr_ind_remap_transp_arr.Length >> 2):(clr_ind_remap_arr.Length >> 2);
byte[] remap_arr = _shift_transp ? clr_ind_remap_transp_arr:clr_ind_remap_arr;
int start_clr_ind = clr_ind_remap_arr_pos << 2;
for (CHR_n = 0; CHR_n < size; CHR_n++)
{
m_data.from_CHR_bank_to_spr8x8(m_CHR_ids[CHR_n], utils.tmp_spr8x8_buff, 0);
for (pix_n = 0; pix_n < utils.CONST_SPR8x8_TOTAL_PIXELS_CNT; pix_n++)
{
clr_ind = utils.tmp_spr8x8_buff[pix_n];
clr_ind = remap_arr[start_clr_ind + clr_ind];
utils.tmp_spr8x8_buff[pix_n] = clr_ind;
}
m_data.from_spr8x8_to_CHR_bank(m_CHR_ids[CHR_n], utils.tmp_spr8x8_buff);
}
dispatch_event_pixel_changed();
dispatch_event_data_changed();
dispatch_event_need_gfx_update();
update();
}
}
void BtnOkClick_Event(object sender, EventArgs e)
{
if (m_color_A >= 0 && m_color_B >= 0)
{
#if DEF_PALETTE16_PER_CHR
int pix_n;
int CHR_id;
int CHR_n;
int block_n;
bool[] CHR_flags = new bool[platform_data.get_CHR_bank_max_sprites_cnt()];
Array.Clear(CHR_flags, 0, CHR_flags.Length);
uint block_data;
int ff_block_n = m_tiles_data.get_first_free_block_id(false);
for (block_n = 0; block_n < ff_block_n; block_n++)
{
for (CHR_n = 0; CHR_n < utils.CONST_BLOCK_SIZE; CHR_n++)
{
block_data = m_tiles_data.blocks[(block_n << 2) + CHR_n];
CHR_id = tiles_data.get_block_CHR_id(block_data);
if (CHR_flags[CHR_id] == false && (tiles_data.get_block_flags_palette(block_data) == m_tiles_data.palette_pos))
{
m_tiles_data.from_CHR_bank_to_spr8x8(CHR_id, utils.tmp_spr8x8_buff, 0);
for (pix_n = 0; pix_n < utils.CONST_SPR8x8_TOTAL_PIXELS_CNT; pix_n++)
{
if (utils.tmp_spr8x8_buff[pix_n] == m_color_A)
{
utils.tmp_spr8x8_buff[pix_n] = ( byte )m_color_B;
}
else
if (utils.tmp_spr8x8_buff[pix_n] == m_color_B)
{
utils.tmp_spr8x8_buff[pix_n] = ( byte )m_color_A;
}
}
m_tiles_data.from_spr8x8_to_CHR_bank(CHR_id, utils.tmp_spr8x8_buff);
CHR_flags[CHR_id] = true;
}
}
}
#else
for (int i = 0; i < m_tiles_data.CHR_bank.Length; i++)
{
if (m_tiles_data.CHR_bank[i] == m_color_A)
{
m_tiles_data.CHR_bank[i] = ( byte )m_color_B;
}
else
if (m_tiles_data.CHR_bank[i] == m_color_B)
{
m_tiles_data.CHR_bank[i] = ( byte )m_color_A;
}
}
#endif
int ind_A = m_tiles_data.subpalettes[m_color_A >> 2][m_color_A & 0x03];
int ind_B = m_tiles_data.subpalettes[m_color_B >> 2][m_color_B & 0x03];
m_tiles_data.subpalettes[m_color_A >> 2][m_color_A & 0x03] = ind_B;
m_tiles_data.subpalettes[m_color_B >> 2][m_color_B & 0x03] = ind_A;
for (int j = 0; j < utils.CONST_NUM_SMALL_PALETTES; j++)
{
palette_group.Instance.get_palettes_arr()[j].update();
}
}
else
{
MainForm.message_box("Please, select both Color A and Color B!", "Colors Swapping Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
