public void Release()
{
normal = null;
normal_f = null;
attack = null;
attack_f = null;
}
draw_combat_icon(int iconIndex, Icon iconState, int direction, int tileY, int tileX) /* sub_76504 */
{
DaxBlock icon = gbl.combat_icons[iconIndex].GetIcon(iconState, direction);
if (icon != null)
{
seg040.draw_combat_picture(icon, (tileY * 3) + 1, (tileX * 3) + 1, 0);
}
}
public void LoadIcons(int maskColor, int masked, string file_text, int normal_id, int attack_id)
{
normal = LoadIconHelper(maskColor, masked, normal_id, file_text);
normal_f = LoadIconHelper(maskColor, masked, normal_id, file_text);
normal_f.FlipIconLeftToRight();
attack = LoadIconHelper(maskColor, masked, attack_id, file_text);
attack_f = LoadIconHelper(maskColor, masked, attack_id, file_text);
attack_f.FlipIconLeftToRight();
}
public void LoadIcons(int maskColor, bool shouldMask, string file_text, int normal_id, int attack_id)
{
normal = LoadIconHelper(maskColor, shouldMask, normal_id, file_text);
normal_f = LoadIconHelper(maskColor, shouldMask, normal_id, file_text);
normal_f.FlipIconLeftToRight();
attack = LoadIconHelper(maskColor, shouldMask, attack_id, file_text);
attack_f = LoadIconHelper(maskColor, shouldMask, attack_id, file_text);
attack_f.FlipIconLeftToRight();
}
internal static void Show3DSprite(DaxArray arg_0, int sprite_index)
{
if (sprite_index < 1 || sprite_index > 3)
{
Logger.LogAndExit("Illegal range in Show3DSprite. {0}", sprite_index);
}
if (arg_0.frames[sprite_index - 1].picture != null)
{
DaxBlock block = arg_0.frames[sprite_index - 1].picture;
seg040.OverlayBounded(arg_0.frames[sprite_index - 1].picture, 1, 0, block.y_pos + 3 - 1, block.x_pos + 3 - 1);
seg040.DrawOverlay();
}
}
internal static void Put8x8Symbol(byte arg_0, bool use_overlay, int symbol_id, int rowY, int colX)
{
byte symbol_set = 0; /*HACK to make compiler happy*/
if (symbol_id >= 1 && symbol_id <= 0x2d)
{
symbol_set = 0;
}
else if (symbol_id >= 0x2E && symbol_id <= 0x73)
{
symbol_set = 1;
}
else if (symbol_id >= 0x74 && symbol_id <= 0x0B9)
{
symbol_set = 2;
}
else if (symbol_id >= 0x0BA && symbol_id <= 0x0FF)
{
symbol_set = 3;
}
else if (symbol_id >= 0x100 && symbol_id <= 0x127)
{
symbol_set = 4;
}
else if (symbol_id == 0 || (symbol_id >= 0x128 && symbol_id <= 0x7FFF))
{
throw new System.ApplicationException("Bad symbol number in Put8x8Symbol." + symbol_id);
}
if (gbl.symbol_8x8_set[symbol_set] != null)
{
symbol_id -= gbl.symbol_set_fix[symbol_set];
if (use_overlay)
{
seg040.OverlayUnbounded(gbl.symbol_8x8_set[symbol_set], arg_0, symbol_id, rowY, colX);
}
else
{
DaxBlock var_6 = gbl.symbol_8x8_set[symbol_set];
int offset = symbol_id * var_6.bpp;
System.Array.Copy(var_6.data, offset, gbl.cursor_bkup.data, 0, var_6.bpp);
seg040.draw_picture(gbl.cursor_bkup, rowY, colX, 0);
}
}
}
internal static void Load24x24Set(int cellCount, int destCellOffset, int block_id, string fileName)
{
if (destCellOffset > 0x30)
{
Logger.LogAndExit("Start range error in Load24x24Set. {0}", destCellOffset);
}
DaxBlock tmp_block = seg040.LoadDax(0, false, block_id, fileName);
int dateLength = cellCount * tmp_block.Bpp;
int destByteOffset = destCellOffset * tmp_block.Bpp;
if (gbl.dax24x24Set != null)
{
System.Array.Copy(tmp_block.ImageData, 0, gbl.dax24x24Set.ImageData, destByteOffset, dateLength);
}
seg043.clear_keyboard();
}
internal static void draw_clipped_picture(DaxBlock dax_block, int rowY, int colX, int index,
int clipMinX, int clipMaxX, int clipMinY, int clipMaxY)
{
if (dax_block != null)
{
int offset = index * dax_block.Bpp;
int minY = rowY * 8;
int maxY = minY + dax_block.Height;
int minX = colX * 8;
int maxX = minX + (dax_block.Width * 8);
for (int pixY = minY; pixY < maxY; pixY++)
{
for (int pixX = minX; pixX < maxX; pixX++)
{
if (pixX >= clipMinX && pixX < clipMaxX &&
pixY >= clipMinY && pixY < clipMaxY)
{
byte color = dax_block.ImageData[offset];
if (color == color_no_draw)
{
}
else if (color == color_re_color_from)
{
Display.SetPixel3(pixX, pixY, color_re_color_to);
}
else
{
Display.SetPixel3(pixX, pixY, color);
}
}
offset++;
}
}
Display.Update();
}
}
internal static void DrawMaybeOverlayed(DaxBlock dax_block, bool useOverlay, int rowY, int colX) // sub_7000A
{
if (dax_block != null)
{
if (gbl.area_ptr.picture_fade > 0 || useOverlay == true)
{
if (gbl.area_ptr.picture_fade > 0)
{
dax_block.Recolor(true, fadeNewColors, fadeOldColors);
}
seg040.OverlayBounded(dax_block, 0, 0, rowY - 1, colX - 1);
seg040.DrawOverlay();
}
else
{
seg040.draw_picture(dax_block, rowY, colX, 0);
}
}
}
internal static void load_missile_dax(bool flipIcon, byte iconOffset, Icon iconAction, int iconIdx) /* sub_67924 */
{
int dataSize = gbl.missile_dax.bpp;
if (flipIcon == true)
{
gbl.combat_icons[iconIdx].GetIcon(iconAction, 0).FlipIconLeftToRight();
}
else
{
DaxBlock src = gbl.combat_icons[iconIdx].GetIcon(iconAction, 0);
if (src != null)
{
System.Array.Copy(src.data, 0, gbl.missile_dax.data, iconOffset * dataSize, dataSize);
}
else
{
System.Array.Clear(gbl.missile_dax.data, iconOffset * dataSize, dataSize);
}
}
}
internal static void ega_backup(DaxBlock dax_block, int rowY, int colX) /* ega_01 */
{
if (dax_block != null)
{
int offset = 0;
int minY = rowY * 8;
int maxY = minY + dax_block.Height;
int minX = colX * 8;
int maxX = minX + (dax_block.Width * 8);
for (int pixY = minY; pixY < maxY; pixY++)
{
for (int pixX = minX; pixX < maxX; pixX++)
{
dax_block.ImageData[offset] = Display.GetPixel(pixX, pixY);
offset++;
}
}
}
}
OverlayBounded(DaxBlock source, int arg_8, int itemIndex, int rowY, int colX) /* sub_E353 */
{
draw_combat_picture(source, rowY + 1, colX + 1, itemIndex);
}
internal static void OverlayUnbounded(DaxBlock source, int arg_8, int itemIdex, int rowY, int colX)
{
draw_combat_picture(source, rowY + 1, colX + 1, itemIdex);
}
internal static void draw_picture(DaxBlock dax_block, int rowY, int colX, int index)
{
draw_clipped_picture(dax_block, rowY, colX, index, 0, 320, 0, 200);
}
public void Release()
{
normal = null;
normal_f = null;
attack = null;
attack_f = null;
}
internal static void load_pic_final(ref DaxArray daxArray, bool shouldMask, byte block_id, string file_name)
{
if (file_name != gbl.lastDaxFile ||
block_id != gbl.lastDaxBlockId)
{
if (block_id != 0xff)
{
if (gbl.AnimationsOn)
{
ovr027.ClearPromptAreaNoUpdate();
Seg041.DisplayString("Loading...Please Wait", 0, 10, 0x18, 0);
}
DaxArrayFreeDaxBlocks(daxArray);
gbl.lastDaxFile = file_name;
gbl.lastDaxBlockId = block_id;
bool is_pic_or_final = (file_name == "PIC" || file_name == "FINAL");
short uncompressed_size;
byte[] uncompressed_data;
seg042.load_decode_dax(out uncompressed_data, out uncompressed_size, block_id,
file_name + gbl.game_area.ToString() + ".dax");
if (uncompressed_size == 0)
{
Seg041.DisplayAndPause("PIC not found", 14);
}
else
{
int src_offset = 0;
daxArray.numFrames = uncompressed_data[src_offset];
src_offset++;
daxArray.curFrame = 1;
byte frames_count = 0; // kind of pointless...
if (gbl.AnimationsOn == false && is_pic_or_final == true)
{
daxArray.numFrames = 1;
}
byte[] first_frame_ega_layout = null;
for (int frame = 0; frame < daxArray.numFrames; frame++)
{
daxArray.frames[frame].delay = Sys.ArrayToInt(uncompressed_data, src_offset);
src_offset += 4;
short height = Sys.ArrayToShort(uncompressed_data, src_offset);
src_offset += 2;
short width = Sys.ArrayToShort(uncompressed_data, src_offset);
src_offset += 2;
frames_count++;
daxArray.frames[frame].picture = new DaxBlock(1, width, height);
DaxBlock dax_block = daxArray.frames[frame].picture;
dax_block.XPos = Sys.ArrayToShort(uncompressed_data, src_offset);
src_offset += 2;
dax_block.YPos = Sys.ArrayToShort(uncompressed_data, src_offset);
src_offset += 3;
// Skipping unused bytes
src_offset += 8;
int ega_encoded_size = (daxArray.frames[frame].picture.Bpp / 2) - 1;
if (is_pic_or_final == true)
{
if (frame == 0)
{
first_frame_ega_layout = new byte[ega_encoded_size + 1];
System.Array.Copy(uncompressed_data, src_offset, first_frame_ega_layout, 0,
ega_encoded_size + 1);
}
else
{
for (int i = 0; i < ega_encoded_size; i++)
{
byte b = first_frame_ega_layout[i];
uncompressed_data[src_offset + i] ^= b;
}
}
}
daxArray.frames[frame].picture.DaxToPicture(0, shouldMask, src_offset, uncompressed_data);
if (shouldMask)
{
daxArray.frames[frame].picture
.Recolor(false, transparentNewColors, transparentOldColors);
}
src_offset += ega_encoded_size + 1;
}
daxArray.numFrames = frames_count; // also pointless
uncompressed_data = null;
seg043.clear_keyboard();
if (gbl.AnimationsOn)
{
ovr027.ClearPromptAreaNoUpdate();
}
}
}
}
}
internal static void draw_combat_picture(DaxBlock dax_block, int rowY, int colX, int index)
{
draw_clipped_picture(dax_block, rowY, colX, index, 8, 176, 8, 176);
}
internal static void CombatantKilled(Player player) // sub_74E6F
{
if (gbl.game_state != GameState.Combat)
{
seg044.PlaySound(Sound.sound_5);
seg041.GameDelay();
}
else
{
bool downedPlayer = gbl.downedPlayers.Exists(cell => cell.target == player);
if (!downedPlayer)
{
int player_index = GetPlayerIndex(player);
var map = ovr033.PlayerMapPos(player);
if (PlayerOnScreen(true, player) == false)
{
redrawCombatArea(8, 3, map);
}
RedrawPlayerBackground(player_index);
seg044.PlaySound(Sound.sound_5);
// Draw skull overlay
DaxBlock attackIcon = gbl.combat_icons[24].GetIcon(Icon.Attack, 0);
DaxBlock normalIcon = gbl.combat_icons[25].GetIcon(Icon.Normal, 0);
var points = BuildSizeMap(gbl.CombatMap[player_index].size, gbl.CombatMap[player_index].screenPos);
for (int var_3 = 0; var_3 <= 8; var_3++)
{
foreach (var pos in points)
{
if (CoordOnScreen(pos) == true)
{
DaxBlock tmp = ((var_3 & 1) == 0) ? attackIcon : normalIcon;
seg040.OverlayBounded(tmp, 5, 0, (pos.y) * 3, (pos.x) * 3);
}
}
seg040.DrawOverlay();
seg049.SysDelay(10);
}
// Add downed corpse for team players.
if (player.actions.nonTeamMember == false)
{
var b = new Struct_1D183();
gbl.downedPlayers.Add(b);
b.originalBackgroundTile = gbl.mapToBackGroundTile[map];
b.target = player;
b.map = map;
if (gbl.mapToBackGroundTile[map] != 0x1E)
{
gbl.mapToBackGroundTile[map] = 0x1F;
}
}
// clean-up combat stuff
seg041.GameDelay();
RedrawPlayerBackground(player_index);
gbl.CombatMap[GetPlayerIndex(player)].size = 0;
setup_mapToPlayerIndex_and_playerScreen();
redrawCombatArea(8, 3, gbl.mapToBackGroundTile.mapScreenTopLeft + Point.ScreenCenter);
player.actions.delay = 0;
player.actions.move = 0;
player.actions.spell_id = 0;
player.actions.guarding = false;
}
}
}
