diff --git a/src/scripts/entis_gls/csx/v1/img.rs b/src/scripts/entis_gls/csx/v1/img.rs index 4fa4da2..bc2854c 100644 --- a/src/scripts/entis_gls/csx/v1/img.rs +++ b/src/scripts/entis_gls/csx/v1/img.rs @@ -599,6 +599,388 @@ impl ECSExecutionImage { Ok(messages) } + pub fn import<'a>( + &self, + messages: Vec, + file: Box, + replacement: Option<&'a ReplacementTable>, + ) -> Result<()> { + let mut cloned = self.clone(); + let mut disasm = ECSExecutionImageDisassembler::new( + self.image.to_ref(), + self.ext_const_str.as_ref(), + None, + ); + disasm.execute()?; + let mut assembly = disasm.assembly.clone(); + let mut index = 0; + let mut dumped_index = 0; + let mut new_image = MemWriter::new(); + let mut pre_is_mess = false; + let mut first_mess_index = None; + let mut last_mess_index = None; + let mut message_iter = messages.into_iter(); + let mut mess = message_iter.next(); + while index < assembly.len() { + let cmd = assembly[index].clone(); + if cmd.code == CsicCall { + disasm.stream.pos = cmd.addr as usize + 1; + let csom = disasm.read_csom()?; + let num_args = disasm.stream.read_i32()?; + let func_name = WideString::unpack(&mut disasm.stream, false, Encoding::Utf16LE)?.0; + let mut is_mess = false; + if csom == CsomAuto && num_args == 1 && func_name == "Mess" { + is_mess = true; + if first_mess_index.is_none() { + first_mess_index = Some(index); + } + last_mess_index = Some(index); + } + if pre_is_mess && !is_mess { + let first_index = first_mess_index + .ok_or(anyhow::anyhow!("Internal error: first_mess_index is None"))?; + let last_index = last_mess_index + .ok_or(anyhow::anyhow!("Internal error: last_mess_index is None"))?; + // Load string + let pre_index = first_index - 1; + while dumped_index < pre_index { + let tcmd = &mut assembly[dumped_index]; + tcmd.new_addr = new_image.pos as u32; + // Copy original instruction + new_image.write_from( + &mut disasm.stream, + tcmd.addr as u64, + tcmd.size as u64, + )?; + dumped_index += 1; + } + // Free + let post_index = last_index + 1; + let mut message = mess + .take() + .ok_or_else(|| { + anyhow::anyhow!("Not enough messages to import for Mess command.") + })? + .message; + mess = message_iter.next(); + if let Some(repl) = replacement { + for (k, v) in repl.map.iter() { + message = message.replace(k, v); + } + } + for i in (first_index..=last_index).step_by(3) { + let tcmd = assembly[i - 1].clone(); + disasm.stream.pos = tcmd.addr as usize + 1; + let lcsom = disasm.read_csom()?; + let lcsvt = disasm.read_csvt()?; + if lcsom != CsomImmediate || lcsvt != CsvtString { + return Err(anyhow::anyhow!( + "Invalid load command before Mess at {:08X}.", + tcmd.addr + )); + } + } + let mes_list: Vec<_> = message + .replace("\n", &self.lf) + .split(&self.lf) + .map(|s| s.to_string()) + .collect(); + let mut new_assembly = Vec::new(); + let mes_count = mes_list.len(); + let mut tmp_index = pre_index; + for i in 0..mes_count { + let mut mes = mes_list[i].clone(); + if i < mes_count - 1 { + mes.push_str(&self.lf); + } + let mut tcmd = if tmp_index <= post_index { + let data = assembly[tmp_index].clone(); + tmp_index += 1; + if data.code != CsicLoad { + return Err(anyhow::anyhow!( + "Internal error: expected Load command at {:08X}.", + data.addr + )); + } + data + } else { + ECSExecutionImageCommandRecord { + code: CsicLoad, + addr: u32::MAX, + size: 0, + new_addr: 0, + } + }; + tcmd.new_addr = new_image.pos as u32; + new_image.write_u8(CsicLoad.into())?; + new_image.write_u8(CsomImmediate.into())?; + new_image.write_u8(CsvtString.into())?; + WideString(mes).pack(&mut new_image, false, Encoding::Utf8)?; + new_assembly.push(tcmd); + let mut tcmd = if tmp_index <= post_index { + let data = assembly[tmp_index].clone(); + tmp_index += 1; + if data.code != CsicCall { + return Err(anyhow::anyhow!( + "Expected Call command at {:08X}.", + data.addr + )); + } + data + } else { + ECSExecutionImageCommandRecord { + code: CsicCall, + addr: u32::MAX, + size: 0, + new_addr: 0, + } + }; + tcmd.new_addr = new_image.pos as u32; + new_image.write_u8(CsicCall.into())?; + new_image.write_u8(CsomAuto.into())?; + new_image.write_i32(1)?; // num_args + WideString("Mess".to_string()).pack( + &mut new_image, + false, + Encoding::Utf16LE, + )?; + new_assembly.push(tcmd); + let mut tcmd = if tmp_index <= post_index { + let data = assembly[tmp_index].clone(); + tmp_index += 1; + if data.code != CsicFree { + return Err(anyhow::anyhow!( + "Expected Free command at {:08X}.", + data.addr + )); + } + data + } else { + ECSExecutionImageCommandRecord { + code: CsicFree, + addr: u32::MAX, + size: 0, + new_addr: 0, + } + }; + tcmd.new_addr = new_image.pos as u32; + new_image.write_u8(CsicFree.into())?; + new_assembly.push(tcmd); + } + let ori_count = post_index - pre_index + 1; + let new_count = new_assembly.len(); + dumped_index += new_count; + index = (index as isize + (new_count as isize - ori_count as isize)) as usize; + last_mess_index = None; + first_mess_index = None; + assembly.splice(pre_index..post_index + 1, new_assembly); + } + if csom == CsomAuto && num_args == 2 && func_name == "Talk" { + if index < 2 { + return Err(anyhow::anyhow!( + "No enough load command at {:08x}.", + cmd.addr + )); + } + let pre_index = index - 2; + while dumped_index < pre_index { + let tcmd = &mut assembly[dumped_index]; + tcmd.new_addr = new_image.pos as u32; + // Copy original instruction + new_image.write_from( + &mut disasm.stream, + tcmd.addr as u64, + tcmd.size as u64, + )?; + dumped_index += 1; + } + let tcmd = &mut assembly[pre_index]; + tcmd.new_addr = new_image.pos as u32; + disasm.stream.pos = tcmd.addr as usize + 1; + let lcsom = disasm.read_csom()?; + let lcsvt = disasm.read_csvt()?; + if lcsom != CsomImmediate || lcsvt != CsvtString { + return Err(anyhow::anyhow!( + "Invalid load command before Talk at {:08X}.", + tcmd.addr + )); + } + let original_name = disasm.get_string_literal()?; + let name = if original_name == "心の声" { + original_name + } else { + let mut name = mess.as_mut().map(|s| s.name.take()).flatten().ok_or( + anyhow::anyhow!("No available name for Talk at {:08X}.", cmd.addr), + )?; + if let Some(repl) = replacement { + for (k, v) in repl.map.iter() { + name = name.replace(k, v); + } + } + name + }; + new_image.write_u8(CsicLoad.into())?; + new_image.write_u8(lcsom.into())?; + new_image.write_u8(lcsvt.into())?; + WideString(name).pack(&mut new_image, false, Encoding::Utf8)?; + dumped_index += 1; + while dumped_index <= index { + let tcmd = &mut assembly[dumped_index]; + tcmd.new_addr = new_image.pos as u32; + // Copy original instruction + new_image.write_from( + &mut disasm.stream, + tcmd.addr as u64, + tcmd.size as u64, + )?; + dumped_index += 1; + } + } else if csom == CsomAuto && num_args == 2 && func_name == "AddSelect" { + if index < 2 { + return Err(anyhow::anyhow!( + "No enough load command at {:08x}.", + cmd.addr + )); + } + let pre_index = index - 2; + while dumped_index < pre_index { + let tcmd = &mut assembly[dumped_index]; + tcmd.new_addr = new_image.pos as u32; + // Copy original instruction + new_image.write_from( + &mut disasm.stream, + tcmd.addr as u64, + tcmd.size as u64, + )?; + dumped_index += 1; + } + let tcmd = &mut assembly[pre_index]; + tcmd.new_addr = new_image.pos as u32; + disasm.stream.pos = tcmd.addr as usize + 1; + let lcsom = disasm.read_csom()?; + let lcsvt = disasm.read_csvt()?; + if lcsom != CsomImmediate || lcsvt != CsvtString { + return Err(anyhow::anyhow!( + "Invalid load command before AddSelect at {:08X}.", + tcmd.addr + )); + } + let mut message = mess + .take() + .ok_or_else(|| { + anyhow::anyhow!( + "No available message for AddSelect at {:08X}.", + cmd.addr + ) + })? + .message; + mess = message_iter.next(); + if let Some(repl) = replacement { + for (k, v) in repl.map.iter() { + message = message.replace(k, v); + } + } + new_image.write_u8(CsicLoad.into())?; + new_image.write_u8(lcsom.into())?; + new_image.write_u8(lcsvt.into())?; + WideString(message).pack(&mut new_image, false, Encoding::Utf8)?; + dumped_index += 1; + while dumped_index <= index { + let tcmd = &mut assembly[dumped_index]; + tcmd.new_addr = new_image.pos as u32; + // Copy original instruction + new_image.write_from( + &mut disasm.stream, + tcmd.addr as u64, + tcmd.size as u64, + )?; + dumped_index += 1; + } + } else if csom == CsomAuto && num_args == 1 && func_name == "SceneTitle" { + if index < 1 { + return Err(anyhow::anyhow!( + "No enough load command at {:08x}.", + cmd.addr + )); + } + let pre_index = index - 1; + while dumped_index < pre_index { + let tcmd = &mut assembly[dumped_index]; + tcmd.new_addr = new_image.pos as u32; + // Copy original instruction + new_image.write_from( + &mut disasm.stream, + tcmd.addr as u64, + tcmd.size as u64, + )?; + dumped_index += 1; + } + let tcmd = &mut assembly[pre_index]; + tcmd.new_addr = new_image.pos as u32; + disasm.stream.pos = tcmd.addr as usize + 1; + let lcsom = disasm.read_csom()?; + let lcsvt = disasm.read_csvt()?; + if lcsom != CsomImmediate || lcsvt != CsvtString { + return Err(anyhow::anyhow!( + "Invalid load command before SceneTitle at {:08X}.", + tcmd.addr + )); + } + let mut message = mess + .take() + .ok_or_else(|| { + anyhow::anyhow!( + "No available message for SceneTitle at {:08X}.", + cmd.addr + ) + })? + .message; + mess = message_iter.next(); + if let Some(repl) = replacement { + for (k, v) in repl.map.iter() { + message = message.replace(k, v); + } + } + new_image.write_u8(CsicLoad.into())?; + new_image.write_u8(lcsom.into())?; + new_image.write_u8(lcsvt.into())?; + WideString(message).pack(&mut new_image, false, Encoding::Utf8)?; + dumped_index += 1; + while dumped_index <= index { + let tcmd = &mut assembly[dumped_index]; + tcmd.new_addr = new_image.pos as u32; + // Copy original instruction + new_image.write_from( + &mut disasm.stream, + tcmd.addr as u64, + tcmd.size as u64, + )?; + dumped_index += 1; + } + } + pre_is_mess = is_mess; + } + index += 1; + } + while dumped_index < assembly.len() { + let tcmd = &mut assembly[dumped_index]; + tcmd.new_addr = new_image.pos as u32; + // Copy original instruction + new_image.write_from(&mut disasm.stream, tcmd.addr as u64, tcmd.size as u64)?; + dumped_index += 1; + } + if mess.is_some() || message_iter.next().is_some() { + return Err(anyhow::anyhow!("Too many messages to import.")); + } + let commands: HashMap = + assembly.iter().map(|c| (c.addr, c)).collect(); + Self::fix_image(&assembly, disasm.stream.clone(), &mut new_image, &commands)?; + cloned.image = MemReader::new(new_image.into_inner()); + cloned.fix_references(&commands)?; + cloned.save(file)?; + Ok(()) + } + pub fn import_multi<'a>( &self, mut messages: HashMap>, diff --git a/src/scripts/entis_gls/csx/v1/mod.rs b/src/scripts/entis_gls/csx/v1/mod.rs index 3409810..1dea189 100644 --- a/src/scripts/entis_gls/csx/v1/mod.rs +++ b/src/scripts/entis_gls/csx/v1/mod.rs @@ -90,6 +90,17 @@ impl Script for CSXScript { self.img.export() } + fn import_messages<'a>( + &'a self, + messages: Vec, + file: Box, + _filename: &str, + _encoding: Encoding, + replacement: Option<&'a ReplacementTable>, + ) -> Result<()> { + self.img.import(messages, file, replacement) + } + fn multiple_message_files(&self) -> bool { true }