├── pkg_menu.list
├── issue_template.md
├── tbb2shift.list
├── swap.sh
├── vcalcOpCodes.hh
├── patchEboot.py
├── transfer.sh
├── 1stload.list
├── 102repack_ch.sh
├── sceneTool.hh
├── Makefile
├── unplt.cpp
├── encScripts.sh
├── 102repack.sh
├── plt.cpp
├── tbbconv
    ├── node_modules
    │   └── jconv
    │   │   ├── package.json
    │   │   ├── READMEja.md
    │   │   ├── README.md
    │   │   ├── jconv.min.js
    │   │   └── jconv.js
    └── tbbconv.js
├── Translation.md
├── undat.cpp
├── README.md
├── xaiPatch.cpp
├── dat.cpp
├── unxai.cpp
├── sceneOpCodeNames.hh
├── LICENSE
├── xai.cpp
├── sceneOpCodes.hh
├── bin2script.cpp
└── script2bin.cpp


/pkg_menu.list:
--------------------------------------------------------------------------------
1 | 
2 | dir_book.rsb
3 | #help.rsb CRASH
4 | item_dtt.rsb
5 | itwin.rsb
6 | itwins.rsb
7 | mdiary.rsb
8 | mopt.rsb
9 | 


--------------------------------------------------------------------------------
/issue_template.md:
--------------------------------------------------------------------------------
 1 | ### YS VIII ###
 2 | 
 3 | - 1 : Did you create your own or download a pre-patched ?
 4 | 
 5 | - 2 : Are you using the latest version ?
 6 | 
 7 | - 3 : Where does the bug occur ? (Please be specific with details)
 8 | 
 9 | - 4 : Please provide a save.
10 | 
11 | Thank you.
12 | 


--------------------------------------------------------------------------------
/tbb2shift.list:
--------------------------------------------------------------------------------
 1 | #3dicon.tbb
 2 | actev.tbb
 3 | balance.tbb
 4 | diary.tbb
 5 | drchara.tbb
 6 | #equip.tbb
 7 | #fisharea.tbb
 8 | #fishchar.tbb
 9 | #fishchr2.tbb
10 | #fishhazu.tbb
11 | #fish.tbb
12 | invtable.tbb
13 | itempt.tbb
14 | item.tbb
15 | lensfl.tbb
16 | manual.tbb
17 | map3dcon.tbb
18 | #mapcoop.tbb
19 | #mapevent.tbb
20 | #mapmstbl.tbb
21 | mapname.tbb
22 | #mapopen.tbb
23 | maprange.tbb
24 | #mapwarp.tbb
25 | minimap.tbb
26 | mixitem2.tbb
27 | monslib.tbb
28 | npcparam.tbb
29 | #pc.tbb
30 | quest.tbb
31 | record.tbb
32 | #shop2.tbb
33 | #skill.tbb
34 | soundefx.tbb
35 | status.tbb
36 | #tips.tbb
37 | voice.tbb
38 | #vo_scene.tbb


--------------------------------------------------------------------------------
/swap.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | display_usage()
 4 | {
 5 |     echo "Usage : $0 <fileList> <inputDir> <outputDir>" 
 6 |     echo -e "  Copies the filenames in <fileList> from <inputDir> to <outputDir>" 
 7 | }
 8 | 
 9 | if [  $# -lt 3 ] 
10 | then 
11 |     display_usage
12 |     exit 1
13 | fi 
14 | 
15 | input=$2
16 | output=$3
17 | 
18 | while IFS='' read -r filename || [[ -n "$filename" ]]; do
19 | 
20 | 	[[ "$filename" =~ ^#.*$ ]] && continue
21 | 	[[ -z "$filename" ]] && continue
22 | 
23 | 	if [ $1 = tbb2shift.list ]; then
24 | 		echo "Converting $filename from $input to $output as SHIFT-JIS"
25 | 
26 | 		node tbbconv/tbbconv.js unpack "$input"/"$filename" tmp
27 | 		node tbbconv/tbbconv.js pack tmp "$output"/"$filename" --enc shift-jis
28 | 		# mkdir -p tbb
29 | 		# cp tmp tbb/"$filename".csv
30 | 
31 | 	else
32 | 		echo "Copying $filename from $input to $output"
33 | 		cp -f "$input"/"$filename" "$output"/"$filename"
34 | 	fi
35 | 
36 | done < "$1"
37 | 
38 | echo "Script $1 finished"
39 | 
40 | 


--------------------------------------------------------------------------------
/vcalcOpCodes.hh:
--------------------------------------------------------------------------------
 1 | // Scene OpCodes
 2 | 
 3 | #pragma once
 4 | 
 5 | enum VCalcOpCode {
 6 | 
 7 |   VCODE_NEQ = 0x0001,
 8 |   VCODE_NOT = 0x0002,
 9 |   VCODE_MUL = 0x0003,
10 |   VCODE_DIV = 0x0004,
11 |   VCODE_IDIV = 0x0005,
12 |   VCODE_ADD = 0x0006,
13 |   VCODE_SUB = 0x0007,
14 |   VCODE_SRL = 0x0008,
15 |   VCODE_GE = 0x0009,
16 |   VCODE_GT = 0x000A,
17 |   VCODE_SLL = 0x000B,
18 |   VCODE_LE = 0x000C,
19 |   VCODE_LT = 0x000D,
20 |   VCODE_EQ = 0x000E,
21 |   VCODE_AND = 0x0010,
22 |   VCODE_BAND = 0x0011,
23 |   VCODE_OR = 0x0012,
24 |   VCODE_BOR = 0x0013,
25 |   VCODE_BNOT = 0x0014,
26 |   VCODE_XOR = 0x0015,
27 |   VCODE_LDINT = 0x001A,
28 |   VCODE_LDFLT = 0x001B,
29 |   VCODE_LDGLB = 0x001C,
30 |   VCODE_END = 0x001D,
31 |   VCODE_LDVAR = 0x001F,
32 | 
33 |   VCODE_NOP = 0x0024,
34 |   VCODE_ABS = 0x0025,
35 |   VCODE_F2I = 0x0026,
36 |   VCODE_I2F = 0x0027,
37 |   VCODE_RAND = 0x0029,
38 |   VCODE_FRAND = 0x002A,
39 |   VCODE_SOBJ = 0x002C,
40 |   VCODE_ROBJ = 0x002B,
41 | 
42 |   VCODE_NEG = 0x0042,
43 | 
44 |   VCODE_MAXVAL = 0x0045
45 | };
46 | 


--------------------------------------------------------------------------------
/patchEboot.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/python3
 2 | 
 3 | from io import *
 4 | import sys
 5 | 
 6 | saveLvlPatch0="Lv %d\0\0"
 7 | saveLvlPatch1="Lv %d\n\0"
 8 | saveLvlOrigin="Lv%02d"
 9 | bSaveLvlOrigin=bytes(saveLvlOrigin, 'utf8')
10 | 
11 | # Patch the eboot's save level formatting
12 | def patchEboot(path):
13 | 	try:
14 | 		with open(path, 'r+b') as fh:
15 | 			print('Patching ' + path + ' ...')
16 | 			data = fh.read()
17 | 			offset0 = data.find(bSaveLvlOrigin)
18 | 			offset1 = data.find(bSaveLvlOrigin, offset0 + len(saveLvlOrigin))
19 | 
20 | 			if offset0 > 1000 and offset1 > 1000:
21 | 				print('First offset  : ' + hex(offset0))
22 | 				print('Second offset : ' + hex(offset1))
23 | 
24 | 				fh.seek(offset0)
25 | 				fh.write(bytes(saveLvlPatch0, 'utf8'))
26 | 				fh.seek(offset1)
27 | 				fh.write(bytes(saveLvlPatch1, 'utf8'))
28 | 				print(path + ' patched')
29 | 
30 | 			else:
31 | 				print("File does not require patching")
32 | 
33 | 	except IOError:
34 | 		print(path + ' not found')
35 | 
36 | 
37 | if __name__ == "__main__":
38 | 	patchEboot(sys.argv[1])
39 | 


--------------------------------------------------------------------------------
/transfer.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | DIR=$1
 4 | 
 5 | #cp -f patch101_fix.xai $DIR/app/PCSG00881/patch101.xai
 6 | cp -f patch102_fix.xai $DIR/app/PCSG00881/patch102.xai
 7 | # cp -f patch102_fix_ch.xai $DIR/app/PCSH00297/patch102.xai
 8 | 
 9 | # ./xaiPatch patch101_fix.xai "shift-jis_dist/patch101/script/mp1201.bin" script/mp1201.bin
10 | # ./xaiPatch $DIR/app/PCSG00881/patch101.xai "shift-jis_dist/patch101/script/mp1201.bin" script/mp1201.bin
11 | 
12 | # ./xaiPatch $DIR/app/PCSG00881/rootast.xai "jap/base/movie/logo.mp4" movie/logo.mp4
13 | 
14 | # for script in script/*; do
15 | #     ./xaiPatch $DIR/app/PCSG00881/rootast.xai $script $script > /dev/null
16 | # done
17 | 
18 | #./xaiPatch $DIR/app/PCSG00881/rootast.xai custom/mp4102t2.bin script/mp4102t2.bin
19 | 
20 | ./patchEboot.py $DIR/app/PCSG00881/eboot.bin
21 | ./patchEboot.py $DIR/app/PCSG00881/mai_moe/eboot_origin.bin
22 | 
23 | # ./patchEboot.py $DIR/app/PCSH00297/eboot.bin > /dev/null
24 | # ./patchEboot.py $DIR/app/PCSH00297/mai_moe/eboot_origin.bin > /dev/null
25 | 
26 | 
27 | echo "Unmounting '${DIR}', please wait ..."
28 | umount $DIR -v
29 | 


--------------------------------------------------------------------------------
/1stload.list:
--------------------------------------------------------------------------------
 1 | #3dicon.h OK
 2 | 3dicon.tbb
 3 | actev.tbb
 4 | #argpunc.txt <= CRASH
 5 | ascii2l.itp
 6 | balance.tbb
 7 | c000.mtb
 8 | c001.mtb
 9 | #c002.mtb	One of those bugs laxia's finisher, other .mtb only changed smthg like checksum
10 | c003.mtb
11 | #c004.mtb	One of those bugs laxia's finisher, other .mtb only changed smthg like checksum
12 | c005.mtb
13 | #def.h OK
14 | diary.tbb
15 | drchara.tbb
16 | #efxlist.txt OK
17 | #enum_al.h OK
18 | #enum_rl.h OK
19 | equip.tbb
20 | fisharea.tbb
21 | fishchar.tbb
22 | fishchr2.tbb
23 | #fish.h OK
24 | fishhazu.tbb
25 | fish.tbb
26 | #flag.h OK
27 | font.itf
28 | #inccc2.scp
29 | #inccc3.scp
30 | #inccc.scp
31 | invtable.tbb
32 | item.bin
33 | itempt.tbb
34 | item.tbb
35 | lensfl.tbb
36 | lit_atxt.csv
37 | #lit_rtxt.csv BUG : Can't move, but has english stuff
38 | manual.tbb
39 | map3dcon.tbb
40 | mapainfo.tlb
41 | mapcoop.tbb
42 | mapevent.tbb
43 | mapmstbl.tbb
44 | mapname.tbb
45 | mapopen.tbb
46 | maprange.tbb
47 | mapwarp.tbb
48 | minimap.tbb
49 | mixitem2.tbb
50 | #mons.h	CRASH
51 | monslib.tbb
52 | #monspunc.txt OK
53 | #mtdpunc.txt	TODO : TEST
54 | npc.bin
55 | npcparam.tbb
56 | #opepunc.txt CRASH
57 | pc.tbb
58 | pl_const.plt
59 | quest.tbb
60 | record.tbb
61 | #rszpunc.txt	TODO : TEST
62 | #scr_inc.h	TODO : TEST
63 | #scr_punc.txt	TODO : TEST
64 | #se.h	TODO : TEST
65 | shdlist.csv
66 | shop2.tbb
67 | #skilldef.h	TODO : TEST
68 | skill.tbb
69 | soundefx.tbb
70 | # status.tbb bugs on the japanese game, so we have to reencode it later for this game
71 | status.tbb
72 | system.bin
73 | system01.itp
74 | talk.bin
75 | talkcam.bin
76 | #tips.h	TODO : TEST
77 | tips.tbb
78 | #vo.h	TODO : TEST
79 | voice.tbb
80 | vo_scene.tbb
81 | y8_btl.itp
82 | 


--------------------------------------------------------------------------------
/102repack_ch.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | PKG_MENU_ENG_DIR=pkg_menu_eng
 4 | PKG_MENU_FIX_DIR=pkg_menu_fix_ch
 5 | PKG_MENU_CH_XAI=pkg_menu_ch.xai
 6 | PKG_MENU_OUT=pkg_menu_fix_ch.xai
 7 | PKG_MENU_LIST=pkg_menu.list
 8 | 
 9 | PATCH_102_FIX_DIR=patch102_fix_ch
10 | PATCH_102_REAL=patch102_real_ch.xai
11 | PATCH_102_OUT=patch102_fix_ch.xai
12 | 
13 | DAT_CH=1stload_ch.dat
14 | DAT_FIX_DIR=1stload_fix_ch
15 | DAT_OUT=1stload_fix_ch.dat
16 | 
17 | DAT_LIST=1stload.list
18 | DAT_ENG_DIR=1stload_allEng
19 | 
20 | TBB_LIST=tbb2shift.list
21 | 
22 | 
23 | rm $PKG_MENU_FIX_DIR/*
24 | ./unxai $PKG_MENU_CH_XAI $PKG_MENU_FIX_DIR > /dev/null
25 | ./swap.sh $PKG_MENU_LIST $PKG_MENU_ENG_DIR $PKG_MENU_FIX_DIR > /dev/null
26 | 
27 | ./xai $PKG_MENU_FIX_DIR $PKG_MENU_OUT $PKG_MENU_CH_XAI > /dev/null
28 | cp -f $PKG_MENU_OUT $PATCH_102_FIX_DIR/flash/pkg_menu.xai
29 | 
30 | rm $DAT_FIX_DIR/*
31 | ./undat $DAT_CH $DAT_FIX_DIR > /dev/null
32 | ./swap.sh $DAT_LIST $DAT_ENG_DIR $DAT_FIX_DIR > /dev/null
33 | 
34 | cp -f custom/lit_rtxt_ch.csv $DAT_FIX_DIR/lit_rtxt.csv
35 | cp -f custom/lit_rtxt_ch.csv $PATCH_102_FIX_DIR/system/lit_rtxt.csv
36 | 
37 | cp -f custom/pl_const_ch.plt $DAT_FIX_DIR/pl_const.plt
38 | cp -f custom/pl_const_ch.plt $PATCH_102_FIX_DIR/flash/pl_const.plt
39 | 
40 | 
41 | # mkdir -p tbb
42 | # ./swap.sh $TBB_LIST $DAT_ENG_DIR tbb > /dev/null
43 | 
44 | cp -f tbb_utf8/* $DAT_FIX_DIR
45 | 
46 | 
47 | ./dat $DAT_FIX_DIR $DAT_OUT > /dev/null
48 | cp -f $DAT_OUT $PATCH_102_FIX_DIR/system/1stload.dat
49 | 
50 | ./xai $PATCH_102_FIX_DIR $PATCH_102_OUT $PATCH_102_REAL > /dev/null
51 | cp -f $PATCH_102_OUT patch102.xai
52 | 
53 | # Some checks
54 | diff $PATCH_102_FIX_DIR/flash/pkg_menu.xai $PKG_MENU_OUT
55 | diff $PATCH_102_FIX_DIR/system/1stload.dat $DAT_OUT
56 | 


--------------------------------------------------------------------------------
/sceneTool.hh:
--------------------------------------------------------------------------------
 1 | // Scene tool
 2 | 
 3 | #pragma once
 4 | #include <cinttypes>
 5 | 
 6 | struct __attribute__((__packed__)) FILE_HEADER_V2 {
 7 |   char                        magic[8];                 //"YS7_SCP\0"
 8 |   uint8_t                     reserved[3];              //Isn't accessed by implementation
 9 |   uint8_t                     version;               //0x4 in mine, 0x2-0x4 use V2 header
10 |   uint64_t                    checksum;    //Doesn't appear to be checked by loader
11 |   uint32_t                    segs_count;            //Segments count
12 |   // SEGMENT_HEADER[segs_count]  segments;              //Segment headers
13 | };
14 | 
15 | struct __attribute__((__packed__)) SEGMENT_HEADER {
16 |   char        name[0x20];      //Segment name
17 |   uint32_t    size;      //Size of segment data
18 |   uint32_t    offset;    //Offset to segment data from the beginning of file
19 | };
20 | 
21 | typedef uint16_t OPCODE;
22 | typedef uint16_t DATA_TAG;
23 | 
24 | enum DataTag {
25 | 
26 |     INT_TAG = 0x82DD,
27 |     FLOAT_TAG = 0x82DE,
28 |     STRING_TAG = 0x82DF,
29 |     VCALC_TAG = 0x82E0,
30 | 
31 |     POPUP_TAG = 0x2020,
32 | };
33 | 
34 | 
35 | struct __attribute__((__packed__)) GENERIC_ARG {
36 | 
37 |   uint16_t  tag;
38 | 
39 |   union __attribute__((__packed__)) {
40 |     int32_t  iVal;
41 |     float    fVal;
42 |     uint32_t uVal;
43 |   };
44 | };
45 | 
46 | 
47 | struct __attribute__((__packed__)) INT_ARG {
48 |   uint16_t  tag_82DD;
49 |   int32_t   value;
50 | };
51 | 
52 | struct __attribute__((__packed__)) FLOAT_ARG {
53 |   uint16_t  tag_82DE;
54 |   float     value;
55 | };
56 | 
57 | struct __attribute__((__packed__)) STRING_ARG {
58 |   uint16_t  tag_82DF;
59 |   uint32_t  cch;
60 |   // char[cch] text;
61 | };
62 | 
63 | struct __attribute__((__packed__)) VCALC_ARG {
64 |   uint16_t        tag_82E0;
65 |   uint32_t        length;
66 |   // uint8_t[length] value;
67 | };
68 | 
69 | struct __attribute__((__packed__)) POPUP_ARG {
70 |   uint16_t  tag_2020;
71 |   uint32_t  nLines;
72 |   uint32_t  len;
73 |   // uint16_t[nLines] linePositions?
74 |   // char[len] popupText
75 | };
76 | 
77 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | 
 2 | INC=
 3 | LIB=
 4 | LSUFFIX=
 5 | 
 6 | CCFLAGS=-std=c++11 -g
 7 | 
 8 | ifeq ($(OS),Windows_NT)
 9 | 	CCFLAGS += -D WIN32 -static -static-libgcc -static-libstdc++
10 | 	INC=C:\Program Files\boost\include\boost-1_65_1
11 | 	LIB=C:\Program Files\boost\lib
12 | 	LSUFFIX=-mgw48-mt-1_65_1
13 | 
14 | 	ifeq ($(PROCESSOR_ARCHITEW6432),AMD64)
15 | 		CCFLAGS += -D AMD64
16 | 	else
17 | 		ifeq ($(PROCESSOR_ARCHITECTURE),AMD64)
18 | 			CCFLAGS += -D AMD64
19 | 		endif
20 | 		ifeq ($(PROCESSOR_ARCHITECTURE),x86)
21 | 			CCFLAGS += -D IA32
22 | 		endif
23 | 	endif
24 | else
25 | 	UNAME_S := $(shell uname -s)
26 | 	ifeq ($(UNAME_S),Linux)
27 | 		CCFLAGS += -D LINUX
28 | 	endif
29 | 	ifeq ($(UNAME_S),Darwin)
30 | 		CCFLAGS += -D OSX
31 | 	endif
32 | 	UNAME_P := $(shell uname -p)
33 | 	ifeq ($(UNAME_P),x86_64)
34 | 		CCFLAGS += -D AMD64
35 | 	endif
36 | 	ifneq ($(filter %86,$(UNAME_P)),)
37 | 		CCFLAGS += -D IA32
38 | 	endif
39 | 	ifneq ($(filter arm%,$(UNAME_P)),)
40 | 		CCFLAGS += -D ARM
41 | 	endif
42 | endif
43 | 
44 | IFLAGS=-I"${INC}"
45 | LFLAGS=-L"${LIB}" -lboost_system${LSUFFIX} -lboost_filesystem${LSUFFIX} -lboost_locale${LSUFFIX}
46 | 
47 | all: xai unxai dat undat plt unplt xaiPatch bin2script script2bin
48 | 
49 | xai: xai.cpp
50 | 	g++ ${CCFLAGS} -o $@ $< ${IFLAGS} ${LFLAGS}
51 | 
52 | unxai: unxai.cpp
53 | 	g++ ${CCFLAGS} -o $@ $< ${IFLAGS} ${LFLAGS}
54 | 
55 | dat: dat.cpp
56 | 	g++ ${CCFLAGS} -o $@ $< ${IFLAGS} ${LFLAGS}
57 | 
58 | undat: undat.cpp
59 | 	g++ ${CCFLAGS} -o $@ $< ${IFLAGS} ${LFLAGS}
60 | 
61 | plt: plt.cpp
62 | 	g++ ${CCFLAGS} -o $@ $<
63 | 
64 | unplt: unplt.cpp
65 | 	g++ ${CCFLAGS} -o $@ $<
66 | 
67 | xaiPatch: xaiPatch.cpp
68 | 	g++ ${CCFLAGS} -o $@ $<
69 | 
70 | bin2script: bin2script.cpp sceneTool.hh sceneOpCodes.hh sceneOpCodeNames.hh
71 | 	g++ ${CCFLAGS} -fpermissive -o $@ $< ${IFLAGS} ${LFLAGS}
72 | 
73 | script2bin: script2bin.cpp sceneTool.hh sceneOpCodes.hh sceneOpCodeNames.hh
74 | 	g++ ${CCFLAGS} -fpermissive -o $@ $< ${IFLAGS} ${LFLAGS}
75 | 
76 | 
77 | clean:
78 | 	rm unxai xai -f
79 | 	rm undat dat -f
80 | 	rm unplt plt -f
81 | 	rm xaiPatch -f
82 | 	rm bin2script -f
83 | 	rm script2bin -f
84 | 


--------------------------------------------------------------------------------
/unplt.cpp:
--------------------------------------------------------------------------------
 1 | // PLT Unpacker by yosh778
 2 | 
 3 | #include <string>
 4 | #include <iostream>
 5 | #include <algorithm>
 6 | 
 7 | #include <sstream>
 8 | #include <fstream>
 9 | #include <cinttypes>
10 | 
11 | uint16_t read16(std::ifstream& input) {
12 | 	uint16_t data;
13 | 	input.read((char*)&data, (int)sizeof(data));
14 | 	return data;
15 | }
16 | 
17 | uint32_t read32(std::ifstream& input) {
18 | 	uint32_t data;
19 | 	input.read((char*)&data, (int)sizeof(data));
20 | 	return data;
21 | }
22 | 
23 | uint64_t read64(std::ifstream& input) {
24 | 	uint64_t data;
25 | 	input.read((char*)&data, (int)sizeof(data));
26 | 	return data;
27 | }
28 | 
29 | int main(int argc, char *argv[])
30 | {
31 | 	if ( argc < 3 ) {
32 | 		std::cerr << "Usage : " << argv[0] << " <input> <output>" << std::endl;
33 | 		return -1;
34 | 	}
35 | 
36 | 	std::string iDir = argv[1];
37 | 	std::string oDir = argv[2];
38 | 
39 | 	std::ifstream file( iDir.c_str(), std::ios_base::binary );
40 | 
41 | 	if ( !file.is_open() )
42 | 		return -2;
43 | 
44 | 	uint32_t data;
45 | 
46 | 	uint16_t nbEntries = read16(file);
47 | 	char fileName[64];
48 | 
49 | 	uint8_t *buf = NULL;
50 | 	uint16_t bufSize = 0;
51 | 	uint32_t nFoundEntries = 0;
52 | 
53 | 	std::ofstream output( oDir.c_str(), std::ios_base::trunc );
54 | 
55 | 	if ( !output.is_open() )
56 | 		return -1;
57 | 
58 | 
59 | 	for (uint32_t i = 0; i < nbEntries; i++) {
60 | 
61 | 		file.read(fileName, sizeof(fileName));
62 | 		fileName[63] = 0;
63 | 
64 | 		std::cout << fileName << std::endl;
65 | 
66 | 		uint16_t size = read16(file);
67 | 
68 | 		if ( !size )
69 | 			continue;
70 | 
71 | 		nFoundEntries++;
72 | 
73 | 		if ( (size+1) > bufSize ) {
74 | 			buf = (uint8_t*)realloc( buf, size+1 );
75 | 			bufSize = size+1;
76 | 		}
77 | 
78 | 		file.read( (char*)buf, size );
79 | 		buf[size] = 0;
80 | 
81 | 		output << fileName << std::endl;
82 | 		output << buf << std::endl;
83 | 	}
84 | 
85 | 	output.close();
86 | 
87 | 	std::cerr <<
88 | 	std::endl << "Number of declared entries      : " << nbEntries << std::endl;
89 | 	std::cerr << "Number of extracted entries     : " << nFoundEntries << std::endl;
90 | 
91 | 	file.close();
92 | 
93 | 	return 0;
94 | }
95 | 
96 | 


--------------------------------------------------------------------------------
/encScripts.sh:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | clear
 4 | clear
 5 | 
 6 | rm -rf "shift-jis_dist/"
 7 | 
 8 | DIR="shift-jis_dist"
 9 | 
10 | mkdir -p $DIR
11 | 
12 | 
13 | for path in eng/*/script/*; do
14 |     ./bin2script "$path" 2>err > tmp
15 |     exit_status=$?
16 |     cat err | grep -v "Invalid"
17 | 
18 |     if [ $exit_status -eq 0 ]; then
19 |         PREV="${path%%/*}"
20 |         NEXT="${path#*/}"
21 |         DEST="${PREV}_enc/${NEXT}"
22 |         ./script2bin tmp "$DEST" --enc-shift-jis > /dev/null
23 |         # ./bin2script "$DEST" > mm 2>err
24 |         # ./script2bin mm nn > /dev/null
25 |         # echo $path
26 |     fi
27 | done
28 | 
29 | mv "${PREV}_enc" "$DIR"
30 | 
31 | 
32 | for path in 1stload_allEng_script/*; do
33 |     ./bin2script "$path" 2>err > tmp
34 |     exit_status=$?
35 |     cat err | grep -v "Invalid"
36 | 
37 |     if [ $exit_status -eq 0 ]; then
38 |         PREV="${path%%/*}"
39 |         NEXT="${path#*/}"
40 |         DEST="${PREV}_enc/${NEXT}"
41 |         ./script2bin tmp "$DEST" --enc-shift-jis > /dev/null
42 |         # echo $path
43 |     fi
44 | done
45 | 
46 | mv "${PREV}_enc" "$DIR"
47 | 
48 | 
49 | for path in patch102_eng/script/*; do
50 |     ./bin2script "$path" 2>err > tmp
51 |     exit_status=$?
52 |     cat err | grep -v "Invalid"
53 | 
54 |     if [ $exit_status -eq 0 ]; then
55 |         PREV="${path%%/*}"
56 |         NEXT="${path#*/}"
57 |         DEST="${PREV}_enc/${NEXT}"
58 |         ./script2bin tmp "$DEST" --enc-shift-jis > /dev/null
59 |         # echo $path
60 |     fi
61 | done
62 | 
63 | mv "${PREV}_enc" "$DIR"
64 | 
65 | 
66 | for path in sceneFixes/*; do
67 |     ./bin2script "$path" 2>err > tmp
68 |     exit_status=$?
69 |     cat err | grep -v "Invalid"
70 | 
71 |     if [ $exit_status -eq 0 ]; then
72 |         PREV="${path%%/*}"
73 |         NEXT="${path#*/}"
74 |         DEST="${PREV}_enc/${NEXT}"
75 |         ./script2bin tmp "$DEST" --enc-shift-jis > /dev/null
76 |         # echo $path
77 |     fi
78 | done
79 | 
80 | mv "${PREV}_enc" "$DIR"
81 | 
82 | cp -f "$DIR"/sceneFixes_enc/mp4102t2.bin "$DIR"/eng_enc/base/script/mp4102t2.bin
83 | cp -f "$DIR"/sceneFixes_enc/mp1103.bin "$DIR"/patch102_eng_enc/script/mp1103.bin
84 | 
85 | 
86 | rm -rf "$DIR"/eng_enc/text_fr/ "$DIR"/eng_enc/patch102_fake
87 | 
88 | mv "$DIR"/eng_enc/* "$DIR"
89 | mv "$DIR"/base "$DIR"/rootast
90 | rmdir "$DIR"/eng_enc
91 | 
92 | 


--------------------------------------------------------------------------------
/102repack.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | PKG_MENU_ENG_DIR=pkg_menu_eng
 4 | PKG_MENU_FIX_DIR=pkg_menu_fix
 5 | PKG_MENU_JP_XAI=pkg_menu_jp.xai
 6 | PKG_MENU_OUT=pkg_menu_fix.xai
 7 | PKG_MENU_LIST=pkg_menu.list
 8 | 
 9 | PATCH_102_FIX_DIR=patch102_fix
10 | PATCH_102_REAL=patch102_real.xai
11 | PATCH_102_OUT=patch102_fix.xai
12 | 
13 | DAT_JP=1stload_jp.dat
14 | DAT_FIX_DIR=1stload_fix
15 | DAT_OUT=1stload_fix.dat
16 | 
17 | DAT_LIST=1stload.list
18 | DAT_ENG_DIR=1stload_allEng
19 | 
20 | TBB_LIST=tbb2shift.list
21 | 
22 | 
23 | rm $PKG_MENU_FIX_DIR/*
24 | ./unxai $PKG_MENU_JP_XAI $PKG_MENU_FIX_DIR > /dev/null
25 | ./swap.sh $PKG_MENU_LIST $PKG_MENU_ENG_DIR $PKG_MENU_FIX_DIR > /dev/null
26 | 
27 | ./xai $PKG_MENU_FIX_DIR $PKG_MENU_OUT $PKG_MENU_JP_XAI > /dev/null
28 | cp -f $PKG_MENU_OUT $PATCH_102_FIX_DIR/flash/pkg_menu.xai
29 | 
30 | rm $DAT_FIX_DIR/*
31 | ./undat $DAT_JP $DAT_FIX_DIR > /dev/null
32 | ./swap.sh $DAT_LIST $DAT_ENG_DIR $DAT_FIX_DIR > /dev/null
33 | 
34 | cp -f custom/lit_rtxt.csv $DAT_FIX_DIR
35 | cp -f custom/lit_rtxt.csv $PATCH_102_FIX_DIR/system/lit_rtxt.csv
36 | 
37 | cp -f custom/pl_const.plt $DAT_FIX_DIR
38 | cp -f custom/pl_const.plt $PATCH_102_FIX_DIR/flash/pl_const.plt
39 | 
40 | cp -f custom/mp1103.bin $PATCH_102_FIX_DIR/script/mp1103.bin
41 | 
42 | 
43 | # ./script2bin custom/item_test.ys custom/item.bin --enc-shift-jis > /dev/null
44 | # ./script2bin custom/talk.ys custom/talk.bin --enc-shift-jis > /dev/null
45 | ./script2bin custom/mp1204_credits.ys custom/mp1204.bin --enc-shift-jis > /dev/null
46 | ./script2bin custom/mp1101_mod.ys custom/mp1101.bin --enc-shift-jis > /dev/null
47 | #./script2bin custom/talk_test.ys custom/talk.bin > /dev/null
48 | 
49 | cp -f custom/mp1204.bin $PATCH_102_FIX_DIR/script/mp1204.bin
50 | #cp -f custom/mp1101.bin $PATCH_102_FIX_DIR/script/mp1101.bin
51 | 
52 | #cp -f custom/item_fix.bin custom/item.bin
53 | 
54 | 
55 |  # cp -f custom/item.bin $DAT_FIX_DIR
56 | #cp -f custom/talk.bin $DAT_FIX_DIR
57 | 
58 | # mkdir -p tbb
59 | # ./swap.sh $TBB_LIST $DAT_ENG_DIR tbb > /dev/null
60 | 
61 | cp -f tbb/* $DAT_FIX_DIR
62 | 
63 | 
64 | ./dat $DAT_FIX_DIR $DAT_OUT > /dev/null
65 | cp -f $DAT_OUT $PATCH_102_FIX_DIR/system/1stload.dat
66 | 
67 | ./xai $PATCH_102_FIX_DIR $PATCH_102_OUT $PATCH_102_REAL > /dev/null
68 | cp -f $PATCH_102_OUT patch102.xai
69 | 
70 | # Some checks
71 | diff $PATCH_102_FIX_DIR/flash/pkg_menu.xai $PKG_MENU_OUT
72 | diff $PATCH_102_FIX_DIR/system/1stload.dat $DAT_OUT
73 | 
74 | 


--------------------------------------------------------------------------------
/plt.cpp:
--------------------------------------------------------------------------------
 1 | // PLT Packer by yosh778
 2 | 
 3 | #include <string>
 4 | #include <iostream>
 5 | #include <algorithm>
 6 | 
 7 | #include <fstream>
 8 | #include <unordered_map>
 9 | #include <cinttypes>
10 | #include <cstring>
11 | 
12 | 
13 | void write32(std::fstream& output, uint32_t data) {
14 | 	output.write((char*)&data, (int)sizeof(data));
15 | }
16 | 
17 | void write16(std::fstream& output, uint16_t data) {
18 | 	output.write((char*)&data, (int)sizeof(data));
19 | }
20 | 
21 | uint64_t write64(std::fstream& output, uint64_t data) {
22 | 	output.write((char*)&data, (int)sizeof(data));
23 | }
24 | 
25 | uint32_t read32(std::ifstream& input) {
26 | 	uint32_t data;
27 | 	input.read((char*)&data, (int)sizeof(data));
28 | 	return data;
29 | }
30 | 
31 | uint64_t read64(std::ifstream& input) {
32 | 	uint64_t data;
33 | 	input.read((char*)&data, (int)sizeof(data));
34 | 	return data;
35 | }
36 | 
37 | int main(int argc, char *argv[])
38 | {
39 | 	if ( argc < 3 ) {
40 | 		std::cerr << "Usage : " << argv[0] << " <input> <outputData>" << std::endl;
41 | 		return -1;
42 | 	}
43 | 
44 | 	std::string inPath = argv[1];
45 | 	std::string output = argv[2];
46 | 	uint32_t mimicUnused = 0;
47 | 
48 | 	uint32_t i = 0;
49 | 	uint32_t nbEntries = 0;
50 | 
51 | 	std::ifstream input( inPath.c_str() );
52 | 
53 | 	if ( !input.is_open() ) {
54 | 		std::cerr << "Failed to open " << inPath << std::endl;
55 | 		return -2;
56 | 	}
57 | 
58 | 	std::fstream oFile( output.c_str(), std::ios_base::trunc | std::ios_base::out | std::ios_base::binary );
59 | 
60 | 	if ( !oFile.is_open() ) {
61 | 		std::cerr << "Failed to open output file '" << output << "'" << std::endl;
62 | 		return -2;
63 | 	}
64 | 
65 | 	write16(oFile, nbEntries);
66 | 
67 | 	i = 0;
68 | 	char nameBuf[64];
69 | 
70 | 	for( std::string line; getline( input, line ); )
71 | 	{
72 | 		memset(nameBuf, 0, sizeof(nameBuf));
73 | 		strncpy(nameBuf, line.c_str(), sizeof(nameBuf)-1);
74 | 
75 | 		oFile.write( nameBuf, sizeof(nameBuf) );
76 | 
77 | 		std::cerr << "Writing " << nameBuf << std::endl;
78 | 
79 | 		getline( input, line );
80 | 		write16(oFile, line.size() );
81 | 		oFile.write( line.c_str(), line.size() );
82 | 
83 | 		nbEntries++;
84 | 	}
85 | 
86 | 	oFile.seekg(0);
87 | 	write16(oFile, nbEntries);
88 | 
89 | 	input.close();
90 | 	oFile.close();
91 | 
92 | 	std::cerr << nbEntries << " files were included" << std::endl;
93 | 	std::cerr << "PLT archive successfully created" << std::endl;
94 | 
95 | 	return 0;
96 | }
97 | 
98 | 


--------------------------------------------------------------------------------
/tbbconv/node_modules/jconv/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "_args": [
 3 |     [
 4 |       {
 5 |         "raw": "jconv",
 6 |         "scope": null,
 7 |         "escapedName": "jconv",
 8 |         "name": "jconv",
 9 |         "rawSpec": "",
10 |         "spec": "latest",
11 |         "type": "tag"
12 |       },
13 |       "E:\\GPs\\ys8\\status.tbb"
14 |     ]
15 |   ],
16 |   "_from": "jconv@latest",
17 |   "_id": "jconv@0.1.5",
18 |   "_inCache": true,
19 |   "_installable": true,
20 |   "_location": "/jconv",
21 |   "_npmUser": {
22 |     "name": "narirou",
23 |     "email": "narirou.github@gmail.com"
24 |   },
25 |   "_npmVersion": "1.3.24",
26 |   "_phantomChildren": {},
27 |   "_requested": {
28 |     "raw": "jconv",
29 |     "scope": null,
30 |     "escapedName": "jconv",
31 |     "name": "jconv",
32 |     "rawSpec": "",
33 |     "spec": "latest",
34 |     "type": "tag"
35 |   },
36 |   "_requiredBy": [
37 |     "#USER"
38 |   ],
39 |   "_resolved": "https://registry.npmjs.org/jconv/-/jconv-0.1.5.tgz",
40 |   "_shasum": "c650edba4cc2ce6dd292bf3910b123433c4b47f5",
41 |   "_shrinkwrap": null,
42 |   "_spec": "jconv",
43 |   "_where": "E:\\GPs\\ys8\\status.tbb",
44 |   "auther": "narirou <narirou.github@gmail.com>",
45 |   "bugs": {
46 |     "url": "https://github.com/narirou/jconv/issues"
47 |   },
48 |   "dependencies": {},
49 |   "description": "Pure JavaScript Iconv for Japanese encodings. (Shift_JIS, ISO-2022-JP, EUC-JP, UTF-8, UCS-2)",
50 |   "devDependencies": {
51 |     "async": "*",
52 |     "benchmark": "*",
53 |     "grunt": "~0.4.2",
54 |     "grunt-closurecompiler": "*",
55 |     "grunt-mocha-test": "*",
56 |     "iconv": "*",
57 |     "should": "*"
58 |   },
59 |   "directories": {},
60 |   "dist": {
61 |     "shasum": "c650edba4cc2ce6dd292bf3910b123433c4b47f5",
62 |     "tarball": "https://registry.npmjs.org/jconv/-/jconv-0.1.5.tgz"
63 |   },
64 |   "engines": {
65 |     "node": ">=0.8.0"
66 |   },
67 |   "homepage": "https://github.com/narirou/jconv",
68 |   "keywords": [
69 |     "iconv",
70 |     "encode",
71 |     "encoding",
72 |     "charset",
73 |     "japanese"
74 |   ],
75 |   "license": "MIT",
76 |   "main": "jconv.js",
77 |   "maintainers": [
78 |     {
79 |       "name": "narirou",
80 |       "email": "narirou.github@gmail.com"
81 |     }
82 |   ],
83 |   "name": "jconv",
84 |   "optionalDependencies": {},
85 |   "readme": "ERROR: No README data found!",
86 |   "repository": {
87 |     "type": "git",
88 |     "url": "git+https://github.com/narirou/jconv.git"
89 |   },
90 |   "scripts": {
91 |     "test": "grunt test"
92 |   },
93 |   "version": "0.1.5"
94 | }
95 | 


--------------------------------------------------------------------------------
/tbbconv/node_modules/jconv/READMEja.md:
--------------------------------------------------------------------------------
 1 | jconv
 2 | ====================
 3 | 
 4 | > Pure JavaScript Iconv for Japanese encodings.
 5 | 
 6 | [![Build Status](https://secure.travis-ci.org/narirou/jconv.png?branch=master)](https://travis-ci.org/narirou/jconv)
 7 | [![NPM version](https://badge.fury.io/js/jconv.png)](http://badge.fury.io/js/jconv)
 8 | 
 9 |  * *Shift_JIS(CP932)、ISO-2022-JP(-1)、EUC-JP、UTF8、UNICODE* の相互変換を行うモジュールです。
10 |  * JavaScriptのみで書かれているため、コンパイルは必要ありません。
11 |  * [node-iconv](https://github.com/bnoordhuis/node-iconv)よりも高速に変換を行います。
12 | 
13 | ## インストール
14 | ```bash
15 | $ npm install jconv
16 | ```
17 | 
18 | ## 使い方
19 | **EUC-JP** から **Shift_JIS** に変換したい場合は、次のようにします。
20 | 
21 | ```javascript
22 | var jconv = require( 'jconv' );
23 | 
24 | var SJISBuffer = jconv.convert( EUCJPBuffer, 'EUCJP', 'SJIS' );
25 | ```
26 | 
27 | **iconv-lite** 形式のAPIも利用可能です。
28 | 
29 | ```javascript
30 | var str = jconv.decode( buffer, fromEncoding );
31 | 
32 | var buf = jconv.encode( 'string', toEncoding );
33 | ```
34 | 
35 | ## API
36 |  * **jconv( input, fromEncoding, toEncoding )**  
37 |  * **jconv.convert( input, fromEncoding, toEncoding )**  
38 |     * `input` {Buffer} または {String}  
39 |     * `fromEncoding`, `toEncoding` {String}:  
40 |       変換元のエンコードと、変換先のエンコードを指定します。  
41 |       *Shift_JIS(SJIS,CP932)、ISO-2022-JP(JIS)、EUCJP、UTF8、UNICODE(UCS2,UTF16LE)* のいずれかを指定してください。  
42 |     * `return` {Buffer}  
43 | 
44 |  * **jconv.decode( inputBuffer, fromEncoding )**  
45 |     * `return` {String}  
46 | 
47 |  * **jconv.encode( inputString, toEncoding )**  
48 |     * `return` {Buffer}  
49 | 
50 |  * **jconv.encodingExists( encodingName )**  
51 |     * `return` {Boolean}
52 | 
53 | ## 速度
54 | node-iconv@2.0.7 との変換速度の比較です。[夏目漱石 こころ](http://www.aozora.gr.jp/cards/000148/files/773_14560.html)
55 | のテキストを、 [Benchmark.js](https://github.com/bestiejs/benchmark.js) を利用して変換速度を計測したものになります。  
56 | 環境は *Windows7, core i5 2405-S, mem8G, Node 0.10.22*です。 (利用する環境で計測してみてください。)  
57 | `グレー`がiconv、`青色`がjconvで、高い方がより高速です。  
58 | 
59 | ![jconv - encoding speed test chart](./test/chart/speedLog.png)
60 | [[latest log]](./test/chart/speedLog.txt)  
61 | <!-- https://raw.github.com/narirou/jconv/master/ -->
62 | 
63 | ## エンコードについて
64 |  * Shift_JIS(CP932), ISO-2022-JP(-1), EUC-JP, UTF8, UNICODE(UCS2) の相互変換をサポートしています。   
65 |    「秀丸エディタ」とほぼ同じ変換内容になります。 
66 | 
67 |  * Windowsの機種依存文字を変換できます。  
68 | [(問題詳細)](http://support.microsoft.com/default.aspx?scid=kb;ja;JP170559)  
69 | 
70 |  * "JIS X 0208"、"JIS X 0212"、"CP932" には、ユニコード変換テーブルに相違点があり、
71 |    いくつかの特殊な文字 ( ～￠￡∥ など ) では、デフォルトで相互変換を行うことが出来ません。  
72 |    このモジュールではテーブルの修正を行うことで相互変換できるようにしていますが、
73 |    定義に厳格な変換を行いたい場合は、 node-iconv に libiconv の日本語用修正パッチを当てたモジュールを使用してください。  
74 | [(問題詳細)](http://www8.plala.or.jp/tkubota1/unicode-symbols-map2.html)  
75 | 
76 | ## 参考
77 |  * [iconv-lite](https://github.com/ashtuchkin/iconv-lite) by ashtuchkin.
78 |  * [Encoding.js](https://github.com/polygonplanet/Unzipper.js) by polygonplanet.
79 |  * [iconv-js](https://github.com/Hikaru02/iconv-js) by Hikaru02.
80 |  * [node-iconv](https://github.com/bnoordhuis/node-iconv) by bnoordhuis.
81 |  * [libiconv-1.9.1-ja-patch Description](http://www2d.biglobe.ne.jp/~msyk/software/libiconv-1.9.1-patch.html) by 森山 将之.
82 | 
83 | ありがとうございます。
84 | 
85 | ## Note
86 | Pull requests are welcome.
87 | 
88 | ## Todo
89 |  * Streaming API support
90 | 


--------------------------------------------------------------------------------
/Translation.md:
--------------------------------------------------------------------------------
 1 | 
 2 | # How to translate Ys VIII with these tools ?
 3 | 
 4 | - First you need the Japanese (PCSG00881) game with the 1.02 update & the dumped english assets including the 1.01 update (tested on the EUR version, PCSB01128). Seems the chinese game as base works better though !
 5 | - Replace rootast.xai & patch101.xai with english ones first
 6 | - Now, we need to fix the japanese patch102.xai with english.
 7 | To do that, use the XAST Unpacker to extract english rootast.xai & patch101.xai & japanese patch102.xai
 8 | - Now replace all files in patch102.xai with their english version in patch101.xai, or rootast.xai if not in 1.01, except flash/pkg_menu.xai & system/1stload.dat which must not change
 9 | - Then, we must patch the japanese system/1stload.dat
10 | - First use the DAT Unpacker to extract both japanese / english system/1stload.dat files
11 | - Now use the `swap.sh` bash script on `1stload.list` and english then japanese directories created in last step.
12 | Something like `./swap.sh 1stload.list 1stload_eng/ 1stload_jap/`, otherwise you can just replace each non-commented file in `1stload.list` with its english version (`swap.sh` does that)
13 | - Some files from 1stload.list will be missing from the extracted english 1stload.dat, so just check which ones are missing according to what failed on last step & get those files from the extracted patch101.xai or else rootast.xai english files.
14 | Then, reproduce the last step again, it should work fine now.
15 | - Now we'll patch the japanese flash/pkg_menu.xai
16 | - First use the XAST Unpacker to extract both japanese / english flash/pkg_menu.xai files
17 | - Now use the `swap.sh` bash script on `pkg_menu.list` and english then japanese directories created in last step.
18 | Something like `./swap.sh pkg_menu.list pkg_menu_eng/ pkg_menu_jap/`, otherwise you can just replace each non-commented file in `pkg_menu.list` with its english version (`swap.sh` does that)
19 | - For pl_const.plt & lit_rtxt.csv from from 1stload.dat, you need to hack more manually
20 | - For pl_const.plt, just use the english one for the chinese game. For the Japanese game, you have to convert the encoding to SHIFT-JIS by first unpacking it, & then once fixed repack it using the PLT tools
21 | - For lit_rtxt.csv, with the Japanese game you have to convert the encoding to SHIFT-JIS again.
22 | Then, you must change the quote system used here. Indeed, english uses quotes like "this", you have to convert them to something like 「this」 (take the quote characters directly from the original game's file to make sure the encoding is right !)
23 | - Now for the japanese version only, unpack & then repack uncommented files from tbb2shift.list in 1stload.dat using TBB tools with `--enc shift-jis`, & place these in your patched 1stload folder (this should fix encoding issues)
24 | - Finally, repack the fixed 1stload.dat & pkg_menu.xai files using the `dat` & `xai` tools, use it as system/1stload.dat & flash/pkg_menu.xai in 102 & then repack 102 using the XAST Packer.
25 | Something like `./xai patch102_fix patch102_fixed.xai patch102_untouched.xai`
26 | - Finished for patch 1.02, just use the generated patch102_fixed.xai file as patch102.xai in your japanese game folder & have fun.
27 | - Some other steps are required to fix some encoding issues in scenes for instance, for that you can use the `encScripts.sh` script. Some other smalls files need encoding fixes (details) &, also some files have $n separators which must be converted to spaces instead
28 | - Additionally, you can use the eboot patcher below to fix some details from the eboot itself
29 | 


--------------------------------------------------------------------------------
/undat.cpp:
--------------------------------------------------------------------------------
  1 | // XAST Unpacker by yosh778
  2 | 
  3 | #include <string>
  4 | #include <iostream>
  5 | #include <algorithm>
  6 | 
  7 | #include <sstream>
  8 | #include <fstream>
  9 | #include <cinttypes>
 10 | #include <boost/filesystem.hpp>
 11 | 
 12 | uint32_t read32(std::ifstream& input) {
 13 | 	uint32_t data;
 14 | 	input.read((char*)&data, (int)sizeof(data));
 15 | 	return data;
 16 | }
 17 | 
 18 | uint64_t read64(std::ifstream& input) {
 19 | 	uint64_t data;
 20 | 	input.read((char*)&data, (int)sizeof(data));
 21 | 	return data;
 22 | }
 23 | 
 24 | int main(int argc, char *argv[])
 25 | {
 26 | 	if ( argc < 3 ) {
 27 | 		std::cerr << "Usage : " << argv[0] << " <input> <output>" << std::endl;
 28 | 		return -1;
 29 | 	}
 30 | 
 31 | 	std::string iDir = argv[1];
 32 | 	std::string oDir = argv[2];
 33 | 
 34 | 	std::ifstream file( iDir.c_str(), std::ios_base::binary );
 35 | 
 36 | 	if ( !file.is_open() )
 37 | 		return -2;
 38 | 
 39 | 	uint32_t data;
 40 | 
 41 | 	// Version : 1.01
 42 | 	uint32_t nbEntries = read32(file); // nbEntries
 43 | 	nbEntries = read32(file); // nbEntries
 44 | 	nbEntries = read32(file); // nbEntries
 45 | 	nbEntries = read32(file); // nbEntries
 46 | 	uint32_t dataOffset = 0x10 + 0x20 * nbEntries;
 47 | 
 48 | 	// std::cout << "Number of declared entries      : " << nbEntries << std::endl;
 49 | 
 50 | 	uint64_t *fileSizes = new uint64_t[nbEntries];
 51 | 	uint64_t *fileOffsets = new uint64_t[nbEntries];
 52 | 	uint32_t i = 0;
 53 | 
 54 | 	char **fileNames = new char*[nbEntries];
 55 | 
 56 | 	for (i = 0; i < nbEntries; i++) {
 57 | 
 58 | 		char *fileName = new char[0x10];
 59 | 		file.read(fileName, 0x10);
 60 | 		fileNames[i] = fileName;
 61 | 		std::cout << fileName << std::endl;
 62 | 
 63 | 		// std::cout << "fileoffset : 0x" << std::hex << file.tellg() << std::endl;
 64 | 		fileOffsets[i] = read32(file);
 65 | 		fileSizes[i] = read32(file);
 66 | 		// std::cout << "offset     : 0x" << std::hex << fileOffsets[i] << std::endl;
 67 | 		// std::cout << "size       : 0x" << std::hex << fileSizes[i] << std::endl;
 68 | 
 69 | 		uint32_t padding = read64(file);
 70 | 	}
 71 | 
 72 | 	if ( file.tellg() != dataOffset ) {
 73 | 		std::cerr << "Error while reading header : " << std::hex << file.tellg()
 74 | 			<< " != " << dataOffset << std::dec << std::endl;
 75 | 		return -2;
 76 | 	}
 77 | 
 78 | 
 79 | 	uint8_t *buf = NULL;
 80 | 	uint32_t bufSize = 0;
 81 | 	uint32_t nFoundEntries = 0;
 82 | 
 83 | 	for ( i = 0; i < nbEntries; i++ ) {
 84 | 
 85 | 		uint32_t offset = fileOffsets[i];
 86 | 		uint32_t size = fileSizes[i];
 87 | 
 88 | 		if ( !offset || !size )
 89 | 			continue;
 90 | 
 91 | 		nFoundEntries++;
 92 | 		// std::cout << "Number of extracted entries     : " << std::dec << nFoundEntries << std::endl;
 93 | 		// std::cout << "offset     : 0x" << std::hex << offset << std::endl;
 94 | 		// std::cout << "size     : 0x" << std::dec << size << std::endl;
 95 | 
 96 | 		file.seekg( offset );
 97 | 
 98 | 		if ( size > bufSize ) {
 99 | 			buf = (uint8_t*)realloc( buf, size );
100 | 			bufSize = size;
101 | 		}
102 | 
103 | 		file.read( (char*)buf, size );
104 | 
105 | 		std::string base = fileNames[i];
106 | 		std::string opath( oDir + "/" + base );
107 | 		std::cout << base << std::endl;
108 | 
109 | 
110 | 		boost::system::error_code returnedError;
111 | 		boost::filesystem::path path( opath );
112 | 		//std::cout << path.parent_path() << std::endl;
113 | 
114 | 		boost::filesystem::create_directories(
115 | 			path.parent_path(), returnedError
116 | 		);
117 | 
118 | 
119 | 		std::ofstream output( opath.c_str(), std::ios_base::trunc | std::ios_base::binary );
120 | 
121 | 		if ( !output.is_open() )
122 | 			continue;
123 | 
124 | 		output.write( (char*)buf, size );
125 | 		output.close();
126 | 	}
127 | 
128 | 	std::cerr <<
129 | 	std::endl << "Number of declared entries      : " << nbEntries << std::endl;
130 | 	std::cerr << "Number of extracted entries     : " << nFoundEntries << std::endl;
131 | 
132 | 	file.close();
133 | 
134 | 	return 0;
135 | }
136 | 
137 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Ys VIII Unpacking / Packing tools
  2 | 
  3 | Unpacking & Packing tools for Ys VIII assets
  4 | 
  5 | 
  6 | ## How to translate Ys VIII with it ?
  7 | 
  8 | Follow the guide [here](https://github.com/yosh778/YsVIII-tools/blob/master/Translation.md).
  9 | 
 10 | WARNING : This guide is mostly informative may not contain some complex or more recent steps
 11 | 
 12 | ## Eboot patcher
 13 | 
 14 | Usage : `python3 patchEboot.py <eboot>`
 15 | 
 16 | This python script enables you to apply eboot specific patches. For mai dumps, run it on both the base eboot.bin & mai_moe/eboot_origin.bin.
 17 | This patch allows you to get the savedata level text to display as "Lv 17" instead of "Lv17" for instance, just like the US/EU game does.
 18 | 
 19 | 
 20 | ## XAST
 21 | ### Unpacker
 22 | 
 23 | Usage : `unxai <input> <output>`
 24 | 
 25 | Extracts all files from an input XAST archive into the given output directory.
 26 | 
 27 | 
 28 | ### Packer
 29 | 
 30 | Usage : `xai <folder> <output> (<original>)`
 31 | 
 32 | Packs a whole folder as a XAST output archive.
 33 | 
 34 | If the original .xai archive is given as third argument,
 35 | it will use the same header structure to avoid game compatibility issues (recommanded).
 36 | 
 37 | WARNING : When specifying the original .xai, DO NOT add new files (not supported yet).
 38 | 
 39 | 
 40 | ### Patcher
 41 | 
 42 | Usage : `xaiPatch <inputXai> <inputFile> <filename>`
 43 | 
 44 | Replaces a specific file from the input XAST archive with a new one.
 45 | You must provide the correct filepath from the XAST archive as filename (example : flash/pl_const.plt)
 46 | 
 47 | WARNING : both files must be the same size
 48 | 
 49 | 
 50 | ## DAT
 51 | ### Unpacker
 52 | 
 53 | Usage : `undat <input> <output>`
 54 | 
 55 | Extracts all files from an input DAT archive into the given output directory.
 56 | 
 57 | 
 58 | ### Packer
 59 | 
 60 | Usage : `dat <folder> <output>`
 61 | 
 62 | Packs a whole folder as a DAT output archive.
 63 | 
 64 | WARNING : filenames must not be more than 15 characters, also no folder structure should be used in theory.
 65 | 
 66 | ## PLT
 67 | ### Unpacker
 68 | 
 69 | Usage : `unplt <input> <output>`
 70 | 
 71 | Extracts all strings from an input PLT archive into the given output text file.
 72 | 
 73 | ### Packer
 74 | 
 75 | Usage : `plt <input> <output>`
 76 | 
 77 | Packs all strings from an input text file into the given output PLT archive.
 78 | 
 79 | ## TBB
 80 | 
 81 | Requires Node.js 6+ (8.5 recommended)
 82 | 
 83 | ### Unpacker
 84 | 
 85 | Usage : `node tbbconv/tbbconv.js unpack <inputTBB> <outputCSV>`
 86 | 
 87 | Converts a TBB input file into a CSV output file.
 88 | 
 89 | 
 90 | ### Packer
 91 | 
 92 | Usage : `node tbbconv/tbbconv.js pack <inputCSV> <outputTBB> (--enc shift-jis)`
 93 | 
 94 | Converts a CSV input file into a TBB output file.
 95 | 
 96 | When workingon the Japanese game, add the `--enc shift-jis` argument to repack into shift-jis.
 97 | 
 98 | 
 99 | ## Scripting
100 | 
101 | ### Disassembler
102 | 
103 | Usage : `bin2script <byteScript>`
104 | 
105 | Converts a bytecode script into text.
106 | Credits to [weaknespase](https://github.com/weaknespase) for the [file format reverse](https://gist.github.com/weaknespase/d0a26fbc21a77616199969fe08cd48c2)
107 | 
108 | 
109 | ### Assembler
110 | 
111 | Usage : `script2bin <script> <output> (--enc-shift-jis) (--dec-shift-jis) (--preserve-string-sizes)`
112 | 
113 | Converts a script back into bytecode.
114 | 
115 | - Add `--enc-shift-jis` to convert game text strings from utf8 back into shift-jis.
116 | - Add `--dec-shift-jis` to convert game text strings from shift-jis into utf8 (experiemental)
117 | - If you specify `--preserve-string-sizes`, `--enc-shift-jis` & `--dec-shift-jis` options will attempt to preserve the original string sizes after conversion (by adding spaces or removing last characters)
118 | 
119 | ### RPN arithmetics
120 | 
121 | More information about the RPN arithmetic arguments used in conditions & calculations can be found here : https://gist.github.com/weaknespase/d0a26fbc21a77616199969fe08cd48c2#vcalc-operators
122 | 
123 | You can also find here my first write-up about it : https://gist.github.com/yosh778/141f78102cbcb15673b2375002e52a76
124 | 
125 | 
126 | # Credits
127 | 
128 | - Tony Blue for helping get the game on 3.60
129 | - [weaknespase](https://github.com/weaknespase) for the XAST checksum, TBB tools, script reversing, ... our trump card :)
130 | - [vampirexxxx](https://github.com/vampirexxxx) who is a big help in hacking the assets !
131 | 


--------------------------------------------------------------------------------
/tbbconv/node_modules/jconv/README.md:
--------------------------------------------------------------------------------
  1 | jconv
  2 | ====================
  3 | 
  4 | > Pure JavaScript Iconv for Japanese encodings.
  5 | 
  6 | [![Build Status](https://secure.travis-ci.org/narirou/jconv.png?branch=master)](https://travis-ci.org/narirou/jconv)
  7 | [![NPM version](https://badge.fury.io/js/jconv.png)](http://badge.fury.io/js/jconv)
  8 | 
  9 |  * This module supported the encodings commonly used in Japanese Language:  
 10 |    *Shift_JIS(CP932), ISO-2022-JP(-1), EUC-JP, UTF8, UNICODE(UCS2)* conversion.
 11 |  * Pure Javascript, no need to compile.
 12 |  * Much faster than [node-iconv](https://github.com/bnoordhuis/node-iconv).
 13 | 
 14 | [[Japanese 日本語]](https://github.com/narirou/jconv/blob/master/READMEja.md)
 15 | 
 16 | ## Installation
 17 | ```bash
 18 | $ npm install jconv
 19 | ```
 20 | 
 21 | ## Usage
 22 | For example simply convert from **EUC-JP** to **Shift_JIS**:
 23 | 
 24 | ```javascript
 25 | var jconv = require( 'jconv' );
 26 | 
 27 | var SJISBuffer = jconv.convert( EUCJPBuffer, 'EUCJP', 'SJIS' );
 28 | ```
 29 | 
 30 | Also available **iconv-lite** syntax:
 31 | 
 32 | ```javascript
 33 | var str = jconv.decode( buffer, fromEncoding );
 34 | 
 35 | var buf = jconv.encode( 'string', toEncoding );
 36 | ```
 37 | 
 38 | ## API
 39 |  * **jconv( input, fromEncoding, toEncoding )**  
 40 |  * **jconv.convert( input, fromEncoding, toEncoding )**  
 41 |     * `input` {Buffer} or {String}  
 42 |     * `fromEncoding`, `toEncoding` {String}:  
 43 |        *Shift_JIS(SJIS), ISO-2022-JP(JIS), EUCJP, UTF8, UNICODE(UCS2, UTF16LE)* are available.  
 44 |     * `return` {Buffer}  
 45 | 
 46 |  * **jconv.decode( inputBuffer, fromEncoding )**  
 47 |     * `return` {String}  
 48 | 
 49 |  * **jconv.encode( inputString, toEncoding )**  
 50 |     * `return` {Buffer}  
 51 | 
 52 |  * **jconv.encodingExists( encodingName )**  
 53 |     * `return` {Boolean}
 54 | 
 55 | ## Performance
 56 | Comparison with node-iconv@2.0.7 by converting [Japanese text](http://www.aozora.gr.jp/cards/000148/files/773_14560.html)
 57 | using [Benchmark.js](https://github.com/bestiejs/benchmark.js).  
 58 | Environment is *Windows7, core i5 2405-S, mem8G, Node 0.10.22*.
 59 | (Please check on your hardware.)  
 60 | `Gray`: iconv, `Blue`: jconv (higher is better)  
 61 | 
 62 | ![jconv - encoding speed test chart](https://raw.github.com/narirou/jconv/master/test/chart/speedLog.png)
 63 | [[latest log]](https://github.com/narirou/jconv/blob/master/test/chart/speedLog.txt)  
 64 | 
 65 | ## Encodings
 66 |  * Supported: Shift_JIS(CP932), ISO-2022-JP(-1), EUC-JP, UTF8, UNICODE(UCS2).  
 67 |  
 68 |  * Supported Windows Dependent Characters <-> JIS Conversion.  
 69 | [(problem details)](http://support.microsoft.com/default.aspx?scid=kb;ja;JP170559)  
 70 | 
 71 |  * "JIS X 0208", "JIS X 0212" and "CP932" have the Unicode Mapping Table Differences,
 72 |   so the specific characters ( ～￠￡∥ etc... ) cannot be round-trip converted by default.  
 73 |  This module corrects this difference as much as possible when converting.  
 74 | [(problem details)](http://www8.plala.or.jp/tkubota1/unicode-symbols-map2.html)  
 75 | 
 76 | ## Development 
 77 |  * Clone Repository  
 78 | ```
 79 | git clone https://github.com/narirou/jconv.git  
 80 | cd jconv  
 81 | npm install
 82 | ```
 83 | 
 84 |  * Generate Tables  
 85 | ```
 86 | # generates the unicode mapping table module in "tables" folder.
 87 | node generators/generate-source  
 88 | node generators/generate
 89 | ```
 90 | 
 91 |  * Test
 92 | ```
 93 | grunt test
 94 | ```
 95 | 
 96 |  * Speed Test  
 97 | ```
 98 | # First, minify the script by closure-compiler.
 99 | grunt minify
100 | ```
101 | ``` 
102 | node test/speed  
103 | # This results are visualized by chart.js.  
104 | # Plese open "chart/index.html".
105 | ```
106 | 
107 | ## Based on
108 |  * [iconv-lite](https://github.com/ashtuchkin/iconv-lite) by ashtuchkin.
109 |  * [Encoding.js](https://github.com/polygonplanet/Unzipper.js) by polygonplanet.
110 |  * [iconv-js](https://github.com/Hikaru02/iconv-js) by Hikaru02.
111 |  * [node-iconv](https://github.com/bnoordhuis/node-iconv) by bnoordhuis.
112 |  * [libiconv-1.9.1-ja-patch Description](http://www2d.biglobe.ne.jp/~msyk/software/libiconv-1.9.1-patch.html) by 森山 将之.
113 | 
114 | Thank you so much!
115 | 
116 | ## Note
117 | Pull requests are welcome.
118 | 
119 | ## Todo
120 |  * Streaming API support
121 |  * Support more encodings and languages.
122 | 


--------------------------------------------------------------------------------
/tbbconv/tbbconv.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Example parser and rebuilder of binary string table files, found in YS8.
  3 |  */
  4 | 
  5 | var fs = require("fs");
  6 | var jconv = require("jconv");
  7 | 
  8 | var input = null;
  9 | var output = null;
 10 | var mode = "help";
 11 | var enc = "utf8";
 12 | 
 13 | if (process.argv[2] == "pack") {
 14 |     mode = "pack";
 15 | } else if (process.argv[2] == "unpack") {
 16 |     mode = "unpack";
 17 | } else {
 18 |     console.error("Invalid mode specified.");
 19 | }
 20 | 
 21 | for (var i = 3; i < process.argv.length; i++){
 22 |     let arg = process.argv[i];
 23 |     if (arg == "--enc") {
 24 |         enc = process.argv[++i];
 25 |     } else {
 26 |         if (input == null) {
 27 |             input = arg;
 28 |         } else {
 29 |             output = arg;
 30 |         }
 31 |     }
 32 | }
 33 | 
 34 | if (input == null) {
 35 |     console.error("No input file specified.");
 36 |     mode = "help";
 37 | } else if (output == null) {
 38 |     console.error("No output file specified.");
 39 |     mode = "help";
 40 | } else if (!enc) {
 41 |     enc = "utf8";
 42 |     console.error("Using default encoding: utf8.");
 43 | }
 44 | 
 45 | switch (mode) {
 46 |     case "pack":
 47 |         packFile(input, output, enc);
 48 |         break;
 49 |     case "unpack":
 50 |         unpackFile(input, output, enc);
 51 |         break;
 52 |     case "help":
 53 |         console.error("Usage:\n\tnode tbbconv.js pack|unpack [--enc <encoding>] input output\n");
 54 |         break;    
 55 | }
 56 | 
 57 | function packFile(src, dst, enc) {
 58 |     //Pack CSV into bin
 59 |     
 60 |     var csv = fs.readFileSync(src, "utf8");
 61 | 
 62 |     //Split by rows and columns removing empty lines
 63 |     var csvl = csv.split(/\r\n|\r|\n/);
 64 |     for (var i = 0; i < csvl.length; i++){
 65 |         if (csvl[i].length == 0) {
 66 |             csvl.splice(i, 1);
 67 |             i--;
 68 |             continue;
 69 |         }
 70 |         csvl[i] = csvl[i].split("\t");
 71 |     }
 72 | 
 73 |     var cols = csvl[0].length;
 74 |     var rows = csvl.length;
 75 |     var count = cols * rows;
 76 | 
 77 |     console.log("Encoding CSV file into TBB.");
 78 |     console.log(`${count} strings in ${rows} rows and ${cols} columns.`);
 79 | 
 80 |     var ofd = fs.openSync(dst, "w");
 81 | 
 82 |     var head = Buffer.alloc(12);
 83 |     head.writeUInt32LE(cols, 0);
 84 |     head.writeUInt32LE(rows, 4);
 85 | 
 86 |     //Write header
 87 |     fs.writeSync(ofd, head, 0, head.length);
 88 | 
 89 |     var strenc = function(string) {
 90 |         return Buffer.from(string, enc);
 91 |     }
 92 |     if (enc == "shift-jis") {
 93 |         strenc = function(string) {
 94 |             return jconv.encode(string, "SJIS");
 95 |         }
 96 |     }
 97 | 
 98 |     //Begin writing strings
 99 |     var blocklen = 0;
100 |     var offsets = Buffer.alloc(count * 4);
101 |     for (var r = 0; r < rows; r++){
102 |         for (var c = 0; c < cols; c++){
103 |             //Write offset
104 |             offsets.writeUInt32LE(blocklen, (r * cols + c) * 4);
105 | 
106 |             //Write string
107 |             var b = strenc(csvl[r][c] + "\x00");
108 |             fs.writeSync(ofd, b, 0, b.length);
109 |             
110 |             //Advance offset
111 |             blocklen += b.length;
112 |         }
113 |     }
114 | 
115 |     console.log(`Wrote ${blocklen} bytes strings table.`);
116 | 
117 |     fs.writeSync(ofd, offsets, 0, offsets.length);
118 | 
119 |     console.log(`Wrote ${offsets.length} bytes offset table.`);
120 | 
121 |     //Write corrected header
122 |     head.writeUInt32LE(blocklen, 0x8);
123 |     fs.writeSync(ofd, head, 0, head.length, 0);
124 | 
125 |     fs.closeSync(ofd);
126 | }
127 | 
128 | function unpackFile(src, dst, enc) {
129 |     //Unpack bin to CSV
130 |     var buf = fs.readFileSync(src);
131 | 
132 |     var cols = buf.readUInt32LE(0x0);
133 |     var rows = buf.readUInt32LE(0x4);
134 |     var len = buf.readUInt32LE(0x8);
135 | 
136 |     var strings = buf.slice(0xC, len + 0xC);
137 |     var offsets = buf.slice(0xC + len);
138 | 
139 |     //Convert offsets
140 |     {
141 |         var a = new Array(offsets.length / 4);
142 |         for (var i = 0; i < offsets.length; i += 4){
143 |             a[i / 4 | 0] = offsets.readUInt32LE(i);
144 |         }
145 |         offsets = a;
146 |     }
147 | 
148 |     var count = cols * rows;
149 | 
150 |     console.log("Opened binary TBB file.");
151 |     console.log(`String table: ${strings.length} bytes.`);
152 |     console.log(`${count} strings in ${rows} rows and ${cols} columns.`);
153 | 
154 |     var ofd = fs.openSync(dst, "w");
155 | 
156 |     var strdec = function(buf, start, end) {
157 |         return buf.toString(enc, start, end);
158 |     }
159 |     if (enc == "shift-jis") {
160 |         strdec = function(buf, start, end) {
161 |             return jconv.decode(buf.slice(start, end), "SJIS");
162 |         }
163 |     }
164 |     
165 |     for (var r = 0; r < rows; r++){
166 |         let out = "";
167 |         for (var c = 0; c < cols; c++) {
168 |             let idx = r * cols + c;
169 |             let next = a[idx];
170 |             while (strings[next++] != 0);
171 |             //Cut out null terminator
172 |             out += strdec(strings, a[idx], next-1) + "\t";
173 |         }
174 |         out = out.substr(0, out.length - 1) + "\r\n";
175 |         fs.writeSync(ofd, out, null, "utf8");
176 |     }
177 | 
178 |     fs.close(ofd);
179 | }
180 | 
181 | 


--------------------------------------------------------------------------------
/xaiPatch.cpp:
--------------------------------------------------------------------------------
  1 | // XAST Patcher by yosh778
  2 | 
  3 | #include <string>
  4 | #include <iostream>
  5 | #include <algorithm>
  6 | 
  7 | #include <sstream>
  8 | #include <fstream>
  9 | #include <cinttypes>
 10 | #define RBUF_SIZE 0x1000000
 11 | 
 12 | uint32_t read32(std::fstream& input) {
 13 | 	uint32_t data;
 14 | 	input.read((char*)&data, (int)sizeof(data));
 15 | 	return data;
 16 | }
 17 | 
 18 | uint64_t read64(std::fstream& input) {
 19 | 	uint64_t data;
 20 | 	input.read((char*)&data, (int)sizeof(data));
 21 | 	return data;
 22 | }
 23 | 
 24 | void write32(std::fstream& output, uint32_t data) {
 25 | 	output.write((char*)&data, (int)sizeof(data));
 26 | }
 27 | 
 28 | // Checksum reverse by weaknespase
 29 | uint32_t checksum(const char* in, const uint32_t length, int last = 0){
 30 | 	const char* end = in + length;
 31 | 	int acc = last;
 32 | 	while (in < end)
 33 | 		acc = (acc * 33) ^ (unsigned char) *in++;
 34 | 	return acc;
 35 | }
 36 | 
 37 | int main(int argc, char *argv[])
 38 | {
 39 | 	if ( argc < 4 ) {
 40 | 		std::cerr << "Usage : " << argv[0] << " <inputXai> <inputFile> <filename>" << std::endl;
 41 | 		return -1;
 42 | 	}
 43 | 
 44 | 	std::string iXai = argv[1];
 45 | 	std::string iFile = argv[2];
 46 | 	std::string iFileName = argv[3];
 47 | 
 48 | 	uint32_t fHash = checksum( iFileName.c_str(), iFileName.size() );
 49 | 
 50 | 	std::fstream file( iXai.c_str(), std::ios_base::in | std::ios_base::out | std::ios_base::binary );
 51 | 
 52 | 	if ( !file.is_open() ) {
 53 | 		std::cerr << "ERROR : input XAST not found" << std::endl;
 54 | 		return -2;
 55 | 	}
 56 | 
 57 | 	uint32_t data;
 58 | 
 59 | 	// XAST header
 60 | 	uint32_t magic = read32(file);
 61 | 
 62 | 	// Version : 1.01
 63 | 	uint32_t version = read32(file);
 64 | 	uint32_t nbEntries = read32(file); // nbEntries
 65 | 	uint32_t maxEntries = read32(file); // maxEntries
 66 | 	uint32_t pathsCount = read32(file);
 67 | 	uint32_t dataOffset = read32(file);
 68 | 	uint32_t headerChecksum = read32(file);
 69 | 	uint32_t headersCount = read32(file);
 70 | 	uint32_t xaiSize = read32(file);
 71 | 
 72 | 	uint32_t pathsOffset = 0x30 + headersCount;
 73 | 
 74 | 	file.seekg(0x30);
 75 | 
 76 | 	uint64_t fileSize;
 77 | 	uint64_t fileOffset;
 78 | 	uint32_t pathOffset;
 79 | 	uint32_t pathHash;
 80 | 	uint32_t fileChecksum;
 81 | 	uint32_t nbActualEntries = 0;
 82 | 	uint32_t i = 0;
 83 | 	std::stringstream ss;
 84 | 	bool found = false;
 85 | 
 86 | 	for (i = 0; i < maxEntries; i++) {
 87 | 
 88 | 		pathHash = read32(file);
 89 | 		pathOffset = read32(file);
 90 | 		fileChecksum = read32(file);
 91 | 		uint32_t isXai = read32(file);
 92 | 		found = (pathHash == fHash);
 93 | 
 94 | 
 95 | 		ss << std::hex << pathHash << " | " << pathOffset
 96 | 			<< " | " << fileChecksum << " | " << isXai << std::endl;
 97 | 
 98 | 		if ( isXai > 1 ) {
 99 | 			std::cerr << "WARNING : unsupported value found for isXai : "
100 | 				<< isXai << std::endl;
101 | 		}
102 | 
103 | 		fileSize = read64(file);
104 | 
105 | 		ss << fileSize << std::endl;
106 | 
107 | 		if ( uint64_t padding = read64(file) ) {
108 | 			std::cerr << "WARNING : unsupported value found for padding : "
109 | 				<< padding << std::endl;
110 | 			// return -3;
111 | 		}
112 | 
113 | 		fileOffset = read64(file);
114 | 		uint64_t aSize = read64(file);
115 | 
116 | 		ss << fileOffset << " | " << aSize << std::endl << std::endl;
117 | 
118 | 		if ( found || file.tellg() >= pathsOffset ) {
119 | 			// std::cout << "break" << std::endl;
120 | 			// std::cout << std::hex << file.tellg() << std::endl;
121 | 			break;
122 | 		}
123 | 	}
124 | 
125 | 	// std::cerr << ss.str();
126 | 
127 | 	if ( !found ) {
128 | 		file.close();
129 | 		std::cerr << "File " << iFileName << " not found in this XAST" << std::endl;
130 | 		return -1;
131 | 	}
132 | 
133 | 	const uint32_t headerOffset = (i+1) * 0x30;
134 | 
135 | 
136 | 	std::ifstream input( iFile.c_str(), std::ios_base::binary );
137 | 
138 | 	if ( !input.is_open() ) {
139 | 		file.close();
140 | 		std::cerr << "Failed to open " << iFile << std::endl;
141 | 		return -2;
142 | 	}
143 | 
144 | 	std::cout << "Writing " << iFileName << " at offset 0x" << std::hex << fileOffset << std::dec << std::endl << std::endl;
145 | 
146 | 	file.seekg(fileOffset);
147 | 
148 | 	uint32_t last = 0;
149 | 	uint64_t read = 0;
150 | 	uint64_t totalRead = 0;
151 | 	uint8_t *buf = new uint8_t[RBUF_SIZE];
152 | 
153 | 	while ( input && file ) {
154 | 		input.read( (char*)buf, RBUF_SIZE );
155 | 
156 | 		if ( input )
157 | 			read = RBUF_SIZE;
158 | 
159 | 		else
160 | 			read = input.gcount();
161 | 
162 | 		totalRead += read;
163 | 
164 | 		uint64_t wSize = read;
165 | 
166 | 		if ( totalRead > fileSize ) {
167 | 			wSize -= totalRead - fileSize;
168 | 			std::cerr << "ERROR : Input file size differs ! Expected size : " << fileSize << std::endl;
169 | 		}
170 | 
171 | 		if ( wSize > 0 ) {
172 | 			last = checksum( (const char*)buf, wSize, last );
173 | 			file.write( (const char*)buf, wSize );
174 | 		}
175 | 
176 | 		if ( totalRead >= fileSize )
177 | 			break;
178 | 	}
179 | 
180 | 	input.close();
181 | 
182 | 	file.seekp(headerOffset + 8);
183 | 
184 | 	write32(file, last); // File checksum
185 | 
186 | 	std::cout << "Header offset        : 0x" << std::hex << headerOffset << std::dec << std::endl;
187 | 	std::cout << "Old file checksum    : 0x" << std::hex << fileChecksum << std::dec << std::endl;
188 | 	std::cout << "New file checksum    : 0x" << std::hex << last << std::dec << std::endl;
189 | 
190 | 	file.seekp(0x30);
191 | 
192 | 	uint32_t headerSize = 0x30 * maxEntries;
193 | 
194 | 	if ( RBUF_SIZE < headerSize ) {
195 | 		delete buf;
196 | 		buf = new uint8_t[ headerSize ];
197 | 	}
198 | 
199 | 	file.read( (char*)buf, headerSize );
200 | 	uint32_t headerCheck = checksum( (const char*)buf, headerSize);
201 | 
202 | 	file.seekp(0x18);
203 | 	write32(file, headerCheck);
204 | 
205 | 	std::cout << "Old header checksum  : 0x" << std::hex << headerChecksum << std::dec << std::endl;
206 | 	std::cout << "New header checksum  : 0x" << std::hex << headerCheck << std::dec << std::endl;
207 | 
208 | 	std::cout << std::endl << "XAST file patched with success" << std::endl;
209 | 
210 | 	return 0;
211 | }
212 | 
213 | 


--------------------------------------------------------------------------------
/dat.cpp:
--------------------------------------------------------------------------------
  1 | // DAT Packer by yosh778
  2 | 
  3 | #include <string>
  4 | #include <iostream>
  5 | #include <algorithm>
  6 | 
  7 | #include <fstream>
  8 | #include <unordered_map>
  9 | #include <cinttypes>
 10 | #include <boost/filesystem.hpp>
 11 | 
 12 | #define ALIGN_16(n) ((n / 0x10 + (n % 0x10 ? 1 : 0)) * 0x10)
 13 | #define RBUF_SIZE 0x1000000
 14 | 
 15 | using namespace boost::filesystem;
 16 | 
 17 | void write32(std::fstream& output, uint32_t data) {
 18 | 	output.write((char*)&data, (int)sizeof(data));
 19 | }
 20 | 
 21 | uint64_t write64(std::fstream& output, uint64_t data) {
 22 | 	output.write((char*)&data, (int)sizeof(data));
 23 | }
 24 | 
 25 | uint32_t read32(std::ifstream& input) {
 26 | 	uint32_t data;
 27 | 	input.read((char*)&data, (int)sizeof(data));
 28 | 	return data;
 29 | }
 30 | 
 31 | uint64_t read64(std::ifstream& input) {
 32 | 	uint64_t data;
 33 | 	input.read((char*)&data, (int)sizeof(data));
 34 | 	return data;
 35 | }
 36 | 
 37 | typedef struct FileData_ {
 38 | 	std::string fullpath;
 39 | 	std::string filename;
 40 | 	uint64_t size;
 41 | } FileData;
 42 | 
 43 | std::vector<char*> headerOrder;
 44 | 
 45 | bool alphaSorter(const FileData& a, const FileData& b)
 46 | {
 47 | 	return a.filename < b.filename;
 48 | }
 49 | 
 50 | uint32_t getHeaderOrder(std::vector<char*>& order, std::string input);
 51 | 
 52 | 
 53 | int main(int argc, char *argv[])
 54 | {
 55 | 	if ( argc < 3 ) {
 56 | 		std::cerr << "Usage : " << argv[0] << " <dataPath> <outputDat>" << std::endl;
 57 | 		return -1;
 58 | 	}
 59 | 
 60 | 	std::string inPath = argv[1];
 61 | 	std::string output = argv[2];
 62 | 	uint32_t mimicUnused = 0;
 63 | 
 64 | 	// Check input path existence
 65 | 	if ( !exists( inPath ) ) {
 66 | 	  std::cerr << "ERROR : Input directory " << inPath << " does not exist" << std::endl;
 67 | 	  return EXIT_FAILURE;
 68 | 	}
 69 | 
 70 | 	// if ( argc > 3 ) {
 71 | 	//     mimicUnused = getHeaderOrder( headerOrder, argv[3] );
 72 | 	// }
 73 | 	// else {
 74 | 	// 	std::cout << "WARNING : No original XAST archive specified, this could cause game crashes" << std::endl << std::endl;
 75 | 	// }
 76 | 
 77 | 	std::vector<FileData> files;
 78 | 
 79 | 	recursive_directory_iterator it( inPath ), end;
 80 | 	FileData fileData;
 81 | 	std::unordered_map<std::string, int> headerMap;
 82 | 	uint32_t i = 0;
 83 | 
 84 | 	// Read input directory recursively
 85 | 	for ( ; it != end; ++it ) {
 86 | 	  bool is_dir = is_directory( *it );
 87 | 
 88 | 	  std::string fullpath = it->path().string();
 89 | 	  std::replace(fullpath.begin(), fullpath.end(), '\\', '/');
 90 | 	  std::string filename = fullpath.substr( inPath.size() );
 91 | 
 92 | 	  if ( filename.front() == '/' ) {
 93 | 		filename.erase(0, 1);
 94 | 	  }
 95 | 
 96 | 	  // Skip any non-existing file
 97 | 	  if ( !exists( fullpath ) )
 98 | 		continue;
 99 | 
100 | 	  if ( !is_dir ) {
101 | 		fileData.filename = filename;
102 | 		fileData.fullpath = fullpath;
103 | 		// std::cout << "Checksum for " << filename << " : " << std::hex << fileData.pathCheck << std::dec << std::endl;
104 | 		fileData.size = file_size( fullpath );
105 | 
106 | 		files.push_back( fileData );
107 | 	  }
108 | 	}
109 | 
110 | 	// if ( argc > 3 && (headerOrder.size()-mimicUnused) != files.size() ) {
111 | 	//     std::cout << "When specifying an original file, input folder must contain the same number of files & the same filepaths as the original .xai" << std::endl;
112 | 	//     return -1;
113 | 	// }
114 | 
115 | 	std::sort (files.begin(), files.end(), alphaSorter);
116 | 
117 | 	uint32_t nbEntries = files.size();
118 | 
119 | 	std::fstream oFile( output.c_str(), std::ios_base::trunc | std::ios_base::in | std::ios_base::out | std::ios_base::binary );
120 | 
121 | 	if ( !oFile.is_open() ) {
122 | 		std::cerr << "Failed to open output file '" << output << "'" << std::endl;
123 | 		return -2;
124 | 	}
125 | 
126 | 	uint32_t dataOffset = 0x10 + 0x20 * nbEntries;
127 | 
128 | 	// XAST header
129 | 	write32(oFile, nbEntries);
130 | 	write32(oFile, nbEntries);
131 | 	write32(oFile, nbEntries);
132 | 	write32(oFile, nbEntries);
133 | 
134 | 	i = 0;
135 | 	char nameBuf[16];
136 | 	uint64_t nextFileOffset = dataOffset;
137 | 
138 | 	for ( FileData& file : files ) {
139 | 
140 | 		// std::cout << "Checksum for " << file.filename << " : " std::endl;
141 | 
142 | 		strncpy(nameBuf, file.filename.c_str(), 0x10);
143 | 		nameBuf[15] = 0;
144 | 
145 | 		oFile.write( nameBuf, 0x10 );
146 | 
147 | 
148 | 		write32(oFile, nextFileOffset);
149 | 		write32(oFile, file.size);
150 | 		write64(oFile, 0);
151 | 
152 | 		nextFileOffset += file.size;
153 | 	}
154 | 
155 | 	uint8_t *buf = new uint8_t[RBUF_SIZE];
156 | 
157 | 	if ( oFile.tellp() != dataOffset ) {
158 | 		std::cerr << "Error while writing header : " << std::hex << oFile.tellp()
159 | 			<< " != " << dataOffset << std::dec << std::endl;
160 | 		return -2;
161 | 	}
162 | 
163 | 	uint32_t n = 0; i = 0;
164 | 
165 | 	for ( FileData& file : files ) {
166 | 
167 | 		std::ifstream input( file.fullpath.c_str(), std::ios_base::binary );
168 | 
169 | 		if ( !input.is_open() ) {
170 | 			std::cerr << "Failed to open " << file.fullpath << std::endl;
171 | 			return -2;
172 | 		}
173 | 
174 | 		std::cout << "Writing " << file.filename << std::endl;
175 | 
176 | 		uint64_t read = 0;
177 | 		uint64_t totalRead = 0;
178 | 
179 | 		while ( input && oFile ) {
180 | 			input.read( (char*)buf, RBUF_SIZE );
181 | 
182 | 			if ( input )
183 | 				read = RBUF_SIZE;
184 | 
185 | 			else
186 | 				read = input.gcount();
187 | 
188 | 			oFile.write( (const char*)buf, read );
189 | 			totalRead += read;
190 | 		}
191 | 
192 | 		input.close();
193 | 
194 | 		if ( totalRead != file.size ) {
195 | 			std::cerr << "Bad file size for " << file.fullpath << std::endl;
196 | 			return -3;
197 | 		}
198 | 
199 | 		n++;
200 | 	}
201 | 
202 | 	oFile.close();
203 | 
204 | 	// if ( argc == 3 ) {
205 | 	//     std::cout << std::endl << "WARNING : No original XAST archive specified, this could cause game crashes" << std::endl;
206 | 	// }
207 | 
208 | 	std::cerr << std::endl << n << " files were included" << std::endl;
209 | 	std::cerr << "DAT archive successfully created" << std::endl;
210 | 
211 | 	return 0;
212 | }
213 | 
214 | 


--------------------------------------------------------------------------------
/unxai.cpp:
--------------------------------------------------------------------------------
  1 | // XAST Unpacker by yosh778
  2 | 
  3 | #include <string>
  4 | #include <iostream>
  5 | #include <algorithm>
  6 | 
  7 | #include <sstream>
  8 | #include <fstream>
  9 | #include <cinttypes>
 10 | #include <boost/filesystem.hpp>
 11 | 
 12 | uint32_t read32(std::ifstream& input) {
 13 | 	uint32_t data;
 14 | 	input.read((char*)&data, (int)sizeof(data));
 15 | 	return data;
 16 | }
 17 | 
 18 | uint64_t read64(std::ifstream& input) {
 19 | 	uint64_t data;
 20 | 	input.read((char*)&data, (int)sizeof(data));
 21 | 	return data;
 22 | }
 23 | 
 24 | // Checksum reverse by weaknespase
 25 | uint32_t checksum(const char* in, const uint32_t length, int last = 0){
 26 | 	const char* end = in + length;
 27 | 	int acc = last;
 28 | 	while (in < end)
 29 | 		acc = (acc * 33) ^ (unsigned char) *in++;
 30 | 	return acc;
 31 | }
 32 | 
 33 | int main(int argc, char *argv[])
 34 | {
 35 | 	if ( argc < 3 ) {
 36 | 		std::cerr << "Usage : " << argv[0] << " <input> <output>" << std::endl;
 37 | 		return -1;
 38 | 	}
 39 | 
 40 | 	std::string iDir = argv[1];
 41 | 	std::string oDir = argv[2];
 42 | 
 43 | 	std::ifstream file( iDir.c_str(), std::ios_base::binary );
 44 | 
 45 | 	if ( !file.is_open() )
 46 | 		return -2;
 47 | 
 48 | 	uint32_t data;
 49 | 
 50 | 	// XAST header
 51 | 	uint32_t magic = read32(file);
 52 | 
 53 | 	// Version : 1.01
 54 | 	uint32_t version = read32(file);
 55 | 	uint32_t nbEntries = read32(file); // nbEntries
 56 | 	uint32_t maxEntries = read32(file); // maxEntries
 57 | 	uint32_t pathsCount = read32(file);
 58 | 	uint32_t dataOffset = read32(file);
 59 | 	uint32_t unk0 = read32(file);
 60 | 	uint32_t headersCount = read32(file);
 61 | 	uint32_t fileSize = read32(file);
 62 | 
 63 | 	uint32_t pathsOffset = 0x30 + headersCount;
 64 | 
 65 | 	file.seekg(0x30);
 66 | 
 67 | 	uint64_t *fileSizes = new uint64_t[maxEntries];
 68 | 	uint64_t *fileOffsets = new uint64_t[maxEntries];
 69 | 	uint32_t *pathOffsets = new uint32_t[maxEntries];
 70 | 	uint32_t *pathHash = new uint32_t[maxEntries];
 71 | 	uint32_t *fileChecksums = new uint32_t[maxEntries];
 72 | 	uint32_t nbActualEntries = 0;
 73 | 	uint32_t i = 0;
 74 | 	std::stringstream ss;
 75 | 
 76 | 	for (i = 0; i < maxEntries; i++) {
 77 | 
 78 | 		pathHash[i] = read32(file);
 79 | 		pathOffsets[i] = read32(file);
 80 | 		fileChecksums[i] = read32(file);
 81 | 		uint32_t isXai = read32(file);
 82 | 
 83 | 		ss << std::hex << pathHash[i] << " | " << pathOffsets[i]
 84 | 			<< " | " << fileChecksums[i] << " | " << isXai << std::endl;
 85 | 
 86 | 		if ( isXai > 1 ) {
 87 | 			std::cerr << "WARNING : unsupported value found for isXai : "
 88 | 				<< isXai << std::endl;
 89 | 		}
 90 | 
 91 | 		fileSizes[i] = read64(file);
 92 | 
 93 | 		ss << fileSizes[i] << std::endl;
 94 | 
 95 | 		if ( uint64_t padding = read64(file) ) {
 96 | 			std::cerr << "WARNING : unsupported value found for padding : "
 97 | 				<< padding << std::endl;
 98 | 			// return -3;
 99 | 		}
100 | 
101 | 		fileOffsets[i] = read64(file);
102 | 		uint64_t aSize = read64(file);
103 | 
104 | 		ss << fileOffsets[i] << " | " << aSize << std::endl << std::endl;
105 | 
106 | 		if ( file.tellg() >= pathsOffset ) {
107 | 			// std::cout << "break" << std::endl;
108 | 			// std::cout << std::hex << file.tellg() << std::endl;
109 | 			break;
110 | 		}
111 | 	}
112 | 
113 | 	nbActualEntries = i + 1;
114 | 
115 | 	// std::cout << "Number of declared entries : " << maxEntries << std::endl;
116 | 	// std::cout << "Number of actual entries   : " << nbActualEntries << std::endl;
117 | 	// std::cout << "Number of used entries     : " << nbEntries << std::endl;
118 | 
119 | 	char **fileNames = new char*[maxEntries];
120 | 
121 | 	file.seekg(pathsOffset);
122 | 
123 | 	char *pathsData = new char[pathsCount];
124 | 	file.read(pathsData, pathsCount);
125 | 
126 | 	uint32_t n = 0;
127 | 	char *next = pathsData;
128 | 	char *end = pathsData + pathsCount;
129 | 
130 | 	i = 0;
131 | 
132 | 	while ( next < end ) {
133 | 
134 | 		fileNames[n++] = next;
135 | 
136 | 		ss << next << " | " << pathsOffset + i << std::endl;
137 | 
138 | 		// Prints file paths
139 | 		// std::cout << next << std::endl;
140 | 
141 | 		while ( pathsData[i++] && pathsData < end );
142 | 
143 | 		next = pathsData + i;
144 | 	}
145 | 
146 | 	uint8_t *buf = NULL;
147 | 	uint32_t bufSize = 0;
148 | 	uint32_t nFoundEntries = 0;
149 | 
150 | 	for ( i = 0; i < maxEntries; i++ ) {
151 | 
152 | 		uint32_t offset = fileOffsets[i];
153 | 		uint32_t size = fileSizes[i];
154 | 
155 | 		if ( !offset || !size ) {
156 | 			std::cout << "Skipping empty slot" << std::endl;
157 | 			continue;
158 | 		}
159 | 
160 | 		nFoundEntries++;
161 | 
162 | 		file.seekg( offset );
163 | 
164 | 		if ( size > bufSize ) {
165 | 			buf = (uint8_t*)realloc( buf, size );
166 | 			bufSize = size;
167 | 		}
168 | 
169 | 		file.read( (char*)buf, size );
170 | 
171 | 		std::string base = pathsData + (pathOffsets[i] - pathsOffset);
172 | 		std::string opath( oDir + "/" + base );
173 | 		std::cout << base << std::endl;
174 | 
175 | 		uint32_t pathCheck = checksum( (char*)base.c_str(), base.size() );
176 | 		std::cout << "Computed path checksum : " << std::hex << pathCheck << std::dec << std::endl;
177 | 		std::cout << "Original path checksum : " << std::hex << pathHash[i] << std::dec << std::endl;
178 | 
179 | 		uint32_t contentCheck = checksum( (char*)buf, size );
180 | 		std::cout << "Computed file checksum : " << std::hex << contentCheck << std::dec << std::endl;
181 | 		std::cout << "Original file checksum : " << std::hex << fileChecksums[i] << std::dec << std::endl;
182 | 
183 | 		if ( contentCheck != fileChecksums[i] )
184 | 			std::cout << "File checksum error !" << std::endl;
185 | 
186 | 
187 | 		boost::system::error_code returnedError;
188 | 		boost::filesystem::path path( opath );
189 | 		//std::cout << path.parent_path() << std::endl;
190 | 
191 | 		boost::filesystem::create_directories(
192 | 			path.parent_path(), returnedError
193 | 		);
194 | 
195 | 		std::ofstream output( opath.c_str(), std::ios_base::binary );
196 | 
197 | 		if ( !output.is_open() )
198 | 			continue;
199 | 
200 | 		output.write( (char*)buf, size );
201 | 		output.close();
202 | 	}
203 | 
204 | 	std::cerr <<
205 | 	std::endl << "Number of declared entries      : " << maxEntries << std::endl;
206 | 	std::cerr << "Number of actual entries        : " << nbActualEntries << std::endl;
207 | 	std::cerr << "Number of used entries          : " << nbEntries << std::endl;
208 | 	std::cerr << "Number of filepaths             : " << n << std::endl;
209 | 	std::cerr << "Number of extracted entries     : " << nFoundEntries << std::endl;
210 | 
211 | 	file.close();
212 | 
213 | 	return 0;
214 | }
215 | 
216 | 


--------------------------------------------------------------------------------
/sceneOpCodeNames.hh:
--------------------------------------------------------------------------------
  1 | // Scene OpCodes
  2 | 
  3 | #pragma once
  4 | 
  5 | 
  6 | const char *opCodeNames[] = {
  7 | 
  8 |   "exit",
  9 |   "Load",
 10 |   "LoadTex",
 11 |   "LoadTexAsync",
 12 |   "LoadTexWait",
 13 |   "ReleaseTex",
 14 |   "ChangeAnimation",
 15 |   "Message",
 16 |   "Wait",
 17 |   "WaitFade",
 18 |   "WaitMenu",
 19 |   "SetChrPos",
 20 |   "Move",
 21 |   "MoveTo",
 22 |   "MoveToChr",
 23 |   "MoveEx",
 24 |   "MoveToEx",
 25 |   "MoveToEx2",
 26 |   "MoveToChrEx",
 27 |   "Turn",
 28 |   "Turn2",
 29 |   "TurnTo",
 30 |   "TurnToVec",
 31 |   "TurnToChr",
 32 |   "Jump",
 33 |   "Dash",
 34 |   "ForceDash",
 35 |   "MoveZ",
 36 |   "MoveRotate",
 37 |   "ResetChrPos",
 38 |   "ClearDebris",
 39 |   "MoveCameraAt",
 40 |   "RotateCamera",
 41 |   "ChangeCameraZoom",
 42 |   "ChangeCameraPers",
 43 |   "ChangeCameraElevatio",
 44 |   "ChangeCameraDistance",
 45 |   "MoveCamera",
 46 |   "SaveCamera",
 47 |   "RestoreCamera",
 48 |   "SetStopFlag",
 49 |   "ResetStopFlag",
 50 |   "SetChrInfoFlag",
 51 |   "ResetChrInfoFlag",
 52 |   "SetFlag",
 53 |   "SetChrWork",
 54 |   "SetWork",
 55 |   "JoinParty",
 56 |   "JoinGuest",
 57 |   "SeparateParty",
 58 |   "FadeOut",
 59 |   "FadeIn",
 60 |   "CrossFade",
 61 |   "MenuReset",
 62 |   "MenuAdd",
 63 |   "MenuOpen",
 64 |   "MenuClose",
 65 |   "YesNoMenu",
 66 |   "MiniGame",
 67 |   "Play",
 68 |   "StopBGM",
 69 |   "PlaySE",
 70 |   "PlaySE3D",
 71 |   "SetName",
 72 |   "TalkMes",
 73 |   "Message2",
 74 |   "WaitPrompt",
 75 |   "ClosePrompt",
 76 |   "Portrait_Load",
 77 |   "Portrait_Unload",
 78 |   "Portrait_Create",
 79 |   "Portrait_Close",
 80 |   "Portrait_Anime",
 81 |   "Portrait3D_Set",
 82 |   "Portrait3D_Release",
 83 |   "Portrait3D_Create",
 84 |   "Portrait3D_Close",
 85 |   "Portrait3D_Anime",
 86 |   "Execute",
 87 |   "ExecuteFunc",
 88 |   "WaitThread",
 89 |   "WaitThread2",
 90 |   "StopThread",
 91 |   "StopThread2",
 92 |   "EventCue",
 93 |   "HP_Heal",
 94 |   "HP_Recover",
 95 |   "HPMax_Recover",
 96 |   "SP_Recover",
 97 |   "SPMax_Recover",
 98 |   "RepairSkillCount",
 99 |   "SetCameraMode",
100 |   "SetCameraZPlane",
101 |   "ResetCameraZPlane",
102 |   "ChangeCamera",
103 |   "Effect",
104 |   "Effect2",
105 |   "ChrEffect",
106 |   "ChrEffect2",
107 |   "ChrSpecular",
108 |   "Hagitori",
109 |   "Hagitori2",
110 |   "ChangeFace",
111 |   "HeadYes",
112 |   "HeadNo",
113 |   "Look",
114 |   "LookChr",
115 |   "LookTo",
116 |   "LookVec",
117 |   "LookReset",
118 |   "Emotion",
119 |   "MapHide",
120 |   "MapAnime",
121 |   "MapAnimeIndex",
122 |   "MapAnimeLast",
123 |   "ShopOpen",
124 |   "ShowMinipop",
125 |   "ChangeItemState",
126 |   "EventBox",
127 |   "EventBox2",
128 |   "EventAreaEnable",
129 |   "ChangeItemSlot",
130 |   "DeleteItem",
131 |   "GetItem",
132 |   "GetItemMessage",
133 |   "AddItemLog",
134 |   "ResetMotion",
135 |   "PlayMMV",
136 |   "if",
137 |   "elseIf",
138 |   "else",
139 |   "switch",
140 |   "while",
141 |   "0x8085",
142 |   "break",
143 |   "0x8087",
144 |   "case",
145 |   "default",
146 |   "FreeMove",
147 |   "ResetFollowPoint",
148 |   "ResetPartyPos",
149 |   "CurePoison",
150 |   "EarthQuake",
151 |   "SetLevel",
152 |   "EquipWeapon",
153 |   "EquipArmor",
154 |   "EquipShield",
155 |   "EquipAccessory",
156 |   "Entry",
157 |   "EntryOn",
158 |   "SetEventParam",
159 |   "SetCheckPoint",
160 |   "GetCheckPoint",
161 |   "WarpMenu",
162 |   "TopicMenu",
163 |   "DestroyObj",
164 |   "GetSkill",
165 |   "SetSkillShortCut",
166 |   "SetLeverState",
167 |   "SetLeverNotChange",
168 |   "BtlPopup",
169 |   "AddEX",
170 |   "SetPartyMember",
171 |   "SavePartyMember",
172 |   "RestorePartyMember",
173 |   "SetEventPartyChr",
174 |   "LoadEventPartyChr",
175 |   "ReleaseEventPartyChr",
176 |   "TimeStop",
177 |   "PartyMenu",
178 |   "Reset",
179 |   "DoorOpen",
180 |   "DoorClose",
181 |   "ChrAlpha",
182 |   "ChrColor",
183 |   "MapColor",
184 |   "MapDelProp",
185 |   "MapSetProp",
186 |   "Blur",
187 |   "GameOver",
188 |   "LoadEffect",
189 |   "ReleaseEffect",
190 |   "TimeAtkStart",
191 |   "TimeAtk",
192 |   "TimeAtkMenuReset",
193 |   "TimeAtkMenuAdd",
194 |   "TimeAtkMenuOpen",
195 |   "AutoSave",
196 |   "ReturnTitle",
197 |   "StopEffect",
198 |   "StopEmotion",
199 |   "PartyChrHide",
200 |   "GetItemMessageEx",
201 |   "CopyStatus",
202 |   "Movie",
203 |   "WaitMovie",
204 |   "EmotionEx",
205 |   "SetFumiSwitch",
206 |   "StopSE",
207 |   "SetEnvSEPlayState",
208 |   "SetFog",
209 |   "GetItemMessageExPlus",
210 |   "ResetPresetCamera",
211 |   "Cure",
212 |   "CampMenu",
213 |   "ResetMoveVec",
214 |   "PlayBGMB",
215 |   "RemovePartyEquip",
216 |   "AddStatus",
217 |   "SetPlaceName",
218 |   "YesNoMenuEx",
219 |   "SetPartyPosEntryOut",
220 |   "MPMenu",
221 |   "SetMapMarker",
222 |   "DelMapMarker",
223 |   "DeleteArgMarker",
224 |   "SetEventNPC",
225 |   "PuzzleOpen",
226 |   "SetPortal",
227 |   "CreateKoma",
228 |   "CloseKoma",
229 |   "Portrait_SetKoma",
230 |   "SetKomaInfo",
231 |   "SetKomaColor",
232 |   "MoveKoma",
233 |   "MoveKomaEx",
234 |   "VibratePortrait",
235 |   "VibrateKoma",
236 |   "SetFadeColor",
237 |   "Portrait_Change",
238 |   "HP_ORecover",
239 |   "ChangeHDRBaseLum",
240 |   "ChangeHDRSoftFocus",
241 |   "ChangeHDRDoF",
242 |   "ResetHDRParam",
243 |   "MapNodeEvent",
244 |   "EventAttack",
245 |   "EventDamage",
246 |   "WaitAnimation",
247 |   "MoveToEx3",
248 |   "EvTimeShift",
249 |   "SetDiaryFlag",
250 |   "QuestBoard",
251 |   "ReturnMemoryMenu",
252 |   "Set3DParticle",
253 |   "Change",
254 |   "Change3DParticleVec",
255 |   "Stop",
256 |   "SetOverlay",
257 |   "StopOverlay",
258 |   "SetParent",
259 |   "ChrNodeHide",
260 |   "ForceChangeCamera",
261 |   "RollCamera",
262 |   "CheckChrAngle",
263 |   "CheckChrDistance",
264 |   "SetMapViewPos",
265 |   "ResetTracks",
266 |   "DiscoverMemory",
267 |   "StartZapping",
268 |   "StopZapping",
269 |   "ChrLightState",
270 |   "ChrLightRadius",
271 |   "ChrLightColor",
272 |   "CreateLight",
273 |   "SetLightState",
274 |   "SetLightRadius",
275 |   "SetLightColor",
276 |   "CureAll",
277 |   "SetCondition",
278 |   "PlaySELabel",
279 |   "PlaySE3DLabel",
280 |   "StopSELabel",
281 |   "FadeSELabel",
282 |   "FadeBGM",
283 |   "SetWeaponKillScript",
284 |   "Timer",
285 |   "VisualName",
286 |   "SetArgInitPos",
287 |   "PlayVoice",
288 |   "PlayVoice3D",
289 |   "StopVoice",
290 |   "SetShadowBound",
291 |   "ResetShadowBound",
292 |   "GetTrophy",
293 |   "MemoryMenu",
294 |   "RemoveEquipAll",
295 |   "EndTimeAtk",
296 |   "ChangeSubAnimation",
297 |   "SubAnimationMode",
298 |   "OpenMinimap",
299 |   "SetCantUseItem",
300 |   "WaitAniProcess",
301 |   "UseItem",
302 |   "TalkPopup",
303 |   "MenuType",
304 |   "SetFogBack",
305 |   "SetDoF",
306 |   "SetDoFFocus",
307 |   "SetGlare",
308 |   "SetFogLightFade",
309 |   "SetMapLightColor",
310 |   "SetMapLightVec",
311 |   "SetMapShadowColor",
312 |   "SetMapChrColor",
313 |   "SetChrLightRatio",
314 |   "SetWeaponLevel",
315 |   "WaitCloseWindow",
316 |   "LookRotateLimit",
317 |   "LookRoll",
318 |   "LookSpd",
319 |   "FixCamera",
320 |   "ResetMapParam",
321 |   "SetName2",
322 |   "OpenMessage",
323 |   "CloseMessage",
324 |   "WaitCloseMessage",
325 |   "SetWorldMapping",
326 |   "SetMotSpd",
327 |   "KeyAnimeCreate",
328 |   "KeyAnimeSet",
329 |   "KeyAnimeCamera",
330 |   "KeyAnimeChara",
331 |   "KeyAnimeRelease",
332 |   "WaitAnimation2",
333 |   "ActiveVoiceStart",
334 |   "ActiveVoiceStop",
335 |   "InterceptStart",
336 |   "Intercept",
337 |   "JoinNPC",
338 |   "SetFishingRank",
339 |   "CheckFishingSpotCoun",
340 |   "InterceptStop",
341 |   "EquipCostume",
342 |   "SetFogWater",
343 |   "CallFunc",
344 |   "FixPlayerChr",
345 |   "SetShadowOffset",
346 |   "SetShadowOffsetChr",
347 |   "SetYs8Camera",
348 |   "ResetYs8Camera",
349 |   "DelCheckPoint",
350 |   "SetSkipScript",
351 |   "Slow",
352 |   "SoundEfx",
353 |   "SetFishingAreaState",
354 |   "SaveEventState",
355 |   "RestoreEventState",
356 |   "GetInterceptRank",
357 |   "InterceptResume",
358 |   "InterceptKickOffMenu",
359 |   "GetCoopEvPeopleNum",
360 |   "PitchChr",
361 |   "RollChr",
362 |   "AddWarpDisableList",
363 |   "GetProgressQuest",
364 |   "SetDiaryCharaFlag",
365 |   "ItemBackup",
366 |   "UseFood",
367 |   "GetNumKilledEnemy",
368 |   "SetRealTimeHelp",
369 |   "SetEventDriven",
370 |   "PlaySceneVoice",
371 |   "Portrait",
372 |   "CameraShakeParam",
373 |   "GetExp",
374 |   "SetDiaryShopFlag",
375 |   "ChangeChrPos",
376 |   "ItemCue",
377 |   "InterceptSetRetMap",
378 |   "WarpCancel",
379 |   "DropItem",
380 |   "DelWarpDisableList",
381 |   "SetChrInfoFlagStr",
382 |   "LoadChr",
383 |   "ReleaseChr",
384 |   "ReleaseChrGo",
385 |   "SetGradationColor",
386 |   "SetLensFlare",
387 |   "GetDiaryCharaFlag",
388 |   "SetChrAtariFlag",
389 |   "MenuEnable",
390 |   "SetChrID",
391 |   "GetTrophyDirect",
392 |   "DelMapMarkerAll",
393 |   "DelSkillNewMark",
394 |   "0x8182",
395 | };
396 | 


--------------------------------------------------------------------------------
/tbbconv/node_modules/jconv/jconv.min.js:
--------------------------------------------------------------------------------
 1 | (function(){function t(c){switch(c.toUpperCase()){case "WINDOWS-31J":case "CP932":case "SJIS":case "SHIFTJIS":case "SHIFT_JIS":return"SJIS";case "EUCJP":case "EUC-JP":return"EUCJP";case "JIS":case "ISO2022JP":case "ISO-2022-JP":case "ISO-2022-JP-1":return"JIS";case "UTF8":case "UTF-8":return"UTF8";case "UNICODE":case "UCS2":case "UCS-2":case "UTF16LE":case "UTF-16LE":return"UCS2";default:return""}}function q(c,k,g){128>c?k[g++]=c:(2048>c?k[g++]=192|c>>>6:(65536>c?k[g++]=224|c>>>12:(2097152>c?k[g++]=
 2 | 240|c>>>18:(67108864>c?k[g++]=248|c>>>24:(k[g++]=252|c/1073741824,k[g++]=128|c>>>24&63),k[g++]=128|c>>>18&63),k[g++]=128|c>>>12&63),k[g++]=128|c>>>6&63),k[g++]=128|c&63);return g}function r(c,k,g){k[g++]=c&255;k[g++]=c>>8;return g}var p={SJIS:require("./tables/SJIS"),JIS:require("./tables/JIS"),JISEXT:require("./tables/JISEXT"),SJISInverted:require("./tables/SJISInverted"),JISInverted:require("./tables/JISInverted"),JISEXTInverted:require("./tables/JISEXTInverted")},s={},n=module.exports=function(c,
 3 | k,g){return n.convert(c,k,g)};n.defineEncoding=function(c){s[c.name]=new function(c){this.name=c.name;this.convert=c.convert}(c)};n.convert=function(c,k,g){k=t(k);g=t(g);if(!k||!g)throw Error("Encoding not recognized.");c=c||new Buffer(0);c=c instanceof Buffer?c:new Buffer(c.toString(),"UTF8");if(k===g)return c;var h=s[k+"to"+g];if(h)return h.convert(c);k=s[k+"toUCS2"];g=s["UCS2to"+g];if(k&&g)return g.convert(k.convert(c));throw Error("Encoding not recognized.");};n.decode=function(c,k){switch(k.toUpperCase()){case "BINARY":case "BASE64":case "ASCII":case "HEX":case "UTF8":case "UTF-8":case "UNICODE":case "UCS2":case "UCS-2":case "UTF16LE":case "UTF-16LE":return c.toString(k);
 4 | default:return n.convert(c,k,"UCS2").toString("UCS2")}};n.encode=function(c,k){switch(k.toUpperCase()){case "BASE64":case "ASCII":case "HEX":case "UTF8":case "UTF-8":return new Buffer(c,k);default:return n.convert(c,"UTF8",k)}};n.encodingExists=function(c){return t(c)?!0:!1};n.defineEncoding({name:"UCS2toUTF8",convert:function(c){for(var k=c.length,g=new Buffer(3*k),h=0,f,b=0;b<k;)f=c[b++],f=(c[b++]<<8)+f,h=q(f,g,h);return g.slice(0,h)}});n.defineEncoding({name:"UCS2toSJIS",convert:function(c){for(var k=
 5 | p.SJISInverted,g=k[12539],h=c.length,f=new Buffer(h),b=0,a,d=0;d<h;)a=c[d++],a=(c[d++]<<8)+a,128>a?f[b++]=a:65377<=a&&65439>=a?f[b++]=a-65216:(a=k[a]||g,f[b++]=a>>8,f[b++]=a&255);return f.slice(0,b)}});n.defineEncoding({name:"UCS2toJIS",convert:function(c){for(var k=p.JISInverted,g=p.JISEXTInverted,h=k[12539],f=c.length,b=new Buffer(3*f+4),a=0,d,e=0,l=0;l<f;)if(d=c[l++],d=(c[l++]<<8)+d,128>d)0!==e&&(e=0,b[a++]=27,b[a++]=40,b[a++]=66),b[a++]=d;else if(65377<=d&&65439>=d)1!==e&&(e=1,b[a++]=27,b[a++]=
 6 | 40,b[a++]=73),b[a++]=d-65344;else{var m=k[d];m?(2!==e&&(e=2,b[a++]=27,b[a++]=36,b[a++]=66),b[a++]=m>>8,b[a++]=m&255):(d=g[d])?(3!==e&&(e=3,b[a++]=27,b[a++]=36,b[a++]=40,b[a++]=68),b[a++]=d>>8,b[a++]=d&255):(2!==e&&(e=2,b[a++]=27,b[a++]=36,b[a++]=66),b[a++]=h>>8,b[a++]=h&255)}0!==e&&(b[a++]=27,b[a++]=40,b[a++]=66);return b.slice(0,a)}});n.defineEncoding({name:"UCS2toEUCJP",convert:function(c){for(var k=p.JISInverted,g=p.JISEXTInverted,h=k[12539],f=c.length,b=new Buffer(2*f),a=0,d,e=0;e<f;)if(d=c[e++],
 7 | d=(c[e++]<<8)+d,128>d)b[a++]=d;else if(65377<=d&&65439>=d)b[a++]=142,b[a++]=d-65472;else{var l=k[d];l?(b[a++]=(l>>8)-128,b[a++]=(l&255)-128):(d=g[d])?(b[a++]=143,b[a++]=(d>>8)-128,b[a++]=(d&255)-128):(b[a++]=(h>>8)-128,b[a++]=(h&255)-128)}return b.slice(0,a)}});n.defineEncoding({name:"UTF8toUCS2",convert:function(c){for(var k=c.length,g=new Buffer(2*k),h=0,f,b=0;b<k;){f=c[b++];switch(f>>4){case 0:case 1:case 2:case 3:case 4:case 5:case 6:case 7:break;case 12:case 13:f=(f&31)<<6|c[b++]&63;break;case 14:f=
 8 | (f&15)<<12|(c[b++]&63)<<6|c[b++]&63;break;default:f=(f&7)<<18|(c[b++]&63)<<12|(c[b++]&63)<<6|c[b++]&63}h=r(f,g,h)}return g.slice(0,h)}});n.defineEncoding({name:"UTF8toSJIS",convert:function(c){for(var k=p.SJISInverted,g=k[12539],h=c.length,f=new Buffer(2*h),b=0,a,d=0;d<h;){a=c[d++];switch(a>>4){case 0:case 1:case 2:case 3:case 4:case 5:case 6:case 7:break;case 12:case 13:a=(a&31)<<6|c[d++]&63;break;case 14:a=(a&15)<<12|(c[d++]&63)<<6|c[d++]&63;break;default:a=(a&7)<<18|(c[d++]&63)<<12|(c[d++]&63)<<
 9 | 6|c[d++]&63}128>a?f[b++]=a:65377<=a&&65439>=a?f[b++]=a-65216:(a=k[a]||g,f[b++]=a>>8,f[b++]=a&255)}return f.slice(0,b)}});n.defineEncoding({name:"UTF8toJIS",convert:function(c){for(var k=p.JISInverted,g=p.JISEXTInverted,h=k[12539],f=c.length,b=new Buffer(3*f+4),a=0,d,e=0,l=0;l<f;){d=c[l++];switch(d>>4){case 0:case 1:case 2:case 3:case 4:case 5:case 6:case 7:break;case 12:case 13:d=(d&31)<<6|c[l++]&63;break;case 14:d=(d&15)<<12|(c[l++]&63)<<6|c[l++]&63;break;default:d=(d&7)<<18|(c[l++]&63)<<12|(c[l++]&
10 | 63)<<6|c[l++]&63}if(128>d)0!==e&&(e=0,b[a++]=27,b[a++]=40,b[a++]=66),b[a++]=d;else if(65377<=d&&65439>=d)1!==e&&(e=1,b[a++]=27,b[a++]=40,b[a++]=73),b[a++]=d-65344;else{var m=k[d];m?(2!==e&&(e=2,b[a++]=27,b[a++]=36,b[a++]=66),b[a++]=m>>8,b[a++]=m&255):(d=g[d])?(3!==e&&(e=3,b[a++]=27,b[a++]=36,b[a++]=40,b[a++]=68),b[a++]=d>>8,b[a++]=d&255):(2!==e&&(e=2,b[a++]=27,b[a++]=36,b[a++]=66),b[a++]=h>>8,b[a++]=h&255)}}0!==e&&(b[a++]=27,b[a++]=40,b[a++]=66);return b.slice(0,a)}});n.defineEncoding({name:"UTF8toEUCJP",
11 | convert:function(c){for(var k=p.JISInverted,g=p.JISEXTInverted,h=k[12539],f=c.length,b=new Buffer(2*f),a=0,d,e=0;e<f;){d=c[e++];switch(d>>4){case 0:case 1:case 2:case 3:case 4:case 5:case 6:case 7:break;case 12:case 13:d=(d&31)<<6|c[e++]&63;break;case 14:d=(d&15)<<12|(c[e++]&63)<<6|c[e++]&63;break;default:d=(d&7)<<18|(c[e++]&63)<<12|(c[e++]&63)<<6|c[e++]&63}if(128>d)b[a++]=d;else if(65377<=d&&65439>=d)b[a++]=142,b[a++]=d-65472;else{var l=k[d];l?(b[a++]=(l>>8)-128,b[a++]=(l&255)-128):(d=g[d])?(b[a++]=
12 | 143,b[a++]=(d>>8)-128,b[a++]=(d&255)-128):(b[a++]=(h>>8)-128,b[a++]=(h&255)-128)}}return b.slice(0,a)}});n.defineEncoding({name:"SJIStoUCS2",convert:function(c){for(var k=p.SJIS,g=c.length,h=new Buffer(3*g),f=0,b,a=0;a<g;)b=c[a++],128>b||(160<=b&&223>=b?b+=65216:(b=(b<<8)+c[a++],b=k[b]||12539)),f=r(b,h,f);return h.slice(0,f)}});n.defineEncoding({name:"SJIStoUTF8",convert:function(c){for(var k=p.SJIS,g=c.length,h=new Buffer(3*g),f=0,b,a=0;a<g;)b=c[a++],128>b||(160<=b&&223>=b?b+=65216:(b=(b<<8)+c[a++],
13 | b=k[b]||12539)),f=q(b,h,f);return h.slice(0,f)}});n.defineEncoding({name:"SJIStoJIS",convert:function(c){for(var k=p.SJIS,g=p.JISInverted,h=c.length,f=new Buffer(3*h+4),b=0,a=0,d=0;d<h;){var e=c[d++];if(128>e)0!==a&&(a=0,f[b++]=27,f[b++]=40,f[b++]=66),f[b++]=e;else if(161<=e&&223>=e)1!==a&&(a=1,f[b++]=27,f[b++]=40,f[b++]=73),f[b++]=e-128;else if(238>=e){2!==a&&(a=2,f[b++]=27,f[b++]=36,f[b++]=66);var l=c[d++],e=e<<1;159>l?(e=319>e?e-225:e-97,l=126<l?l-32:l-31):(e=319>e?e-224:e-96,l-=126);f[b++]=e;
14 | f[b++]=l}else 250<=e&&(2!==a&&(a=2,f[b++]=27,f[b++]=36,f[b++]=66),e=(e<<8)+c[d++],e=g[k[e]||12539],f[b++]=e>>8,f[b++]=e&255)}0!==a&&(f[b++]=27,f[b++]=40,f[b++]=66);return f.slice(0,b)}});n.defineEncoding({name:"SJIStoEUCJP",convert:function(c){for(var k=p.SJIS,g=p.JISInverted,h=c.length,f=new Buffer(2*h),b=0,a=0;a<h;){var d=c[a++];if(128>d)f[b++]=d;else if(161<=d&&223>=d)f[b++]=142,f[b++]=d;else if(238>=d){var e=c[a++],d=d<<1;159>e?(d=319>d?d-97:d-225,e=126<e?e+96:e+97):(d=319>d?d-96:d-224,e+=2);
15 | f[b++]=d;f[b++]=e}else 250<=d&&(d=(d<<8)+c[a++],d=g[k[d]||12539],f[b++]=(d>>8)-128,f[b++]=(d&255)-128)}return f.slice(0,b)}});n.defineEncoding({name:"JIStoUCS2",convert:function(c){for(var k=p.JIS,g=p.JISEXT,h=c.length,f=new Buffer(2*h),b=0,a,d=0,e=0;e<h;){var l=c[e++];if(27===l){var l=c[e++],m=c[e++];switch(l){case 40:66===m||161===c?d=0:73===m&&(d=1);break;case 38:d=2;e+=3;break;case 36:64===m||66===m?d=2:40===m&&(d=3,e++)}}else{switch(d){case 0:a=l;break;case 1:a=l+65344;break;case 2:a=(l<<8)+
16 | c[e++];a=k[a]||12539;break;case 3:a=(l<<8)+c[e++],a=g[a]||12539}b=r(a,f,b)}}return f.slice(0,b)}});n.defineEncoding({name:"JIStoUTF8",convert:function(c){for(var k=p.JIS,g=p.JISEXT,h=c.length,f=new Buffer(2*h),b=0,a,d=0,e=0;e<h;){var l=c[e++];if(27===l){var l=c[e++],m=c[e++];switch(l){case 40:66===m||161===c?d=0:73===m&&(d=1);break;case 38:d=2;e+=3;break;case 36:64===m||66===m?d=2:40===m&&(d=3,e++)}}else{switch(d){case 0:a=l;break;case 1:a=l+65344;break;case 2:a=(l<<8)+c[e++];a=k[a]||12539;break;
17 | case 3:a=(l<<8)+c[e++],a=g[a]||12539}b=q(a,f,b)}}return f.slice(0,b)}});n.defineEncoding({name:"JIStoSJIS",convert:function(c){for(var k=p.SJIS,g=p.SJISInverted,h=g[12539],f=c.length,b=new Buffer(2*f),a=0,d=0,e=0;e<f;){var l=c[e++];if(27===l){var m=c[e++],l=c[e++];switch(m){case 40:66===l||161===c?d=0:73===l&&(d=1);break;case 38:d=2;e+=3;break;case 36:64===l||66===l?d=2:40===l&&(d=3,e++)}}else switch(d){case 0:b[a++]=l;break;case 1:b[a++]=l+128;break;case 2:m=c[e++];l&1?(l>>=1,l=47>l?l+113:l-79,m=
18 | 95<m?m+32:m+31):(l>>=1,l=47>=l?l+112:l-80,m+=126);var n=((l&255)<<8)+m;60736<=n&&61180>=n&&(m=g[k[n]]||h,l=m>>8,m&=255);b[a++]=l;b[a++]=m;break;case 3:b[a++]=h>>8,b[a++]=h&255,e++}}return b.slice(0,a)}});n.defineEncoding({name:"JIStoEUCJP",convert:function(c){for(var k=c.length,g=new Buffer(2*k),h=0,f=0,b=0;b<k;){var a=c[b++];if(27===a){var a=c[b++],d=c[b++];switch(a){case 40:66===d||161===c?f=0:73===d&&(f=1);break;case 38:f=2;b+=3;break;case 36:64===d||66===d?f=2:40===d&&(f=3,b++)}}else switch(f){case 0:g[h++]=
19 | a;break;case 1:g[h++]=142;g[h++]=a+128;break;case 2:g[h++]=a+128;g[h++]=c[b++]+128;break;case 3:g[h++]=143,g[h++]=a+128,g[h++]=c[b++]+128}}return g.slice(0,h)}});n.defineEncoding({name:"EUCJPtoUCS2",convert:function(c){for(var k=p.JIS,g=p.JISEXT,h=c.length,f=new Buffer(2*h),b=0,a,d=0;d<h;){a=c[d++];if(!(128>a))if(142===a)a=c[d++]+65216;else if(143===a){a=c[d++]-128;var e=c[d++]-128;a=(a<<8)+e;a=g[a]||12539}else e=a-128,a=c[d++]-128,a=(e<<8)+a,a=k[a]||12539;b=r(a,f,b)}return f.slice(0,b)}});n.defineEncoding({name:"EUCJPtoUTF8",
20 | convert:function(c){for(var k=p.JIS,g=p.JISEXT,h=c.length,f=new Buffer(2*h),b=0,a,d=0;d<h;){a=c[d++];if(!(128>a))if(142===a)a=c[d++]+65216;else if(143===a){a=c[d++]-128;var e=c[d++]-128;a=(a<<8)+e;a=g[a]||12539}else e=a-128,a=c[d++]-128,a=(e<<8)+a,a=k[a]||12539;b=q(a,f,b)}return f.slice(0,b)}});n.defineEncoding({name:"EUCJPtoSJIS",convert:function(c){for(var k=p.SJIS,g=p.SJISInverted,h=g[12539],f=c.length,b=new Buffer(2*f),a=0,d=0;d<f;){var e=c[d++];if(128>e)b[a++]=e;else if(142===e)b[a++]=c[d++];
21 | else if(143===e)b[a++]=h>>8,b[a++]=h&255,d+=2;else{var l=c[d++];e&1?(e>>=1,e=111>e?e+49:e+113,l=223<l?l-96:l-97):(e>>=1,e=111>=e?e+48:e+112,l-=2);var m=((e&255)<<8)+l;60736<=m&&61180>=m&&(l=g[k[m]]||h,e=l>>8,l&=255);b[a++]=e;b[a++]=l}}return b.slice(0,a)}});n.defineEncoding({name:"EUCJPtoJIS",convert:function(c){for(var k=c.length,g=new Buffer(3*k+4),h=0,f=0,b=0;b<k;){var a=c[b++];128>a?(0!==f&&(f=0,g[h++]=27,g[h++]=40,g[h++]=66),g[h++]=a):(142===a?1!==f&&(f=1,g[h++]=27,g[h++]=40,g[h++]=73):143===
22 | a?(3!==f&&(f=3,g[h++]=27,g[h++]=36,g[h++]=40,g[h++]=68),g[h++]=c[b++]-128):(2!==f&&(f=2,g[h++]=27,g[h++]=36,g[h++]=66),g[h++]=a-128),g[h++]=c[b++]-128)}0!==f&&(g[h++]=27,g[h++]=40,g[h++]=66);return g.slice(0,h)}})})();
23 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                                  Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "{}"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright {yyyy} {name of copyright owner}
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 


--------------------------------------------------------------------------------
/xai.cpp:
--------------------------------------------------------------------------------
  1 | // XAST Packer by yosh778
  2 | 
  3 | #include <string>
  4 | #include <iostream>
  5 | #include <algorithm>
  6 | 
  7 | #include <fstream>
  8 | #include <unordered_map>
  9 | #include <cinttypes>
 10 | #include <boost/filesystem.hpp>
 11 | 
 12 | #define ALIGN_16(n) ((n / 0x10 + (n % 0x10 ? 1 : 0)) * 0x10)
 13 | #define RBUF_SIZE 0x1000000
 14 | 
 15 | using namespace boost::filesystem;
 16 | 
 17 | void write32(std::fstream& output, uint32_t data) {
 18 | 	output.write((char*)&data, (int)sizeof(data));
 19 | }
 20 | 
 21 | void write64(std::fstream& output, uint64_t data) {
 22 | 	output.write((char*)&data, (int)sizeof(data));
 23 | }
 24 | 
 25 | uint32_t read32(std::ifstream& input) {
 26 | 	uint32_t data;
 27 | 	input.read((char*)&data, (int)sizeof(data));
 28 | 	return data;
 29 | }
 30 | 
 31 | uint64_t read64(std::ifstream& input) {
 32 | 	uint64_t data;
 33 | 	input.read((char*)&data, (int)sizeof(data));
 34 | 	return data;
 35 | }
 36 | 
 37 | // Checksum reverse by weaknespase
 38 | uint32_t checksum(const char* in, const size_t length, int last = 0){
 39 | 	const char* end = in + length;
 40 | 	int acc = last;
 41 | 	while (in < end)
 42 | 		acc = (acc * 33) ^ (unsigned char) *in++;
 43 | 	return acc;
 44 | }
 45 | 
 46 | typedef struct FileData_ {
 47 | 	std::string fullpath;
 48 | 	std::string filename;
 49 | 	uint32_t pathOffset;
 50 | 	uint32_t pathCheck;
 51 | 	uint32_t contentCheck;
 52 | 	uint64_t offset;
 53 | 	uint64_t size;
 54 | } FileData;
 55 | 
 56 | std::vector<char*> headerOrder;
 57 | 
 58 | bool alphaSorter(const FileData& a, const FileData& b)
 59 | {
 60 | 	return a.filename < b.filename;
 61 | }
 62 | 
 63 | uint32_t getHeaderOrder(std::vector<char*>& order, std::string input);
 64 | 
 65 | 
 66 | int main(int argc, char *argv[])
 67 | {
 68 | 	if ( argc < 3 ) {
 69 | 		std::cerr << "Usage : " << argv[0] << " <dataPath> <outputXai> (<originalXai>)" << std::endl;
 70 | 		return -1;
 71 | 	}
 72 | 
 73 | 	std::string inPath = argv[1];
 74 | 	std::string output = argv[2];
 75 | 	uint32_t mimicUnused = 0;
 76 | 
 77 | 	// Check input path existence
 78 | 	if ( !exists( inPath ) ) {
 79 | 	  std::cerr << "ERROR : Input directory " << inPath << " does not exist" << std::endl;
 80 | 	  return EXIT_FAILURE;
 81 | 	}
 82 | 
 83 | 	if ( argc > 3 ) {
 84 | 		mimicUnused = getHeaderOrder( headerOrder, argv[3] );
 85 | 	}
 86 | 	else {
 87 | 		std::cerr << "WARNING : No original XAST archive specified, this could cause game crashes" << std::endl << std::endl;
 88 | 	}
 89 | 
 90 | 	std::vector<FileData> files;
 91 | 
 92 | 	recursive_directory_iterator it( inPath ), end;
 93 | 	FileData fileData;
 94 | 	uint32_t pathsCount = 0;
 95 | 	std::unordered_map<std::string, int> headerMap;
 96 | 	uint32_t i = 0;
 97 | 
 98 | 	// Read input directory recursively
 99 | 	for ( ; it != end; ++it ) {
100 | 	  bool is_dir = is_directory( *it );
101 | 
102 | 	  std::string fullpath = it->path().string();
103 | 	  std::replace(fullpath.begin(), fullpath.end(), '\\', '/');
104 | 
105 | 	  std::string filename = fullpath.substr( inPath.size() );
106 | 
107 | 	  if ( filename.front() == '/' ) {
108 | 		filename.erase(0, 1);
109 | 	  }
110 | 
111 | 	// Skip any non-existing file
112 | 	if ( !exists( fullpath ) )
113 | 	continue;
114 | 
115 | 	if ( !is_dir ) {
116 | 		pathsCount += filename.size() + 1;
117 | 		fileData.filename = filename;
118 | 		fileData.fullpath = fullpath;
119 | 		fileData.pathCheck = checksum( filename.c_str(), filename.size() );
120 | 		// std::cout << "Checksum for " << filename << " : " << std::hex << fileData.pathCheck << std::dec << std::endl;
121 | 		fileData.size = file_size( fullpath );
122 | 
123 | 		files.push_back( fileData );
124 | 	  }
125 | 	}
126 | 
127 | 	if ( argc > 3 && (headerOrder.size()-mimicUnused) != files.size() ) {
128 | 		std::cerr << "When specifying an original file, input folder must contain the same number of files & the same filepaths as the original .xai" << std::endl;
129 | 		return -1;
130 | 	}
131 | 
132 | 	std::sort (files.begin(), files.end(), alphaSorter);
133 | 
134 | 	uint32_t nbEntries = files.size();
135 | 
136 | 	std::fstream oFile( output.c_str(), std::ios_base::trunc | std::ios_base::in | std::ios_base::out | std::ios_base::binary );
137 | 
138 | 	if ( !oFile.is_open() ) {
139 | 		std::cerr << "Failed to open output file '" << output << "'" << std::endl;
140 | 		return -2;
141 | 	}
142 | 
143 | 	uint32_t nbUnused = 0;
144 | 	uint32_t maxEntries = nbEntries + nbUnused + mimicUnused;
145 | 	uint32_t alignedPathsCount = ALIGN_16(pathsCount);
146 | 
147 | 	uint32_t data;
148 | 	uint64_t pathsOffset = 0x30 * (1 + maxEntries);
149 | 	uint32_t dataOffset = pathsOffset + alignedPathsCount;
150 | 
151 | 	// XAST header
152 | 	write32(oFile, 0x54534158);
153 | 	write32(oFile, 0x01010000); // Version : 1.01
154 | 	write32(oFile, nbEntries);
155 | 	write32(oFile, maxEntries);
156 | 
157 | 	write32(oFile, pathsCount);
158 | 	write32(oFile, dataOffset);
159 | 
160 | 	uint32_t unk0 = -1; // Headers checksum (dummy for now)
161 | 	write32(oFile, unk0);
162 | 
163 | 	uint32_t headersCount = pathsOffset - 0x30;
164 | 	write32(oFile, headersCount);
165 | 
166 | 	uint64_t fileSize = -1;
167 | 	write64(oFile, fileSize);
168 | 	write64(oFile, 0);
169 | 
170 | 	uint64_t nextPathOffset = pathsOffset;
171 | 	uint64_t nextFileOffset = dataOffset;
172 | 
173 | 	i = 0;
174 | 
175 | 	if ( argc == 3 )
176 | 	for ( FileData& file : files ) {
177 | 
178 | 		std::cout << "Checksum for " << file.filename << " : " << std::hex << file.pathCheck << std::dec << std::endl;
179 | 
180 | 		// Filepath checksum
181 | 		write32(oFile, file.pathCheck);
182 | 
183 | 		write32(oFile, nextPathOffset);
184 | 		nextPathOffset += file.filename.size() + 1;
185 | 
186 | 		write32(oFile, 0); // File checksum
187 | 
188 | 		bool isXast = extension(file.filename) == ".xai";
189 | 		// std::cout << extension(file.filename) << " : " << isXast << std::endl;
190 | 
191 | 		write32(oFile, isXast); // boolean : is it another XAST .xai file ?
192 | 
193 | 		write64(oFile, file.size);
194 | 		write64(oFile, 0); // Padding
195 | 
196 | 		uint64_t aSize = ALIGN_16(file.size);
197 | 
198 | 		if ( ++i >= files.size() )
199 | 			aSize = file.size;
200 | 
201 | 		write64(oFile, nextFileOffset);
202 | 		write64(oFile, aSize); // Aligned file size
203 | 
204 | 		nextFileOffset += aSize;
205 | 	}
206 | 
207 | 	else
208 | 	for ( char *filePath : headerOrder ) {
209 | 
210 | 		write32(oFile, -1);
211 | 		write32(oFile, 0);
212 | 		write32(oFile, -1);
213 | 		write32(oFile, 0);
214 | 
215 | 		write64(oFile, 0);
216 | 		write64(oFile, 0);
217 | 
218 | 		write64(oFile, 0);
219 | 		write64(oFile, 0);
220 | 	}
221 | 
222 | 	// Write additional unused entry slots
223 | 	for ( uint32_t i = 0; i < nbUnused; i++ ) {
224 | 
225 | 		write32(oFile, -1);
226 | 		write32(oFile, 0);
227 | 		write32(oFile, -1);
228 | 		write32(oFile, 0);
229 | 
230 | 		write64(oFile, 0);
231 | 		write64(oFile, 0);
232 | 
233 | 		write64(oFile, 0);
234 | 		write64(oFile, 0);
235 | 	}
236 | 
237 | 	for ( FileData file : files ) {
238 | 		oFile.write( file.filename.c_str(), file.filename.size() + 1 );
239 | 	}
240 | 
241 | 	uint8_t *buf = new uint8_t[RBUF_SIZE];
242 | 
243 | 	if ( oFile.tellp() % 0x10 ) {
244 | 		memset( buf, 0, 0x10 );
245 | 		oFile.write( (char*)buf, 0x10 - (oFile.tellp() % 0x10) );
246 | 	}
247 | 
248 | 	if ( oFile.tellp() != dataOffset ) {
249 | 		std::cerr << "Error while writing header : " << std::hex << oFile.tellp()
250 | 			<< " != " << dataOffset << std::dec << std::endl;
251 | 		return -2;
252 | 	}
253 | 
254 | 	uint32_t n = 0; i = 0;
255 | 
256 | 	for ( FileData& file : files ) {
257 | 
258 | 		std::ifstream input( file.fullpath.c_str(), std::ios_base::binary );
259 | 
260 | 		if ( !input.is_open() ) {
261 | 			std::cerr << "Failed to open " << file.fullpath << std::endl;
262 | 			return -2;
263 | 		}
264 | 
265 | 		file.pathOffset = nextPathOffset;
266 | 		nextPathOffset += file.filename.size() + 1;
267 | 
268 | 		headerMap[ file.filename ] = i++;
269 | 
270 | 		uint64_t aSize = ALIGN_16(file.size);
271 | 
272 | 		file.offset = nextFileOffset;
273 | 
274 | 		nextFileOffset += aSize;
275 | 
276 | 		std::cout << "Writing " << file.filename << std::endl;
277 | 
278 | 		uint32_t last = 0;
279 | 		uint64_t read = 0;
280 | 		uint64_t totalRead = 0;
281 | 
282 | 		while ( input && oFile ) {
283 | 			input.read( (char*)buf, RBUF_SIZE );
284 | 
285 | 			if ( input )
286 | 				read = RBUF_SIZE;
287 | 
288 | 			else
289 | 				read = input.gcount();
290 | 
291 | 			last = checksum( (const char*)buf, read, last );
292 | 			oFile.write( (const char*)buf, read );
293 | 			totalRead += read;
294 | 		}
295 | 
296 | 		input.close();
297 | 
298 | 		if ( totalRead != file.size ) {
299 | 			std::cerr << "Bad file size" << std::endl;
300 | 			return -3;
301 | 		}
302 | 
303 | 		file.contentCheck = last;
304 | 
305 | 		// Align for next file data if needed
306 | 		if ( ++n < files.size() && oFile.tellp() % 0x10 ) {
307 | 			memset( buf, 0, 0x10 );
308 | 			oFile.write( (char*)buf, 0x10 - (oFile.tellp() % 0x10) );
309 | 		}
310 | 	}
311 | 
312 | 	fileSize = oFile.tellp();
313 | 
314 | 	oFile.seekp(0x20);
315 | 	write64(oFile, fileSize);
316 | 	i = 0;
317 | 
318 | 	if ( argc == 3 )
319 | 	for ( FileData& file : files ) {
320 | 		oFile.seekp((0x30 * ++i) + 8);
321 | 
322 | 		// write32(oFile, file.pathCheck);
323 | 		// write32(oFile, file.pathOffset);
324 | 		write32(oFile, file.contentCheck); // File checksum
325 | 	}
326 | 
327 | 	else
328 | 	for ( char *filePath : headerOrder ) {
329 | 		std::string hpath;
330 | 		oFile.seekp(0x30 * (i+1));
331 | 
332 | 		if ( filePath && filePath != (char*)-1 ) {
333 | 			hpath = std::string(filePath);
334 | 			FileData& file = files[ headerMap[ hpath ] ];
335 | 			std::cout << "Writing checksum for " << file.filename << std::endl;
336 | 
337 | 			write32(oFile, file.pathCheck);
338 | 			write32(oFile, file.pathOffset);
339 | 			write32(oFile, file.contentCheck); // File checksum
340 | 
341 | 			bool isXast = extension(file.filename) == ".xai";
342 | 			// std::cout << extension(file.filename) << " : " << isXast << std::endl;
343 | 
344 | 			write32(oFile, isXast); // boolean : is it another XAST .xai file ?
345 | 
346 | 			write64(oFile, file.size);
347 | 			write64(oFile, 0); // Padding
348 | 
349 | 			write64(oFile, file.offset);
350 | 			uint32_t aSize = ALIGN_16(file.size);
351 | 
352 | 			if ( (file.offset + file.size) >= fileSize ) {
353 | 				aSize = file.size;
354 | 			}
355 | 
356 | 			write64(oFile, aSize); // Aligned file size
357 | 		}
358 | 
359 | 		i++;
360 | 	}
361 | 
362 | 
363 | 	oFile.seekp(0x30);
364 | 
365 | 	uint32_t headerSize = 0x30 * maxEntries;
366 | 
367 | 	if ( RBUF_SIZE < headerSize ) {
368 | 		delete buf;
369 | 		buf = new uint8_t[ headerSize ];
370 | 	}
371 | 
372 | 	oFile.read( (char*)buf, headerSize );
373 | 	uint32_t headerCheck = checksum( (const char*)buf, headerSize);
374 | 
375 | 	oFile.seekp(0x18);
376 | 	write32(oFile, headerCheck);
377 | 
378 | 	oFile.close();
379 | 
380 | 	if ( argc == 3 ) {
381 | 		std::cerr << std::endl << "WARNING : No original XAST archive specified, this could cause game crashes" << std::endl;
382 | 	}
383 | 
384 | 	std::cerr << std::endl << n << " files were included" << std::endl;
385 | 	std::cerr << "XAST archive successfully created" << std::endl;
386 | 
387 | 	return 0;
388 | }
389 | 
390 | uint32_t getHeaderOrder(std::vector<char*>& order, std::string input)
391 | {
392 | 	std::ifstream file( input.c_str(), std::ios_base::binary );
393 | 
394 | 	if ( !file.is_open() )
395 | 		return -2;
396 | 
397 | 	uint32_t data;
398 | 
399 | 	// XAST header
400 | 	uint32_t magic = read32(file);
401 | 
402 | 	// Version : 1.01
403 | 	uint32_t version = read32(file);
404 | 	uint32_t nbEntries = read32(file); // nbEntries
405 | 	uint32_t maxEntries = read32(file); // maxEntries
406 | 	uint32_t pathsCount = read32(file);
407 | 	uint32_t dataOffset = read32(file);
408 | 	uint32_t unk0 = read32(file);
409 | 	uint32_t headersCount = read32(file);
410 | 	uint32_t fileSize = read32(file);
411 | 
412 | 	uint32_t pathsOffset = 0x30 + headersCount;
413 | 
414 | 	uint64_t *fileSizes = new uint64_t[maxEntries];
415 | 	uint64_t *fileOffsets = new uint64_t[maxEntries];
416 | 	uint32_t *pathOffsets = new uint32_t[maxEntries];
417 | 	uint32_t *unk1 = new uint32_t[maxEntries];
418 | 	uint32_t *fileChecksums = new uint32_t[maxEntries];
419 | 	uint32_t nbActualEntries = 0;
420 | 	uint32_t i = 0;
421 | 
422 | 	file.seekg(pathsOffset);
423 | 
424 | 	char *pathsData = new char[pathsCount];
425 | 	file.read(pathsData, pathsCount);
426 | 
427 | 	file.seekg(0x30);
428 | 
429 | 	uint32_t nbUnused = 0;
430 | 
431 | 	for (i = 0; i < maxEntries; i++) {
432 | 
433 | 		unk1[i] = read32(file);
434 | 		pathOffsets[i] = read32(file);
435 | 		fileChecksums[i] = read32(file);
436 | 		uint32_t isXai = read32(file);
437 | 
438 | 		if ( pathOffsets[i] && pathOffsets[i] != -1 ) {
439 | 			order.push_back( pathsData + (pathOffsets[i] - pathsOffset) );
440 | 		}
441 | 
442 | 		else {
443 | 			order.push_back( (char*)-1 );
444 | 			nbUnused++;
445 | 		}
446 | 
447 | 		fileSizes[i] = read64(file);
448 | 		uint64_t padding = read64(file);
449 | 
450 | 		fileOffsets[i] = read64(file);
451 | 		uint64_t aSize = read64(file);
452 | 
453 | 		if ( file.tellg() >= pathsOffset )
454 | 			break;
455 | 	}
456 | 
457 | 	delete fileSizes;
458 | 	delete fileOffsets;
459 | 	delete pathOffsets;
460 | 	delete unk1;
461 | 	delete fileChecksums;
462 | 
463 | 	return nbUnused;
464 | }
465 | 
466 | 


--------------------------------------------------------------------------------
/sceneOpCodes.hh:
--------------------------------------------------------------------------------
  1 | // Scene OpCodes
  2 | 
  3 | #pragma once
  4 | 
  5 | enum OpCode {
  6 | 
  7 |   OPCODE_exit = 0x8000,
  8 |   OPCODE_Load = 0x8001,
  9 |   OPCODE_LoadTex = 0x8002,
 10 |   OPCODE_LoadTexAsync = 0x8003,
 11 |   OPCODE_LoadTexWait = 0x8004,
 12 |   OPCODE_ReleaseTex = 0x8005,
 13 |   OPCODE_ChangeAnimation = 0x8006,
 14 |   OPCODE_Message = 0x8007,
 15 |   OPCODE_Wait = 0x8008,
 16 |   OPCODE_WaitFade = 0x8009,
 17 |   OPCODE_WaitMenu = 0x800A,
 18 |   OPCODE_SetChrPos = 0x800B,
 19 |   OPCODE_Move = 0x800C,
 20 |   OPCODE_MoveTo = 0x800D,
 21 |   OPCODE_MoveToChr = 0x800E,
 22 |   OPCODE_MoveEx = 0x800F,
 23 |   OPCODE_MoveToEx = 0x8010,
 24 |   OPCODE_MoveToEx2 = 0x8011,
 25 |   OPCODE_MoveToChrEx = 0x8012,
 26 |   OPCODE_Turn = 0x8013,
 27 |   OPCODE_Turn2 = 0x8014,
 28 |   OPCODE_TurnTo = 0x8015,
 29 |   OPCODE_TurnToVec = 0x8016,
 30 |   OPCODE_TurnToChr = 0x8017,
 31 |   OPCODE_Jump = 0x8018,
 32 |   OPCODE_Dash = 0x8019,
 33 |   OPCODE_ForceDash = 0x801A,
 34 |   OPCODE_MoveZ = 0x801B,
 35 |   OPCODE_MoveRotate = 0x801C,
 36 |   OPCODE_ResetChrPos = 0x801D,
 37 |   OPCODE_ClearDebris = 0x801E,
 38 |   OPCODE_MoveCameraAt = 0x801F,
 39 |   OPCODE_RotateCamera = 0x8020,
 40 |   OPCODE_ChangeCameraZoom = 0x8021,
 41 |   OPCODE_ChangeCameraPers = 0x8022,
 42 |   OPCODE_ChangeCameraElevatio = 0x8023,
 43 |   OPCODE_ChangeCameraDistance = 0x8024,
 44 |   OPCODE_MoveCamera = 0x8025,
 45 |   OPCODE_SaveCamera = 0x8026,
 46 |   OPCODE_RestoreCamera = 0x8027,
 47 |   OPCODE_SetStopFlag = 0x8028,
 48 |   OPCODE_ResetStopFlag = 0x8029,
 49 |   OPCODE_SetChrInfoFlag = 0x802A,
 50 |   OPCODE_ResetChrInfoFlag = 0x802B,
 51 |   OPCODE_SetFlag = 0x802C,
 52 |   OPCODE_SetChrWork = 0x802D,
 53 |   OPCODE_SetWork = 0x802E,
 54 |   OPCODE_JoinParty = 0x802F,
 55 |   OPCODE_JoinGuest = 0x8030,
 56 |   OPCODE_SeparateParty = 0x8031,
 57 |   OPCODE_FadeOut = 0x8032,
 58 |   OPCODE_FadeIn = 0x8033,
 59 |   OPCODE_CrossFade = 0x8034,
 60 |   OPCODE_MenuReset = 0x8035,
 61 |   OPCODE_MenuAdd = 0x8036,
 62 |   OPCODE_MenuOpen = 0x8037,
 63 |   OPCODE_MenuClose = 0x8038,
 64 |   OPCODE_YesNoMenu = 0x8039,
 65 |   OPCODE_MiniGame = 0x803A,
 66 |   OPCODE_Play = 0x803B,
 67 |   OPCODE_StopBGM = 0x803C,
 68 |   OPCODE_PlaySE = 0x803D,
 69 |   OPCODE_PlaySE3D = 0x803E,
 70 |   OPCODE_SetName = 0x803F,
 71 |   OPCODE_TalkMes = 0x8040,
 72 |   OPCODE_Message2 = 0x8041,
 73 |   OPCODE_WaitPrompt = 0x8042,
 74 |   OPCODE_ClosePrompt = 0x8043,
 75 |   OPCODE_Portrait_Load = 0x8044,
 76 |   OPCODE_Portrait_Unload = 0x8045,
 77 |   OPCODE_Portrait_Create = 0x8046,
 78 |   OPCODE_Portrait_Close = 0x8047,
 79 |   OPCODE_Portrait_Anime = 0x8048,
 80 |   OPCODE_Portrait3D_Set = 0x8049,
 81 |   OPCODE_Portrait3D_Release = 0x804A,
 82 |   OPCODE_Portrait3D_Create = 0x804B,
 83 |   OPCODE_Portrait3D_Close = 0x804C,
 84 |   OPCODE_Portrait3D_Anime = 0x804D,
 85 |   OPCODE_Execute = 0x804E,
 86 |   OPCODE_ExecuteFunc = 0x804F,
 87 |   OPCODE_WaitThread = 0x8050,
 88 |   OPCODE_WaitThread2 = 0x8051,
 89 |   OPCODE_StopThread = 0x8052,
 90 |   OPCODE_StopThread2 = 0x8053,
 91 |   OPCODE_EventCue = 0x8054,
 92 |   OPCODE_HP_Heal = 0x8055,
 93 |   OPCODE_HP_Recover = 0x8056,
 94 |   OPCODE_HPMax_Recover = 0x8057,
 95 |   OPCODE_SP_Recover = 0x8058,
 96 |   OPCODE_SPMax_Recover = 0x8059,
 97 |   OPCODE_RepairSkillCount = 0x805A,
 98 |   OPCODE_SetCameraMode = 0x805B,
 99 |   OPCODE_SetCameraZPlane = 0x805C,
100 |   OPCODE_ResetCameraZPlane = 0x805D,
101 |   OPCODE_ChangeCamera = 0x805E,
102 |   OPCODE_Effect = 0x805F,
103 |   OPCODE_Effect2 = 0x8060,
104 |   OPCODE_ChrEffect = 0x8061,
105 |   OPCODE_ChrEffect2 = 0x8062,
106 |   OPCODE_ChrSpecular = 0x8063,
107 |   OPCODE_Hagitori = 0x8064,
108 |   OPCODE_Hagitori2 = 0x8065,
109 |   OPCODE_ChangeFace = 0x8066,
110 |   OPCODE_HeadYes = 0x8067,
111 |   OPCODE_HeadNo = 0x8068,
112 |   OPCODE_Look = 0x8069,
113 |   OPCODE_LookChr = 0x806A,
114 |   OPCODE_LookTo = 0x806B,
115 |   OPCODE_LookVec = 0x806C,
116 |   OPCODE_LookReset = 0x806D,
117 |   OPCODE_Emotion = 0x806E,
118 |   OPCODE_MapHide = 0x806F,
119 |   OPCODE_MapAnime = 0x8070,
120 |   OPCODE_MapAnimeIndex = 0x8071,
121 |   OPCODE_MapAnimeLast = 0x8072,
122 |   OPCODE_ShopOpen = 0x8073,
123 |   OPCODE_ShowMinipop = 0x8074,
124 |   OPCODE_ChangeItemState = 0x8075,
125 |   OPCODE_EventBox = 0x8076,
126 |   OPCODE_EventBox2 = 0x8077,
127 |   OPCODE_EventAreaEnable = 0x8078,
128 |   OPCODE_ChangeItemSlot = 0x8079,
129 |   OPCODE_DeleteItem = 0x807A,
130 |   OPCODE_GetItem = 0x807B,
131 |   OPCODE_GetItemMessage = 0x807C,
132 |   OPCODE_AddItemLog = 0x807D,
133 |   OPCODE_ResetMotion = 0x807E,
134 |   OPCODE_PlayMMV = 0x807F,
135 |   OPCODE_if = 0x8080,
136 |   OPCODE_elseIf = 0x8081,
137 |   OPCODE_else = 0x8082,
138 |   OPCODE_switch = 0x8083,
139 |   OPCODE_while = 0x8084,
140 |   OPCODE_8085 = 0x8085, // goto / jump ?
141 |   OPCODE_break = 0x8086,
142 |   OPCODE_8087 = 0x8087, // end if ?
143 |   OPCODE_case = 0x8088,
144 |   OPCODE_default = 0x8089,
145 |   OPCODE_FreeMove = 0x808A,
146 |   OPCODE_ResetFollowPoint = 0x808B,
147 |   OPCODE_ResetPartyPos = 0x808C,
148 |   OPCODE_CurePoison = 0x808D,
149 |   OPCODE_EarthQuake = 0x808E,
150 |   OPCODE_SetLevel = 0x808F,
151 |   OPCODE_EquipWeapon = 0x8090,
152 |   OPCODE_EquipArmor = 0x8091,
153 |   OPCODE_EquipShield = 0x8092,
154 |   OPCODE_EquipAccessory = 0x8093,
155 |   OPCODE_Entry = 0x8094,
156 |   OPCODE_EntryOn = 0x8095,
157 |   OPCODE_SetEventParam = 0x8096,
158 |   OPCODE_SetCheckPoint = 0x8097,
159 |   OPCODE_GetCheckPoint = 0x8098,
160 |   OPCODE_WarpMenu = 0x8099,
161 |   OPCODE_TopicMenu = 0x809A,
162 |   OPCODE_DestroyObj = 0x809B,
163 |   OPCODE_GetSkill = 0x809C,
164 |   OPCODE_SetSkillShortCut = 0x809D,
165 |   OPCODE_SetLeverState = 0x809E,
166 |   OPCODE_SetLeverNotChange = 0x809F,
167 |   OPCODE_BtlPopup = 0x80A0,
168 |   OPCODE_AddEX = 0x80A1,
169 |   OPCODE_SetPartyMember = 0x80A2,
170 |   OPCODE_SavePartyMember = 0x80A3,
171 |   OPCODE_RestorePartyMember = 0x80A4,
172 |   OPCODE_SetEventPartyChr = 0x80A5,
173 |   OPCODE_LoadEventPartyChr = 0x80A6,
174 |   OPCODE_ReleaseEventPartyChr = 0x80A7,
175 |   OPCODE_TimeStop = 0x80A8,
176 |   OPCODE_PartyMenu = 0x80A9,
177 |   OPCODE_Reset = 0x80AA,
178 |   OPCODE_DoorOpen = 0x80AB,
179 |   OPCODE_DoorClose = 0x80AC,
180 |   OPCODE_ChrAlpha = 0x80AD,
181 |   OPCODE_ChrColor = 0x80AE,
182 |   OPCODE_MapColor = 0x80AF,
183 |   OPCODE_MapDelProp = 0x80B0,
184 |   OPCODE_MapSetProp = 0x80B1,
185 |   OPCODE_Blur = 0x80B2,
186 |   OPCODE_GameOver = 0x80B3,
187 |   OPCODE_LoadEffect = 0x80B4,
188 |   OPCODE_ReleaseEffect = 0x80B5,
189 |   OPCODE_TimeAtkStart = 0x80B6,
190 |   OPCODE_TimeAtk = 0x80B7,
191 |   OPCODE_TimeAtkMenuReset = 0x80B8,
192 |   OPCODE_TimeAtkMenuAdd = 0x80B9,
193 |   OPCODE_TimeAtkMenuOpen = 0x80BA,
194 |   OPCODE_AutoSave = 0x80BB,
195 |   OPCODE_ReturnTitle = 0x80BC,
196 |   OPCODE_StopEffect = 0x80BD,
197 |   OPCODE_StopEmotion = 0x80BE,
198 |   OPCODE_PartyChrHide = 0x80BF,
199 |   OPCODE_GetItemMessageEx = 0x80C0,
200 |   OPCODE_CopyStatus = 0x80C1,
201 |   OPCODE_Movie = 0x80C2,
202 |   OPCODE_WaitMovie = 0x80C3,
203 |   OPCODE_EmotionEx = 0x80C4,
204 |   OPCODE_SetFumiSwitch = 0x80C5,
205 |   OPCODE_StopSE = 0x80C6,
206 |   OPCODE_SetEnvSEPlayState = 0x80C7,
207 |   OPCODE_SetFog = 0x80C8,
208 |   OPCODE_GetItemMessageExPlus = 0x80C9,
209 |   OPCODE_ResetPresetCamera = 0x80CA,
210 |   OPCODE_Cure = 0x80CB,
211 |   OPCODE_CampMenu = 0x80CC,
212 |   OPCODE_ResetMoveVec = 0x80CD,
213 |   OPCODE_PlayBGMB = 0x80CE,
214 |   OPCODE_RemovePartyEquip = 0x80CF,
215 |   OPCODE_AddStatus = 0x80D0,
216 |   OPCODE_SetPlaceName = 0x80D1,
217 |   OPCODE_YesNoMenuEx = 0x80D2,
218 |   OPCODE_SetPartyPosEntryOut = 0x80D3,
219 |   OPCODE_MPMenu = 0x80D4,
220 |   OPCODE_SetMapMarker = 0x80D5,
221 |   OPCODE_DelMapMarker = 0x80D6,
222 |   OPCODE_DeleteArgMarker = 0x80D7,
223 |   OPCODE_SetEventNPC = 0x80D8,
224 |   OPCODE_PuzzleOpen = 0x80D9,
225 |   OPCODE_SetPortal = 0x80DA,
226 |   OPCODE_CreateKoma = 0x80DB,
227 |   OPCODE_CloseKoma = 0x80DC,
228 |   OPCODE_Portrait_SetKoma = 0x80DD,
229 |   OPCODE_SetKomaInfo = 0x80DE,
230 |   OPCODE_SetKomaColor = 0x80DF,
231 |   OPCODE_MoveKoma = 0x80E0,
232 |   OPCODE_MoveKomaEx = 0x80E1,
233 |   OPCODE_VibratePortrait = 0x80E2,
234 |   OPCODE_VibrateKoma = 0x80E3,
235 |   OPCODE_SetFadeColor = 0x80E4,
236 |   OPCODE_Portrait_Change = 0x80E5,
237 |   OPCODE_HP_ORecover = 0x80E6,
238 |   OPCODE_ChangeHDRBaseLum = 0x80E7,
239 |   OPCODE_ChangeHDRSoftFocus = 0x80E8,
240 |   OPCODE_ChangeHDRDoF = 0x80E9,
241 |   OPCODE_ResetHDRParam = 0x80EA,
242 |   OPCODE_MapNodeEvent = 0x80EB,
243 |   OPCODE_EventAttack = 0x80EC,
244 |   OPCODE_EventDamage = 0x80ED,
245 |   OPCODE_WaitAnimation = 0x80EE,
246 |   OPCODE_MoveToEx3 = 0x80EF,
247 |   OPCODE_EvTimeShift = 0x80F0,
248 |   OPCODE_SetDiaryFlag = 0x80F1,
249 |   OPCODE_QuestBoard = 0x80F2,
250 |   OPCODE_ReturnMemoryMenu = 0x80F3,
251 |   OPCODE_Set3DParticle = 0x80F4,
252 |   OPCODE_Change = 0x80F5,
253 |   OPCODE_Change3DParticleVec = 0x80F6,
254 |   OPCODE_Stop = 0x80F7,
255 |   OPCODE_SetOverlay = 0x80F8,
256 |   OPCODE_StopOverlay = 0x80F9,
257 |   OPCODE_SetParent = 0x80FA,
258 |   OPCODE_ChrNodeHide = 0x80FB,
259 |   OPCODE_ForceChangeCamera = 0x80FC,
260 |   OPCODE_RollCamera = 0x80FD,
261 |   OPCODE_CheckChrAngle = 0x80FE,
262 |   OPCODE_CheckChrDistance = 0x80FF,
263 |   OPCODE_SetMapViewPos = 0x8100,
264 |   OPCODE_ResetTracks = 0x8101,
265 |   OPCODE_DiscoverMemory = 0x8102,
266 |   OPCODE_StartZapping = 0x8103,
267 |   OPCODE_StopZapping = 0x8104,
268 |   OPCODE_ChrLightState = 0x8105,
269 |   OPCODE_ChrLightRadius = 0x8106,
270 |   OPCODE_ChrLightColor = 0x8107,
271 |   OPCODE_CreateLight = 0x8108,
272 |   OPCODE_SetLightState = 0x8109,
273 |   OPCODE_SetLightRadius = 0x810A,
274 |   OPCODE_SetLightColor = 0x810B,
275 |   OPCODE_CureAll = 0x810C,
276 |   OPCODE_SetCondition = 0x810D,
277 |   OPCODE_PlaySELabel = 0x810E,
278 |   OPCODE_PlaySE3DLabel = 0x810F,
279 |   OPCODE_StopSELabel = 0x8110,
280 |   OPCODE_FadeSELabel = 0x8111,
281 |   OPCODE_FadeBGM = 0x8112,
282 |   OPCODE_SetWeaponKillScript = 0x8113,
283 |   OPCODE_Timer = 0x8114,
284 |   OPCODE_VisualName = 0x8115,
285 |   OPCODE_SetArgInitPos = 0x8116,
286 |   OPCODE_PlayVoice = 0x8117,
287 |   OPCODE_PlayVoice3D = 0x8118,
288 |   OPCODE_StopVoice = 0x8119,
289 |   OPCODE_SetShadowBound = 0x811A,
290 |   OPCODE_ResetShadowBound = 0x811B,
291 |   OPCODE_GetTrophy = 0x811C,
292 |   OPCODE_MemoryMenu = 0x811D,
293 |   OPCODE_RemoveEquipAll = 0x811E,
294 |   OPCODE_EndTimeAtk = 0x811F,
295 |   OPCODE_ChangeSubAnimation = 0x8120,
296 |   OPCODE_SubAnimationMode = 0x8121,
297 |   OPCODE_OpenMinimap = 0x8122,
298 |   OPCODE_SetCantUseItem = 0x8123,
299 |   OPCODE_WaitAniProcess = 0x8124,
300 |   OPCODE_UseItem = 0x8125,
301 |   OPCODE_TalkPopup = 0x8126,
302 |   OPCODE_MenuType = 0x8127,
303 |   OPCODE_SetFogBack = 0x8128,
304 |   OPCODE_SetDoF = 0x8129,
305 |   OPCODE_SetDoFFocus = 0x812A,
306 |   OPCODE_SetGlare = 0x812B,
307 |   OPCODE_SetFogLightFade = 0x812C,
308 |   OPCODE_SetMapLightColor = 0x812D,
309 |   OPCODE_SetMapLightVec = 0x812E,
310 |   OPCODE_SetMapShadowColor = 0x812F,
311 |   OPCODE_SetMapChrColor = 0x8130,
312 |   OPCODE_SetChrLightRatio = 0x8131,
313 |   OPCODE_SetWeaponLevel = 0x8132,
314 |   OPCODE_WaitCloseWindow = 0x8133,
315 |   OPCODE_LookRotateLimit = 0x8134,
316 |   OPCODE_LookRoll = 0x8135,
317 |   OPCODE_LookSpd = 0x8136,
318 |   OPCODE_FixCamera = 0x8137,
319 |   OPCODE_ResetMapParam = 0x8138,
320 |   OPCODE_SetName2 = 0x8139,
321 |   OPCODE_OpenMessage = 0x813A,
322 |   OPCODE_CloseMessage = 0x813B,
323 |   OPCODE_WaitCloseMessage = 0x813C,
324 |   OPCODE_SetWorldMapping = 0x813D,
325 |   OPCODE_SetMotSpd = 0x813E,
326 |   OPCODE_KeyAnimeCreate = 0x813F,
327 |   OPCODE_KeyAnimeSet = 0x8140,
328 |   OPCODE_KeyAnimeCamera = 0x8141,
329 |   OPCODE_KeyAnimeChara = 0x8142,
330 |   OPCODE_KeyAnimeRelease = 0x8143,
331 |   OPCODE_WaitAnimation2 = 0x8144,
332 |   OPCODE_ActiveVoiceStart = 0x8145,
333 |   OPCODE_ActiveVoiceStop = 0x8146,
334 |   OPCODE_InterceptStart = 0x8147,
335 |   OPCODE_Intercept = 0x8148,
336 |   OPCODE_JoinNPC = 0x8149,
337 |   OPCODE_SetFishingRank = 0x814A,
338 |   OPCODE_CheckFishingSpotCoun = 0x814B,
339 |   OPCODE_InterceptStop = 0x814C,
340 |   OPCODE_EquipCostume = 0x814D,
341 |   OPCODE_SetFogWater = 0x814E,
342 |   OPCODE_CallFunc = 0x814F,
343 |   OPCODE_FixPlayerChr = 0x8150,
344 |   OPCODE_SetShadowOffset = 0x8151,
345 |   OPCODE_SetShadowOffsetChr = 0x8152,
346 |   OPCODE_SetYs8Camera = 0x8153,
347 |   OPCODE_ResetYs8Camera = 0x8154,
348 |   OPCODE_DelCheckPoint = 0x8155,
349 |   OPCODE_SetSkipScript = 0x8156,
350 |   OPCODE_Slow = 0x8157,
351 |   OPCODE_SoundEfx = 0x8158,
352 |   OPCODE_SetFishingAreaState = 0x8159,
353 |   OPCODE_SaveEventState = 0x815A,
354 |   OPCODE_RestoreEventState = 0x815B,
355 |   OPCODE_GetInterceptRank = 0x815C,
356 |   OPCODE_InterceptResume = 0x815D,
357 |   OPCODE_InterceptKickOffMenu = 0x815E,
358 |   OPCODE_GetCoopEvPeopleNum = 0x815F,
359 |   OPCODE_PitchChr = 0x8160,
360 |   OPCODE_RollChr = 0x8161,
361 |   OPCODE_AddWarpDisableList = 0x8162,
362 |   OPCODE_GetProgressQuest = 0x8163,
363 |   OPCODE_SetDiaryCharaFlag = 0x8164,
364 |   OPCODE_ItemBackup = 0x8165,
365 |   OPCODE_UseFood = 0x8166,
366 |   OPCODE_GetNumKilledEnemy = 0x8167,
367 |   OPCODE_SetRealTimeHelp = 0x8168,
368 |   OPCODE_SetEventDriven = 0x8169,
369 |   OPCODE_PlaySceneVoice = 0x816A,
370 |   OPCODE_Portrait = 0x816B,
371 |   OPCODE_CameraShakeParam = 0x816C,
372 |   OPCODE_GetExp = 0x816D,
373 |   OPCODE_SetDiaryShopFlag = 0x816E,
374 |   OPCODE_ChangeChrPos = 0x816F,
375 |   OPCODE_ItemCue = 0x8170,
376 |   OPCODE_InterceptSetRetMap = 0x8171,
377 |   OPCODE_WarpCancel = 0x8172,
378 |   OPCODE_DropItem = 0x8173,
379 |   OPCODE_DelWarpDisableList = 0x8174,
380 |   OPCODE_SetChrInfoFlagStr = 0x8175,
381 |   OPCODE_LoadChr = 0x8176,
382 |   OPCODE_ReleaseChr = 0x8177,
383 |   OPCODE_ReleaseChrGo = 0x8178,
384 |   OPCODE_SetGradationColor = 0x8179,
385 |   OPCODE_SetLensFlare = 0x817A,
386 |   OPCODE_GetDiaryCharaFlag = 0x817B,
387 |   OPCODE_SetChrAtariFlag = 0x817C,
388 |   OPCODE_MenuEnable = 0x817D,
389 |   OPCODE_SetChrID = 0x817E,
390 |   OPCODE_GetTrophyDirect = 0x817F,
391 |   OPCODE_DelMapMarkerAll = 0x8180,
392 |   OPCODE_DelSkillNewMark = 0x8181,
393 |   OPCODE_8182 = 0x8182,
394 | 
395 |   OPCODE_COUNT = 0x183
396 | };
397 | 


--------------------------------------------------------------------------------
/bin2script.cpp:
--------------------------------------------------------------------------------
  1 | // Scene tool
  2 | 
  3 | #include "sceneTool.hh"
  4 | #include "sceneOpCodes.hh"
  5 | #include "sceneOpCodeNames.hh"
  6 | #include "vcalcOpCodes.hh"
  7 | 
  8 | #include <string>
  9 | #include <iostream>
 10 | #include <algorithm>
 11 | #include <iomanip>
 12 | 
 13 | #include <sstream>
 14 | #include <fstream>
 15 | #include <cstring>
 16 | #include <stack>
 17 | #include <map>
 18 | 
 19 | 
 20 | uint16_t read16(std::ifstream& input) {
 21 | 	uint16_t data;
 22 | 	input.read((char*)&data, (int)sizeof(data));
 23 | 	return data;
 24 | }
 25 | 
 26 | uint32_t read32(std::ifstream& input) {
 27 | 	uint32_t data;
 28 | 	input.read((char*)&data, (int)sizeof(data));
 29 | 	return data;
 30 | }
 31 | 
 32 | uint64_t read64(std::ifstream& input) {
 33 | 	uint64_t data;
 34 | 	input.read((char*)&data, (int)sizeof(data));
 35 | 	return data;
 36 | }
 37 | 
 38 | // Checksum reverse by weaknespase
 39 | uint32_t checksum(const char* in, const uint32_t length, int last = 0){
 40 | 	const char* end = in + length;
 41 | 	int acc = last;
 42 | 	while (in < end)
 43 | 		acc = (acc * 33) ^ (unsigned char) *in++;
 44 | 	return acc;
 45 | }
 46 | 
 47 | #define read_elem(fh, elem) fh.read((char*)&elem, (int)sizeof(elem))
 48 | 
 49 | 
 50 | void process_segment( std::ifstream& fh, SEGMENT_HEADER& segHead );
 51 | 
 52 | void print_hex(uint8_t *data, uint32_t size, std::stringstream &stream)
 53 | {
 54 | 	for (uint32_t i = 0; i < size; ++i) {
 55 | 		stream << " " << std::hex << std::setfill('0') << std::setw(2)
 56 | 			<< (int)data[i] << std::dec;
 57 | 	}
 58 | }
 59 | 
 60 | bool print_vcalc(uint8_t *data, uint32_t size, std::string &oString)
 61 | {
 62 | 	bool hasNop = false;
 63 | 	bool done = false;
 64 | 	bool success = true;
 65 | 	uint8_t *end = data + size;
 66 | 	uint8_t *pCur = data;
 67 | 	uint32_t vLast = 0;
 68 | 	bool isIntLast = true;
 69 | 	uint8_t nbVals = 0;
 70 | 	std::string sCalc, sLast, sVal;
 71 | 	std::stack<std::string> vStack;
 72 | 
 73 | 	while ( pCur < end ) {
 74 | 
 75 | 		if ( done )
 76 | 			return false;
 77 | 
 78 | 		uint16_t vcalcOp = *(uint16_t*)pCur;
 79 | 		pCur += 2;
 80 | 
 81 | 		if ( vStack.size() > 0 )
 82 | 			sVal = vStack.top();
 83 | 
 84 | 		hasNop = false;
 85 | 
 86 | 		switch ( vcalcOp ) {
 87 | 		case VCODE_NEQ:
 88 | 			vStack.pop(); sLast = vStack.top(); vStack.pop();
 89 | 			sVal = "(" + sLast + " != " + sVal + ")";
 90 | 			break;
 91 | 
 92 | 		case VCODE_NOT:
 93 | 			vStack.pop();
 94 | 			sVal = "!" + sVal + "";
 95 | 			break;
 96 | 
 97 | 		case VCODE_MUL:
 98 | 			vStack.pop(); sLast = vStack.top(); vStack.pop();
 99 | 			sVal = "(" + sLast + " * " + sVal + ")";
100 | 			break;
101 | 
102 | 		case VCODE_DIV:
103 | 			vStack.pop(); sLast = vStack.top(); vStack.pop();
104 | 			sVal = "(" + sLast + " / " + sVal + ")";
105 | 			break;
106 | 
107 | 		case VCODE_IDIV:
108 | 			vStack.pop(); sLast = vStack.top(); vStack.pop();
109 | 			sVal = "(" + sLast + " // " + sVal + ")";
110 | 			break;
111 | 
112 | 		case VCODE_ADD:
113 | 			vStack.pop(); sLast = vStack.top(); vStack.pop();
114 | 			sVal = "(" + sLast + " + " + sVal + ")";
115 | 			break;
116 | 
117 | 		case VCODE_SUB:
118 | 			vStack.pop(); sLast = vStack.top(); vStack.pop();
119 | 			sVal = "(" + sLast + " - " + sVal + ")";
120 | 			break;
121 | 
122 | 		case VCODE_SRL:
123 | 			vStack.pop(); sLast = vStack.top(); vStack.pop();
124 | 			sVal = "(" + sLast + " >> " + sVal + ")";
125 | 			break;
126 | 
127 | 		case VCODE_GE:
128 | 			vStack.pop(); sLast = vStack.top(); vStack.pop();
129 | 			sVal = "(" + sLast + " >= " + sVal + ")";
130 | 			break;
131 | 
132 | 		case VCODE_GT:
133 | 			vStack.pop(); sLast = vStack.top(); vStack.pop();
134 | 			sVal = "(" + sLast + " > " + sVal + ")";
135 | 			break;
136 | 
137 | 		case VCODE_SLL:
138 | 			vStack.pop(); sLast = vStack.top(); vStack.pop();
139 | 			sVal = "(" + sLast + " << " + sVal + ")";
140 | 			break;
141 | 
142 | 		case VCODE_LE:
143 | 			vStack.pop(); sLast = vStack.top(); vStack.pop();
144 | 			sVal = "(" + sLast + " <= " + sVal + ")";
145 | 			break;
146 | 
147 | 		case VCODE_LT:
148 | 			vStack.pop(); sLast = vStack.top(); vStack.pop();
149 | 			sVal = "(" + sLast + " < " + sVal + ")";
150 | 			break;
151 | 
152 | 		case VCODE_EQ:
153 | 			vStack.pop(); sLast = vStack.top(); vStack.pop();
154 | 			sVal = "(" + sLast + " == " + sVal + ")";
155 | 			break;
156 | 
157 | 		case VCODE_AND:
158 | 			vStack.pop(); sLast = vStack.top(); vStack.pop();
159 | 			sVal = "(" + sLast + " && " + sVal + ")";
160 | 			break;
161 | 
162 | 		case VCODE_BAND:
163 | 			vStack.pop(); sLast = vStack.top(); vStack.pop();
164 | 			sVal = "(" + sLast + " & " + sVal + ")";
165 | 			break;
166 | 
167 | 		case VCODE_OR:
168 | 			vStack.pop(); sLast = vStack.top(); vStack.pop();
169 | 			sVal = "(" + sLast + " || " + sVal + ")";
170 | 			break;
171 | 
172 | 		case VCODE_BOR:
173 | 			vStack.pop(); sLast = vStack.top(); vStack.pop();
174 | 			sVal = "(" + sLast + " | " + sVal + ")";
175 | 			break;
176 | 
177 | 		case VCODE_BNOT:
178 | 			vStack.pop();
179 | 			sVal = "~" + sVal + "";
180 | 			break;
181 | 
182 | 		case VCODE_XOR:
183 | 			vStack.pop(); sLast = vStack.top(); vStack.pop();
184 | 			sVal = "(" + sLast + " ^ " + sVal + ")";
185 | 			break;
186 | 
187 | 		case VCODE_LDINT: {
188 | 			vLast = *(uint32_t*)pCur;
189 | 			pCur += 4;
190 | 
191 | 			sVal = std::to_string(vLast);
192 | 			break;
193 | 		}
194 | 
195 | 		case VCODE_LDFLT: {
196 | 			vLast = *(uint32_t*)pCur;
197 | 			float value = *(float*)pCur;
198 | 			pCur += 4;
199 | 
200 | 			sVal = std::to_string(value);
201 | 			break;
202 | 		}
203 | 
204 | 		case VCODE_END:
205 | 			hasNop = true;
206 | 			done = true;
207 | 			break;
208 | 
209 | 		case VCODE_LDVAR: {
210 | 			vStack.pop();
211 | 			sVal = std::string(isIntLast ? "iVar" : "fVar") + "[" + std::to_string(vLast) + "]";
212 | 			break;
213 | 		}
214 | 
215 | 		// Don't handle nops
216 | 		// case VCODE_NOP:
217 | 		// 	hasNop = true;
218 | 		// 	break;
219 | 
220 | 		case VCODE_ABS:
221 | 			vStack.pop();
222 | 			sVal = "|" + sVal + "|";
223 | 			break;
224 | 
225 | 		case VCODE_F2I:
226 | 			vStack.pop();
227 | 			sVal = "(int)" + sVal;
228 | 			break;
229 | 
230 | 		case VCODE_I2F:
231 | 			vStack.pop();
232 | 			sVal = "(float)" + sVal;
233 | 			break;
234 | 
235 | 		case VCODE_RAND:
236 | 			sVal = "RAND";
237 | 			break;
238 | 
239 | 		case VCODE_FRAND:
240 | 			sVal = "FRAND";
241 | 			break;
242 | 
243 | 		case VCODE_NEG:
244 | 			vStack.pop();
245 | 			sVal = "-" + sVal;
246 | 			break;
247 | 
248 | 		default:
249 | 			// std::cerr << "VCALC UNSUPPORTED OPERATION : 0x" << std::hex << vcalcOp << std::dec << std::endl;
250 | 			// exit(1);
251 | 			return false;
252 | 		}
253 | 
254 | 		if ( !hasNop )
255 | 			vStack.push(sVal);
256 | 	}
257 | 
258 | 	if ( vStack.size() != 1 ) {
259 | 		std::cerr << "VCALC STACK ERROR : " << vStack.size() << std::endl;
260 | 		std::cerr << "TOP : " << vStack.top() << std::endl;
261 | 		// vStack.pop();
262 | 		// std::cerr << "TOP : " << vStack.top() << std::endl;
263 | 		std::stringstream ss;
264 | 		print_hex(data, size, ss);
265 | 		std::cerr << ss.str() << std::endl;
266 | 		// exit(1);
267 | 		return false;
268 | 	}
269 | 
270 | 	if ( done )
271 | 		oString = vStack.top();
272 | 
273 | 	return done;
274 | }
275 | 
276 | 
277 | bool minimize = false;
278 | bool enable_vcalc = false;
279 | 
280 | 
281 | int main(int argc, char *argv[])
282 | {
283 | 	// std::string ss;
284 | 	// uint8_t tData[] = { 0x1A, 0, 1, 0, 0, 0, 0x1F, 0, 0x1D, 0 };
285 | 	// print_vcalc( tData, sizeof(tData), ss ); std::cout << ss << std::endl;
286 | 	//exit(0);
287 | 	std::string iPath;
288 | 
289 | 	for ( int i = 1; i < argc; i++ ) {
290 | 
291 | 		std::string arg = argv[i];
292 | 
293 | 		if ( arg == "-m" ) {
294 | 			std::cerr << "Minimizing output" << std::endl;
295 | 			minimize = true;
296 | 		}
297 | 
298 | 		else if ( arg == "-t" ) {
299 | 			std::cerr << "Enabling VCALC translation" << std::endl;
300 | 			enable_vcalc = true;
301 | 		}
302 | 
303 | 		else if ( iPath.size() < 1 ) {
304 | 			iPath = arg;
305 | 		}
306 | 	}
307 | 
308 | 	if ( argc < 2 || iPath.size() < 1 ) {
309 | 		std::cerr << "Usage : " << argv[0]
310 | 			<< " <byteScript> (-m Minimize, -t VCALC translation)" << std::endl;
311 | 		return -1;
312 | 	}
313 | 
314 | 	std::ifstream iFile( iPath.c_str(), std::ios_base::binary );
315 | 
316 | 	if ( !iFile.is_open() ) {
317 | 		std::cerr << iPath << " not found" << std::endl;
318 | 		return -2;
319 | 	}
320 | 
321 | 
322 | 	FILE_HEADER_V2 headerV2;
323 | 	read_elem( iFile, headerV2 );
324 | 
325 | 	if ( strncmp( headerV2.magic, "YS7_SCP", 8 ) ) {
326 | 		std::cerr << "Invalid input file" << std::endl;
327 | 		iFile.close();
328 | 		return 1;
329 | 	}
330 | 
331 | 	SEGMENT_HEADER segHeads[ headerV2.segs_count ];
332 | 	read_elem( iFile, segHeads );
333 | 
334 | 	for ( int i = 0; i < headerV2.segs_count; i++ ) {
335 | 		process_segment( iFile, segHeads[i] );
336 | 	}
337 | 
338 | 	iFile.close();
339 | 
340 | 	return 0;
341 | }
342 | 
343 | inline bool isJapOpCode( uint16_t code )
344 | {
345 | 	return (0x8000 <= code && code <= 0x8181);
346 | }
347 | 
348 | inline bool isOpCode( uint16_t code )
349 | {
350 | 	return (0x8000 <= code && code <= 0x8182);
351 | }
352 | 
353 | std::map<uint32_t, uint32_t> labelMap;
354 | 
355 | void process_segment( std::ifstream& fh, SEGMENT_HEADER& segHead )
356 | {
357 | 	fh.seekg( segHead.offset );
358 | 
359 | 	uint32_t size = segHead.size;
360 | 	char *segment = (char*)malloc( size );
361 | 
362 | 	fh.read( segment, size );
363 | 
364 | 	std::cout << std::endl;
365 | 	std::cout << "0x" << std::hex << (int)segHead.offset << std::dec << std::endl;
366 | 	std::cout << segHead.name << std::endl;
367 | 	std::cout << "Size : 0x" << std::hex << (int)segHead.size << std::dec << std::endl;
368 | 
369 | 	char *pSeg = segment, *pEnd = segment + size;
370 | 	bool hasJump = false;
371 | 	GENERIC_ARG arg;
372 | 	uint32_t labelIdx = 0;
373 | 
374 | 	std::stringstream ss;
375 | 	std::map<uint32_t, std::string> lines;
376 | 
377 | 	while ( true ) {
378 | 
379 | 		const uint32_t lineOffset = (uint32_t)(pSeg - segment);
380 | 
381 | 		if ( hasJump ) {
382 | 			uint32_t index = 0;
383 | 			const uint32_t labelOffset = (unsigned int)((pSeg - segment) + arg.iVal);
384 | 
385 | 			if ( labelMap.count( labelOffset ) <= 0 ) {
386 | 				index = labelIdx;
387 | 				labelMap[ labelOffset ] = labelIdx;
388 | 
389 | 				if ( arg.iVal < 0 ) {
390 | 
391 | 					if ( lines.count( labelOffset ) > 0 ) {
392 | 
393 | 						std::string oldLine = lines[ labelOffset ];
394 | 						std::string label = "label" + std::to_string(labelIdx) + ": ";
395 | 						std::string newLine;
396 | 
397 | 						if ( !minimize ) {
398 | 							size_t begPos = oldLine.find(":");
399 | 							std::string relOffset = oldLine.substr( 0, begPos+2 );
400 | 							newLine = relOffset + label + oldLine.substr( begPos+2 );
401 | 						}
402 | 						else {
403 | 							size_t begPos = oldLine.find("\n");
404 | 							newLine = oldLine.substr(0, begPos+1) + label + oldLine.substr(begPos+1);
405 | 						}
406 | 
407 | 						lines[ labelOffset ] = newLine;
408 | 					}
409 | 
410 | 					else {
411 | 						std::cerr << "ERROR : invalid label reference to 0x" << std::hex << labelOffset << std::dec << std::endl;
412 | 					}
413 | 				}
414 | 
415 | 				labelIdx++;
416 | 			}
417 | 
418 | 			else
419 | 				index = labelMap[ labelOffset ];
420 | 
421 | 			ss << " / label" << index;
422 | 		}
423 | 
424 | 		if ( pSeg >= (pEnd-1) ) {
425 | 			lines[ lineOffset ] = ss.str();
426 | 			break;
427 | 		}
428 | 
429 | 		ss << std::endl;
430 | 
431 | 		OpCode opcode = (OpCode)*((uint16_t*)pSeg);
432 | 
433 | 		if ( !isOpCode( opcode ) ) {
434 | 			std::cerr << std::endl << "ERROR : bad opcode 0x"
435 | 				<< std::hex << (int)opcode
436 | 				<< " at offset 0x" << (pSeg - segment + segHead.offset)
437 | 				<< std::dec;
438 | 			// return;
439 | 		}
440 | 
441 | 		else if ( !isJapOpCode( opcode ) ) {
442 | 			std::cerr << std::endl << "WARNING : unsupported english opcode 0x"
443 | 				<< std::hex << (int)opcode
444 | 				<< " at offset 0x" << (pSeg - segment + segHead.offset)
445 | 				<< std::dec;
446 | 			// return;
447 | 		}
448 | 
449 | 		if ( !minimize ) {
450 | 			ss << "0x" << std::hex << std::setfill('0') << std::setw(4)
451 | 				<< (int)(pSeg - segment) << ": "
452 | 				<< std::dec;
453 | 		}
454 | 
455 | 		const uint32_t curOffset = (unsigned int)(pSeg - segment);
456 | 
457 | 		if ( labelMap.count( curOffset ) ) {
458 | 			ss << "label" << labelMap[ curOffset ] << ": ";
459 | 		}
460 | 
461 | 		uint32_t opcode_idx = opcode - OPCODE_exit;
462 | 		std::string opcode_name;
463 | 
464 | 		if ( opcode_idx < sizeof(opCodeNames)/sizeof(char*) ) {
465 | 			opcode_name = opCodeNames[ opcode_idx ];
466 | 			ss << opcode_name;
467 | 		}
468 | 		else {
469 | 			ss << std::hex << "0x" << opcode << std::dec;
470 | 		}
471 | 
472 | 		// std::cerr << std::endl << "pSeg = " << std::hex << (int)pSeg << std::dec;
473 | 		pSeg += sizeof(uint16_t);
474 | 		// std::cerr << std::endl << "sizeof(uint16_t) = " << sizeof(uint16_t);
475 | 		// std::cerr << std::endl << "pSeg = " << std::hex << (int)pSeg << std::dec;
476 | 		// std::cerr << std::endl << "opcode = " << std::hex << (int)opcode << std::dec;
477 | 
478 | 		// if ( opcode == OPCODE_exit ) {
479 | 		// 	ss << std::endl;
480 | 		// 	return;
481 | 		// }
482 | 
483 | 		bool is_opcode = false;
484 | 		uint16_t nargs = 0;
485 | 
486 | 		switch (opcode) {
487 | 		case OPCODE_if:
488 | 		case OPCODE_elseIf:
489 | 		case OPCODE_else:
490 | 		case OPCODE_break:
491 | 		case OPCODE_while:
492 | 		case OPCODE_case:
493 | 		case OPCODE_default:
494 | 		case OPCODE_Execute:
495 | 		case OPCODE_8085:
496 | 			hasJump = true;
497 | 			break;
498 | 
499 | 		default:
500 | 			hasJump = false;
501 | 		};
502 | 
503 | 
504 | 		while ( !is_opcode && (pSeg < (pEnd-1)) ) {
505 | 
506 | 			const char *pArg = pSeg;
507 | 			GENERIC_ARG cur = *((GENERIC_ARG*)pSeg);
508 | 			DataTag tag = (DataTag)cur.tag;
509 | 			is_opcode = isOpCode( tag );
510 | 			uint32_t tag_val;
511 | 
512 | 			if ( is_opcode || ++nargs >= 16 ) {
513 | 				// std::cerr << std::endl << "New OPCODE detected";
514 | 				break;
515 | 			}
516 | 
517 | 			else {
518 | 				// std::cerr << "New ARG detected" << std::endl;
519 | 				// pSeg += sizeof(uint16_t);
520 | 
521 | 				// tag_val = *((uint32_t*)pSeg);
522 | 				// pSeg += sizeof(uint32_t);
523 | 
524 | 				pSeg += sizeof(GENERIC_ARG);
525 | 
526 | 				// ss << " ";
527 | 			}
528 | 
529 | 			arg = cur;
530 | 
531 | 			// std::cerr << "Switch ARG" << std::endl;
532 | 
533 | 			switch ( tag ) {
534 | 
535 | 			case INT_TAG:
536 | 				ss << ", #" << arg.iVal;
537 | 
538 | 				if ( !minimize ) {
539 | 					ss << " (@ 0x" << std::hex << std::setfill('0') << std::setw(4)
540 | 							<< ((int)(pSeg - segment) + (int)arg.iVal) << std::dec << ")";
541 | 				}
542 | 				break;
543 | 
544 | 			case FLOAT_TAG:
545 | 				// ss << ", f" << arg.fVal;
546 | 				ss << ", .0x" << std::hex << arg.uVal << std::dec;
547 | 				ss << " (~ " << arg.fVal << ")";
548 | 				break;
549 | 
550 | 			case STRING_TAG: {
551 | 				ss << ", s\"";
552 | 				// ss << ", "<<arg.uVal<<"\"";
553 | 
554 | 				uint32_t len = arg.uVal;
555 | 				char data[len+1];
556 | 
557 | 				strncpy(data, pSeg, len);
558 | 				data[len] = 0;
559 | 				pSeg += len;
560 | 
561 | 				// TODO : find unambiguous string delimiters
562 | 				ss << data << "\"";
563 | 				break;
564 | 			}
565 | 
566 | 			case POPUP_TAG: {
567 | 				// ss << ", popup (" << arg.uVal << ":";
568 | 				ss << ", p";
569 | 
570 | 				POPUP_ARG popup = *(POPUP_ARG*)pArg;
571 | 				uint32_t nLines = popup.nLines;
572 | 				uint32_t len = popup.len;
573 | 				pSeg += sizeof(uint32_t);
574 | 
575 | 				uint32_t args[ nLines ];
576 | 
577 | 				for (uint32_t i = 0; i < nLines; i++) {
578 | 					args[i] = *((uint32_t*)pSeg);
579 | 					pSeg += sizeof(uint32_t);
580 | 
581 | 					// ss << " " << args[i] << " ;";
582 | 				}
583 | 
584 | 				// ss << " \"";
585 | 				ss << "\"";
586 | 
587 | 				char data[len+1];
588 | 
589 | 				strncpy(data, pSeg, len);
590 | 				data[len] = 0;
591 | 				pSeg += len;
592 | 
593 | 				// TODO : find unambiguous string delimiters
594 | 				ss << data << "\"";
595 | 				ss << " (";
596 | 
597 | 				for (uint32_t i = 0; i < nLines; i++) {
598 | 					ss << " " << args[i];
599 | 				}
600 | 				ss << " )";
601 | 
602 | 				// ss << data << "\" )";
603 | 				break;
604 | 			}
605 | 
606 | 			case VCALC_TAG: {
607 | 				uint32_t count = arg.uVal;
608 | 
609 | 				// if ( count != 8 ) {
610 | 				// 	std::cerr << std::endl << "WARNING : 0x82E0 ARG size = " << count;
611 | 				// }
612 | 
613 | 				if ( count > (pEnd - pSeg) ) {
614 | 					std::cerr << std::endl << "FATAL ERROR, segment aborted";
615 | 					ss << std::endl << "FATAL ERROR, segment aborted";
616 | 					return;
617 | 				}
618 | 
619 | 				//print_hex((uint8_t*)pSeg, count, ss);
620 | 				std::string sCalc;
621 | 				bool success = false;
622 | 
623 | 				if ( enable_vcalc )
624 | 					success = print_vcalc((uint8_t*)pSeg, count, sCalc);
625 | 
626 | 				if ( success )
627 | 					ss << ", vCALC (" + sCalc + ")";
628 | 
629 | 				else {
630 | 					ss << ", o";
631 | 					print_hex((uint8_t*)pSeg, count, ss);
632 | 				}
633 | 
634 | 				pSeg += count;
635 | 				break;
636 | 			}
637 | 
638 | 			default:
639 | 				std::cerr << std::endl
640 | 					<< "ERROR : Unknown argument 0x" << std::hex << (int)tag
641 | 					<< " at offset 0x" << (pArg - segment + segHead.offset)
642 | 					<< std::dec << ", stopping argument parsing";
643 | 
644 | 				is_opcode = true;
645 | 				pSeg = (char*)pArg;
646 | 				break;
647 | 
648 | 				// ss << ", " << std::hex << "0x" << (int)tag << " : 0x" << arg.uVal << std::dec;
649 | 				// break;
650 | 			}
651 | 		}
652 | 
653 | 		lines[ lineOffset ] = ss.str();
654 | 		ss.clear();
655 | 		ss.str("");
656 | 	}
657 | 
658 | 	for ( auto &line : lines ) {
659 | 		std::cout << line.second;
660 | 	}
661 | 
662 | 	std::cout << std::endl << "0x" << std::hex << std::setfill('0') << std::setw(4)
663 | 		<< (int)(pSeg - segment) << ": "
664 | 		<< std::dec;
665 | 
666 | 	if ( labelMap.count( (unsigned int)(pSeg - segment) ) ) {
667 | 		std::cout << "label" << labelMap[ (unsigned int)(pSeg - segment) ] << ": ";
668 | 	}
669 | 
670 | 	labelMap.clear();
671 | 
672 | 	std::cout << std::endl;
673 | }
674 | 


--------------------------------------------------------------------------------
/script2bin.cpp:
--------------------------------------------------------------------------------
  1 | // Scene tool
  2 | 
  3 | #include "sceneTool.hh"
  4 | #include "sceneOpCodes.hh"
  5 | #include "sceneOpCodeNames.hh"
  6 | 
  7 | #include <string>
  8 | #include <iostream>
  9 | #include <algorithm>
 10 | #include <iomanip>
 11 | 
 12 | #include <sstream>
 13 | #include <fstream>
 14 | #include <cstring>
 15 | #include <list>
 16 | #include <map>
 17 | 
 18 | #include <boost/algorithm/string.hpp>
 19 | #include <boost/filesystem.hpp>
 20 | 
 21 | #include <boost/iostreams/stream.hpp>
 22 | #include <boost/iostreams/categories.hpp> 
 23 | #include <boost/iostreams/code_converter.hpp>
 24 | 
 25 | #include <boost/locale.hpp>
 26 | 
 27 | using namespace boost::locale;
 28 | using namespace boost::locale::conv;
 29 | 
 30 | 
 31 | void write16(std::fstream& output, uint16_t data) {
 32 | 	output.write((char*)&data, (int)sizeof(data));
 33 | }
 34 | 
 35 | void write32(std::fstream& output, uint32_t data) {
 36 | 	output.write((char*)&data, (int)sizeof(data));
 37 | }
 38 | 
 39 | void write64(std::fstream& output, uint64_t data) {
 40 | 	output.write((char*)&data, (int)sizeof(data));
 41 | }
 42 | 
 43 | uint16_t read16(std::ifstream& input) {
 44 | 	uint16_t data;
 45 | 	input.read((char*)&data, (int)sizeof(data));
 46 | 	return data;
 47 | }
 48 | 
 49 | uint32_t read32(std::ifstream& input) {
 50 | 	uint32_t data;
 51 | 	input.read((char*)&data, (int)sizeof(data));
 52 | 	return data;
 53 | }
 54 | 
 55 | uint64_t read64(std::ifstream& input) {
 56 | 	uint64_t data;
 57 | 	input.read((char*)&data, (int)sizeof(data));
 58 | 	return data;
 59 | }
 60 | 
 61 | // Checksum reverse by weaknespase
 62 | uint32_t checksum(const char* in, const uint32_t length, int last = 0){
 63 | 	const char* end = in + length;
 64 | 	int acc = last;
 65 | 	while (in < end)
 66 | 		acc = (acc * 33) ^ (unsigned char) *in++;
 67 | 	return acc;
 68 | }
 69 | 
 70 | bool oShiftJis = false;
 71 | bool iShiftJis = false;
 72 | bool keepStringSizes = false;
 73 | 
 74 | // Apply encoding fixes here
 75 | void convertText(std::string& text)
 76 | {
 77 | 	char last = 0;
 78 | 	char elem = 0;
 79 | 	bool quoteStarts = true;
 80 | 	std::string data;
 81 | 
 82 | 	// Convert from Shift-JIS to UTF-8 if needed
 83 | 	if ( iShiftJis ) {
 84 | 		data = to_utf<char>( text, "Shift-JIS" );
 85 | 		goto end;
 86 | 	}
 87 | 
 88 | 	// Cancel UTF-8 to Shift-JIS conversion if unneeded
 89 | 	if ( !oShiftJis ) {
 90 | 		return;
 91 | 	}
 92 | 
 93 | 	data = from_utf( text, "Shift-JIS" );
 94 | 
 95 | 	for ( uint32_t i = 0; i < data.size(); i++ ) {
 96 | 
 97 | 		last = elem;
 98 | 		elem = data[i];
 99 | 
100 | 		// Fix english \" for japanese game
101 | 		if ( last == '\\' && elem == '"' ) {
102 | 
103 | 			// data[i-1] = 0x81;
104 | 
105 | 			// if ( quoteStarts ) {
106 | 			// 	data[i] = 0x77;
107 | 			// }
108 | 			// else {
109 | 			// 	data[i] = 0x78;
110 | 			// }
111 | 			data = data.substr(0, i-1) + "\"" + data.substr(i+1);
112 | 			quoteStarts = !quoteStarts;
113 | 		}
114 | 
115 | 	}
116 | 
117 | 	end:
118 | 
119 | 	if ( !keepStringSizes ) {
120 | 		text = data;
121 | 		return;
122 | 	}
123 | 
124 | 	int oSize = data.size();
125 | 	int iSize = text.size();
126 | 	int diff = oSize - iSize;
127 | 
128 | 	if ( diff < 0 ) {
129 | 		diff = -diff;
130 | 
131 | 		bool soh = false;
132 | 
133 | 		if ( data.size() > 0 && data[data.size()-1] == '\x01' )
134 | 			data = data.substr(0, data.size()-1), soh = true;
135 | 
136 | 		for ( int i = 0; i < diff; i++ )
137 | 			data += " ";
138 | 
139 | 		if ( soh )
140 | 			data += "\x01";
141 | 	}
142 | 	else if ( diff > 0 ) {
143 | 
144 | 		bool soh = false;
145 | 
146 | 		if ( data.size() > 0 && data[data.size()-1] == '\x01' )
147 | 			data = data.substr(0, data.size()-1), soh = true;
148 | 
149 | 		data = data.substr(0, data.size()-diff);
150 | 
151 | 		if ( soh )
152 | 			data += "\x01";
153 | 	}
154 | 
155 | 	text = data.substr(0, iSize);
156 | 
157 | 	if ( text.size() != iSize ) {
158 | 		std::cerr << "ERROR : a text fitting error occurred" << std::endl;
159 | 		exit(1);
160 | 	}
161 | }
162 | 
163 | 
164 | 
165 | #define write_elem(fh, elem) fh.write((char*)&elem, (int)sizeof(elem))
166 | 
167 | 
168 | void write_segment( std::fstream& fh, SEGMENT_HEADER& segHead, std::list<std::string>::iterator& it, std::list<std::string>::iterator& end );
169 | 
170 | void print_hex(uint8_t *data, uint32_t size)
171 | {
172 | 	for (uint32_t i = 0; i < size; ++i) {
173 | 		std::cout << " " << std::hex << std::setfill('0') << std::setw(2)
174 | 			<< (int)data[i] << std::dec;
175 | 	}
176 | }
177 | 
178 | uint32_t countSegments(std::list<std::string>& lines);
179 | 
180 | std::map<std::string,uint16_t> opCodeMap;
181 | std::vector<std::pair<uint32_t, std::string>> jmpList;
182 | std::map<std::string, uint32_t> labelMap;
183 | 
184 | int main(int argc, char *argv[])
185 | {
186 | 	std::string iPath;
187 | 	std::string oPath;
188 | 
189 | 	for ( int i = 1; i < argc; i++ ) {
190 | 
191 | 		std::string arg = argv[i];
192 | 
193 | 		if ( arg == "--enc-shift-jis" ) {
194 | 			std::cout << "Reencoding strings as Shift-JIS" << std::endl;
195 | 			oShiftJis = true;
196 | 		}
197 | 
198 | 		else if ( arg == "--dec-shift-jis" ) {
199 | 			std::cout << "Decoding strings as Shift-JIS" << std::endl;
200 | 			iShiftJis = true;
201 | 		}
202 | 
203 | 		else if ( arg == "--preserve-string-sizes" ) {
204 | 			std::cout << "Preserving string sizes" << std::endl;
205 | 		// else if ( arg == "--change-string-sizes" ) {
206 | 		// 	std::cout << "Allowing string size modification" << std::endl;
207 | 		// 	keepStringSizes = false;
208 | 			keepStringSizes = true;
209 | 		}
210 | 
211 | 		else if ( iPath.size() < 1 ) {
212 | 			iPath = arg;
213 | 		}
214 | 
215 | 		else if ( oPath.size() < 1 ) {
216 | 			oPath = arg;
217 | 		}
218 | 	}
219 | 
220 | 	if ( iShiftJis && oShiftJis ) {
221 | 		iShiftJis = false;
222 | 		oShiftJis = false;
223 | 	}
224 | 
225 | 	if ( argc < 3 || iPath.size() < 1 || oPath.size() < 1 ) {
226 | 		std::cerr << "Usage : " << argv[0]
227 | 			<< " <script> <output> (--dec-shift-jis) (--enc-shift-jis) (--change-string-sizes)" << std::endl;
228 | 		return -1;
229 | 	}
230 | 
231 | 
232 | 	for ( uint32_t i = 0; i < OPCODE_COUNT; i++ ) {
233 | 		opCodeMap[ opCodeNames[i] ] = 0x8000 + i;
234 | 	}
235 | 
236 | 	std::ifstream iFile( iPath.c_str(), std::ios_base::binary );
237 | 
238 | 	if ( !iFile.is_open() ) {
239 | 		std::cerr << iPath << " not found" << std::endl;
240 | 		return -2;
241 | 	}
242 | 
243 | 	// Create output directory structure
244 | 	boost::system::error_code returnedError;
245 | 	boost::filesystem::path path( oPath );
246 | 	//std::cout << path.parent_path() << std::endl;
247 | 
248 | 	boost::filesystem::create_directories(
249 | 		path.parent_path(), returnedError
250 | 	);
251 | 
252 | 	std::fstream oFile( oPath.c_str(), std::ios_base::trunc | std::ios_base::in | std::ios_base::out | std::ios_base::binary );
253 | 
254 | 	if ( !oFile.is_open() ) {
255 | 		std::cerr << "Failed to open " << oPath << std::endl;
256 | 		return -2;
257 | 	}
258 | 
259 | 
260 | 	FILE_HEADER_V2 headerV2;
261 | 	memset(&headerV2, 0, sizeof(headerV2));
262 | 
263 | 	std::list<std::string> lines(0);
264 | 
265 | 	for( std::string line; getline( iFile, line ); )
266 | 	{
267 | 		lines.push_back(line);
268 | 	}
269 | 
270 | 	// TODO : count segments
271 | 
272 | 	iFile.close();
273 | 
274 | 	strcpy( headerV2.magic, "YS7_SCP" );
275 | 
276 | 	headerV2.version = 4;
277 | 	headerV2.checksum = 0x69DB279B411DC943; // Fake checksum
278 | 	headerV2.segs_count = countSegments(lines);
279 | 
280 | 	write_elem( oFile, headerV2 );
281 | 
282 | 	SEGMENT_HEADER segHeads[ headerV2.segs_count ];
283 | 	memset(&segHeads, 0, sizeof(segHeads));
284 | 
285 | 	write_elem( oFile, segHeads );
286 | 
287 | 	std::list<std::string>::iterator it = lines.begin();
288 | 	std::list<std::string>::iterator end = lines.end();
289 | 
290 | 	for ( int i = 0; i < headerV2.segs_count; i++ ) {
291 | 		write_segment( oFile, segHeads[i], it, end );
292 | 	}
293 | 
294 | 	oFile.seekp( 0 );
295 | 	write_elem( oFile, headerV2 );
296 | 
297 | 	oFile.seekp( sizeof(headerV2) );
298 | 	write_elem( oFile, segHeads );
299 | 
300 | 	oFile.close();
301 | 
302 | 	return 0;
303 | }
304 | 
305 | inline bool isJapOpCode( uint16_t code )
306 | {
307 | 	return (0x8000 <= code && code <= 0x8181);
308 | }
309 | 
310 | inline bool isOpCode( uint16_t code )
311 | {
312 | 	return (0x8000 <= code && code <= 0x8182);
313 | }
314 | 
315 | std::string nextLine(std::list<std::string>::iterator& it, std::list<std::string>::iterator end)
316 | {
317 | 	std::string line;
318 | 
319 | 	for (; it != end; ++it) {
320 | 
321 | 		line = *it;
322 | 		boost::trim(line);
323 | 
324 | 		if ( line.size() > 0 )
325 | 			return line;
326 | 	}
327 | }
328 | 
329 | #define SEGMENT_DELIMITER ".segment"
330 | #define CODE_DELIMITER ".code"
331 | 
332 | void goToCode(std::list<std::string>::iterator& it, std::list<std::string>::iterator end)
333 | {
334 | 	std::string line;
335 | 
336 | 	for (; it != end; ++it) {
337 | 
338 | 		line = *it;
339 | 		boost::trim(line);
340 | 
341 | 		if ( line == CODE_DELIMITER )
342 | 			return;
343 | 	}
344 | }
345 | 
346 | void nextEmptyLine(std::list<std::string>::iterator& it, std::list<std::string>::iterator end)
347 | {
348 | 	std::string line;
349 | 
350 | 	for (; it != end; ++it) {
351 | 
352 | 		line = *it;
353 | 		boost::trim(line);
354 | 
355 | 		if ( line.size() == 0 )
356 | 			return;
357 | 	}
358 | }
359 | 
360 | uint32_t countSegments(std::list<std::string>& lines)
361 | {
362 | 	std::string line;
363 | 	uint32_t count = 0;
364 | 	std::list<std::string>::iterator it, end = lines.end();
365 | 
366 | 	for ( it = lines.begin(); it != end; ) {
367 | 
368 | 		// Get next segment
369 | 		line = nextLine(it, end);
370 | 
371 | 		// Go to segment code
372 | 		nextEmptyLine(it, end);
373 | 
374 | 		if ( it != end )
375 | 			count++, it++;
376 | 
377 | 		// Go to first code line
378 | 		nextLine(it, end);
379 | 
380 | 		// Go to last code line
381 | 		nextEmptyLine(it, end);
382 | 	}
383 | 
384 | 	return count;
385 | }
386 | 
387 | bool isInteger(std::string line)
388 | {
389 | 	return line.substr(0, 2) == "0x";
390 | }
391 | 
392 | bool parseNextArg( std::string& arg, std::string& args )
393 | {
394 | 	uint32_t beg = args.size();
395 | 	uint32_t size = 0;
396 | 
397 | 	// Look for arg beginning
398 | 	for ( uint32_t i = 0; i < args.size(); i++ ) {
399 | 
400 | 		char elem = args[i];
401 | 
402 | 		if ( elem != ' ' && elem != ',' ) {
403 | 			beg = i;
404 | 			break;
405 | 		}
406 | 	}
407 | 
408 | 	if ( beg >= args.size() )
409 | 		return false;
410 | 
411 | 	bool inString = false;
412 | 	char beforeLast = 0;
413 | 	char last = 0;
414 | 	char elem = args[beg];
415 | 
416 | 	// Look for arg end, ignore string contents
417 | 	for ( uint32_t i = beg; i < args.size(); i++ ) {
418 | 
419 | 		elem = args[i];
420 | 
421 | 		if ( elem == '"' ) {
422 | 
423 | 			if ( !inString ) {
424 | 
425 | 				if ( last == ' ' || last == ',' || !last
426 | 					 || last == 's' || last == 'p' ) {
427 | 
428 | 					inString = true;
429 | 				}
430 | 			}
431 | 			else if ( last != '\\' ) {
432 | 
433 | 				for ( uint32_t j = i+1; j < args.size(); j++ ) {
434 | 
435 | 					char next = args[j];
436 | 
437 | 					if ( next == ',' ) {
438 | 						inString = false;
439 | 						break;
440 | 					}
441 | 
442 | 					else if ( next != ' ' ) {
443 | 						break;
444 | 					}
445 | 				}
446 | 
447 | 			}
448 | 		}
449 | 
450 | 		if ( !inString && elem == ',' ) {
451 | 			break;
452 | 		}
453 | 
454 | 		size++;
455 | 
456 | 		beforeLast = last;
457 | 		last = elem;
458 | 	}
459 | 
460 | 	// if ( inString ) {
461 | 	// 	return false;
462 | 	// }
463 | 
464 | 	bool ret = beg < args.size() && size > 0;
465 | 
466 | 	arg = args.substr( beg, size );
467 | 	args = args.substr( beg + size );
468 | 
469 | 	return ret;
470 | }
471 | 
472 | bool parsePopup( std::vector<uint32_t>& args, std::string& data )
473 | {
474 | 	uint32_t start = 0;
475 | 
476 | 	for ( uint32_t i = 0; i < data.size(); i++ ) {
477 | 		char elem = data[i];
478 | 
479 | 		if ( elem == '\x01' ) {
480 | 			args.push_back( start );
481 | 			start = i+1;
482 | 		}
483 | 	}
484 | 
485 | 	return true;
486 | }
487 | 
488 | bool parseHex( std::vector<uint8_t>& values, std::string data )
489 | {
490 | 	char buf[3];
491 | 	// int hex = 0;
492 | 	int iBuf = 0;
493 | 
494 | 	for (uint32_t i = 0; i < data.size(); ++i) {
495 | 
496 | 		char elem = data[i];
497 | 
498 | 		if ( elem != ' ' ) {
499 | 
500 | 			if ( (elem < '0' && elem > '9')
501 | 				|| (elem < 'a' && elem > 'f')
502 | 				|| (elem < 'A' && elem > 'F') ) {
503 | 				return false;
504 | 			}
505 | 
506 | 			buf[iBuf++] = elem;
507 | 
508 | 			if ( iBuf >= 2 ) {
509 | 				buf[3] = 0;
510 | 
511 | 				try {
512 | 					int value = std::stoul(buf, nullptr, 16);
513 | 					values.push_back( value );
514 | 				}
515 | 				catch (...) {
516 | 					std::cerr << "ERROR : failed to parse '" << data << "' as hex" << std::endl;
517 | 				}
518 | 				// std::cerr << "Added " << value << std::endl;
519 | 
520 | 				iBuf = 0;
521 | 			}
522 | 
523 | 			// hex *= 0x10;
524 | 			// hex |= std::stoul(s, nullptr, 16);
525 | 		}
526 | 		// std::cout << " " << elem << std::dec;
527 | 	}
528 | 
529 | 	return true;
530 | }
531 | 
532 | bool hasJump(uint32_t opcode)
533 | {
534 | 	bool hasJump = false;
535 | 
536 | 	switch (opcode) {
537 | 	case OPCODE_if:
538 | 	case OPCODE_elseIf:
539 | 	case OPCODE_else:
540 | 	case OPCODE_break:
541 | 	case OPCODE_while:
542 | 	case OPCODE_case:
543 | 	case OPCODE_default:
544 | 	case OPCODE_Execute:
545 | 	case OPCODE_8085:
546 | 		hasJump = true;
547 | 		break;
548 | 
549 | 	default:
550 | 		NULL;
551 | 	};
552 | 
553 | 	return hasJump;
554 | }
555 | 
556 | uint32_t lastJump = 0;
557 | std::string labelName;
558 | 
559 | void write_arg( std::fstream& fh, std::string arg, uint16_t opcode )
560 | {
561 | 	boost::trim(arg);
562 | 
563 | 	if ( arg.size() < 1 )
564 | 		return;
565 | 
566 | 	char first = arg[0];
567 | 	std::string content = arg;
568 | 		// std::cout << "Detected arg " << content << std::endl;
569 | 
570 | 	switch ( first ) {
571 | 
572 | 	case 's': {
573 | 		// std::cout << "Detected s'string' arg " << content << std::endl;
574 | 		uint32_t beg = 1;
575 | 
576 | 		for ( uint32_t i = beg; i < content.size(); i++ ) {
577 | 			
578 | 			char elem = content[i];
579 | 
580 | 			if ( elem == '"' ) {
581 | 				beg = i;
582 | 				break;
583 | 			}
584 | 		}
585 | 
586 | 		content = content.substr( beg );
587 | 	}
588 | 
589 | 	case '"': {
590 | 		// std::cout << "Detected 'string' arg " << content << std::endl;
591 | 		uint32_t end = 1;
592 | 		uint32_t i = content.size()-1;
593 | 
594 | 		while ( i > 0 ) {
595 | 			
596 | 			char elem = content[i];
597 | 
598 | 			if ( elem == '"' ) {
599 | 				end = i;
600 | 				break;
601 | 			}
602 | 
603 | 			i--;
604 | 		}
605 | 
606 | 		content = content.substr( 1, end-1 );
607 | 
608 | 		// if (   opcode == OPCODE_MenuAdd
609 | 		// 	|| opcode == OPCODE_YesNoMenu
610 | 		// 	|| opcode == OPCODE_GetItemMessageExPlus
611 | 		// 	|| opcode == OPCODE_Message
612 | 		// 	// TalkMes
613 | 		// 	 ) {
614 | 
615 | 			convertText(content);
616 | 		// }
617 | 
618 | 		// std::cout << "Writing string " << content << std::endl;
619 | 
620 | 		write16( fh, STRING_TAG );
621 | 		write32( fh, content.size() );
622 | 		fh.write( content.c_str(), content.size() );
623 | 		break;
624 | 	}
625 | 
626 | 	case '#': {
627 | 		int32_t value = std::stoi( content.substr( 1 ) );
628 | 
629 | 		write16( fh, INT_TAG );
630 | 		write32( fh, value );
631 | 
632 | 		if ( hasJump( opcode ) ) {
633 | 
634 | 			int labelPos = content.find("/");
635 | 
636 | 			if ( labelPos != std::string::npos ) {
637 | 				labelName = content.substr(labelPos+1);
638 | 				boost::trim(labelName);
639 | 				lastJump = value;
640 | 			}
641 | 		}
642 | 
643 | 		break;
644 | 	}
645 | 
646 | 	case '.': {
647 | 		// float value = std::stof( content.substr( 1 ) );
648 | 		uint32_t value = std::stoul( content.substr(1), nullptr, 16 );
649 | 
650 | 		write16( fh, FLOAT_TAG );
651 | 		write32( fh, *(uint32_t*)&value ); // float writing trick
652 | 		break;
653 | 	}
654 | 
655 | 	case 'o': {
656 | 		std::vector<uint8_t> values(0);
657 | 		parseHex( values, content.substr(1) );
658 | 
659 | 		write16( fh, VCALC_TAG );
660 | 		write32( fh, values.size() );
661 | 		fh.write( (char*)values.data(), values.size() );
662 | 		break;
663 | 	}
664 | 
665 | 	case 'p': {
666 | 		std::string text;
667 | 		std::vector<uint32_t> args(0);
668 | 
669 | 		content = content.substr(1);
670 | 
671 | 		size_t strPos = content.find("\"");
672 | 
673 | 		if ( strPos == std::string::npos ) {
674 | 			std::cerr << "ERROR : invalid popup argument (no string found)" << std::endl;
675 | 			exit(1);
676 | 		}
677 | 
678 | 		content = content.substr( strPos+1 );
679 | 
680 | 		size_t strEnd = content.rfind('\"');
681 | 
682 | 		if ( strEnd == std::string::npos ) {
683 | 			std::cerr << "ERROR : failed to parse popup '" << content << "' of size : " << content.size() << std::endl;
684 | 			exit(2);
685 | 		}
686 | 
687 | 		text = content.substr( 0, strEnd );
688 | 
689 | 		convertText(text);
690 | 
691 | 		// parsePopup( args, text, content.substr(5) );
692 | 		parsePopup( args, text );
693 | 
694 | 		write16( fh, POPUP_TAG );
695 | 		write32( fh, args.size() );
696 | 		write32( fh, text.size() );
697 | 
698 | 		// for ( uint32_t i = 0; i < args.size(); i++ ) {
699 | 		// 	write32( fh, args[i] );
700 | 		// }
701 | 
702 | 		fh.write( (char*)args.data(), args.size() * sizeof(uint32_t) );
703 | 		fh.write( text.c_str(), text.size() );
704 | 		break;
705 | 	}
706 | 
707 | 	default:
708 | 		std::cerr << "ERROR : unrecognized parameter '" << content << "'" << std::endl;
709 | 	}
710 | }
711 | 
712 | void write_segment(
713 | 		std::fstream& fh, SEGMENT_HEADER& segHead,
714 | 		std::list<std::string>::iterator& it,
715 | 		std::list<std::string>::iterator& end
716 | 	)
717 | {
718 | 	segHead.offset = fh.tellp();
719 | 
720 | 	std::string line = nextLine(it, end);
721 | 
722 | 	if ( isInteger(line) ) {
723 | 		std::cout << "Offset : " << line << std::endl;
724 | 		line = nextLine(++it, end);
725 | 	}
726 | 
727 | 	strncpy( segHead.name, line.c_str(), line.size() );
728 | 	std::cout << "Segment name : " << line << std::endl;
729 | 
730 | 	nextEmptyLine(it, end);
731 | 
732 | 	bool done = false;
733 | 	uint16_t opcode = 0;
734 | 
735 | 	while ( ++it != end ) {
736 | 
737 | 		line = *it;
738 | 
739 | 		std::string codeLine = line;
740 | 		std::size_t first;
741 | 		std::size_t found;
742 | 
743 | 		boost::trim(line);
744 | 
745 | 		if ( line.size() > 1 && line[0] == '#' ) {
746 | 			continue;
747 | 		}
748 | 
749 | 		do {
750 | 			first = codeLine.find(",");
751 | 			found = codeLine.find(":");
752 | 
753 | 			if ( found != std::string::npos && found < first ) {
754 | 				std::string label = codeLine.substr(0, found);
755 | 				boost::trim(label);
756 | 
757 | 				if ( label.substr(0, 2) != "0x" ) {
758 | 					labelMap[ label ] = fh.tellp();
759 | 				}
760 | 
761 | 				codeLine = codeLine.substr(found + 1);
762 | 			}
763 | 			else {
764 | 				break;
765 | 			}
766 | 
767 | 		} while ( true );
768 | 
769 | 		boost::trim(codeLine);
770 | 
771 | 		if ( codeLine.size() < 1 ) {
772 | 			++it;
773 | 			break;
774 | 		}
775 | 
776 | 		std::vector<std::string> elems;
777 | 		boost::split(elems, codeLine, boost::is_any_of(","));
778 | 
779 | 		std::string& opCodeName = elems[0];
780 | 		opcode = opCodeMap[ opCodeName ];
781 | 		// std::cout << "OPCODE : " << opCodeName << std::endl;
782 | 
783 | 		write16( fh, opcode );
784 | 
785 | 		std::string arg;
786 | 		std::string args = codeLine.substr( opCodeName.size() );
787 | 
788 | 		while ( parseNextArg( arg, args ) ) {
789 | 
790 | 			// std::cout << "Next arg : " << arg << std::endl;
791 | 			write_arg( fh, arg, opcode );
792 | 		}
793 | 
794 | 		if ( hasJump(opcode) ) {
795 | 			jmpList.push_back( std::make_pair( (int)fh.tellp(), labelName ) );
796 | 		}
797 | 	}
798 | 
799 | 	segHead.size = (int)fh.tellp() - (int)segHead.offset;
800 | 	const uint32_t pos = fh.tellp();
801 | 
802 | 	for ( auto &jmp : jmpList ) {
803 | 
804 | 		fh.seekp( jmp.first - 4 );
805 | 		write32( fh, labelMap[ jmp.second ] - jmp.first );
806 | 		// std::cerr << "setting jmp @offset 0x" << std::hex << (jmp.first-4 - segHead.offset)
807 | 		// 	<< " to @0x" << (int)(labelMap[ jmp.second ] - segHead.offset) << std::dec
808 | 		// 	<< std::endl;
809 | 			// << " ie #" << (int)(labelMap[ jmp.second ] - segHead.offset) << std::endl;
810 | 	}
811 | 
812 | 	fh.seekp(pos);
813 | 
814 | 	jmpList.clear();
815 | 	labelMap.clear();
816 | }
817 | 
818 | 


--------------------------------------------------------------------------------
/tbbconv/node_modules/jconv/jconv.js:
--------------------------------------------------------------------------------
   1 | /*! ------------------------------------------------------
   2 | 
   3 | 	Jconv
   4 | 
   5 | 	Copyright (c) 2013 narirou
   6 | 	MIT Licensed
   7 | 
   8 | ------------------------------------------------------- */
   9 | 
  10 | ( function() {
  11 | 
  12 | 	'use strict';
  13 | 
  14 | 	var unknown = '・'.charCodeAt( 0 );
  15 | 
  16 | 	var tables = {
  17 | 		'SJIS':           require( './tables/SJIS' ),
  18 | 		'JIS':            require( './tables/JIS' ),
  19 | 		'JISEXT':         require( './tables/JISEXT' ),
  20 | 		'SJISInverted':   require( './tables/SJISInverted' ),
  21 | 		'JISInverted':    require( './tables/JISInverted' ),
  22 | 		'JISEXTInverted': require( './tables/JISEXTInverted' )
  23 | 	};
  24 | 
  25 | 	var encodings = {};
  26 | 
  27 | 	var jconv = module.exports = function( buf, from, to ) {
  28 | 		return jconv.convert( buf, from, to );
  29 | 	};
  30 | 
  31 | 	jconv.defineEncoding = function( obj ) {
  32 | 		var Encoding = function( obj ) {
  33 | 			this.name = obj.name;
  34 | 			this.convert = obj.convert;
  35 | 		};
  36 | 		encodings[ obj.name ] = new Encoding( obj );
  37 | 	};
  38 | 
  39 | 	jconv.convert = function( buf, from, to ) {
  40 | 		from = getName( from );
  41 | 		to   = getName( to );
  42 | 
  43 | 		if( ! from || ! to ) {
  44 | 			throw new Error( 'Encoding not recognized.' );
  45 | 		}
  46 | 
  47 | 		buf = ensureBuffer( buf );
  48 | 
  49 | 		if( from === to ) {
  50 | 			return buf;
  51 | 		}
  52 | 
  53 | 		// Directly convert if possible.
  54 | 		var encoder = encodings[ from + 'to' + to ];
  55 | 		if( encoder ) {
  56 | 			return encoder.convert( buf );
  57 | 		}
  58 | 
  59 | 		var uniDecoder = encodings[ from + 'toUCS2' ],
  60 | 			uniEncoder = encodings[ 'UCS2to' + to ];
  61 | 		if( uniDecoder && uniEncoder ) {
  62 | 			return uniEncoder.convert( uniDecoder.convert( buf ) );
  63 | 		}
  64 | 		else {
  65 | 			throw new Error( 'Encoding not recognized.' );
  66 | 		}
  67 | 	};
  68 | 
  69 | 	jconv.decode = function( buf, from ) {
  70 | 		switch( from.toUpperCase() ) {
  71 | 			// Internal Encoding
  72 | 			case 'BINARY':
  73 | 			case 'BASE64':
  74 | 			case 'ASCII':
  75 | 			case 'HEX':
  76 | 			case 'UTF8':
  77 | 			case 'UTF-8':
  78 | 			case 'UNICODE':
  79 | 			case 'UCS2':
  80 | 			case 'UCS-2':
  81 | 			case 'UTF16LE':
  82 | 			case 'UTF-16LE':
  83 | 				return buf.toString( from );
  84 | 			default:
  85 | 				return jconv.convert( buf, from, 'UCS2' ).toString( 'UCS2' );
  86 | 		}
  87 | 	};
  88 | 
  89 | 	jconv.encode = function( str, to ) {
  90 | 		switch( to.toUpperCase() ) {
  91 | 			// Internal Encoding
  92 | 			case 'BASE64':
  93 | 			case 'ASCII':
  94 | 			case 'HEX':
  95 | 			case 'UTF8':
  96 | 			case 'UTF-8':
  97 | 				return new Buffer( str, to );
  98 | 			default:
  99 | 				return jconv.convert( str, 'UTF8', to );
 100 | 		}
 101 | 	};
 102 | 
 103 | 	jconv.encodingExists = function( encoding ) {
 104 | 		return getName( encoding ) ? true : false;
 105 | 	};
 106 | 
 107 | 	function getName( name ) {
 108 | 		switch( name.toUpperCase() ) {
 109 | 			case 'WINDOWS-31J':
 110 | 			case 'CP932':
 111 | 			case 'SJIS':
 112 | 			case 'SHIFTJIS':
 113 | 			case 'SHIFT_JIS':
 114 | 				return 'SJIS';
 115 | 			case 'EUCJP':
 116 | 			case 'EUC-JP':
 117 | 				return 'EUCJP';
 118 | 			case 'JIS':
 119 | 			case 'ISO2022JP':
 120 | 			case 'ISO-2022-JP':
 121 | 			case 'ISO-2022-JP-1':
 122 | 				return 'JIS';
 123 | 			case 'UTF8':
 124 | 			case 'UTF-8':
 125 | 				return 'UTF8';
 126 | 			case 'UNICODE':
 127 | 			case 'UCS2':
 128 | 			case 'UCS-2':
 129 | 			case 'UTF16LE':
 130 | 			case 'UTF-16LE':
 131 | 				return 'UCS2';
 132 | 			default:
 133 | 				return '';
 134 | 		}
 135 | 	}
 136 | 
 137 | 	function ensureBuffer( buf ) {
 138 | 		buf = buf || new Buffer( 0 );
 139 | 		return ( buf instanceof Buffer ) ? buf : new Buffer( buf.toString(), 'UTF8' );
 140 | 	}
 141 | 
 142 | 	// Unicode CharCode -> UTF8 Buffer
 143 | 	function setUtf8Buffer( unicode, utf8Buffer, offset ) {
 144 | 		if( unicode < 0x80 ) {
 145 | 			utf8Buffer[ offset++ ] = unicode;
 146 | 		}
 147 | 		else if( unicode < 0x800 ) {
 148 | 			utf8Buffer[ offset++ ] = 0xC0 | unicode >>>  6       ;
 149 | 			utf8Buffer[ offset++ ] = 0x80 | unicode        & 0x3F;
 150 | 		}
 151 | 		else if( unicode < 0x10000 ) {
 152 | 			utf8Buffer[ offset++ ] = 0xE0 | unicode >>> 12       ;
 153 | 			utf8Buffer[ offset++ ] = 0x80 | unicode >>>  6 & 0x3F;
 154 | 			utf8Buffer[ offset++ ] = 0x80 | unicode        & 0x3F;
 155 | 		}
 156 | 		else if( unicode < 0x200000 ) {
 157 | 			utf8Buffer[ offset++ ] = 0xF0 | unicode >>> 18       ;
 158 | 			utf8Buffer[ offset++ ] = 0x80 | unicode >>> 12 & 0x3F;
 159 | 			utf8Buffer[ offset++ ] = 0x80 | unicode >>>  6 & 0x3F;
 160 | 			utf8Buffer[ offset++ ] = 0x80 | unicode        & 0x3F;
 161 | 		}
 162 | 		else if( unicode < 0x4000000 ) {
 163 | 			utf8Buffer[ offset++ ] = 0xF8 | unicode >>> 24       ;
 164 | 			utf8Buffer[ offset++ ] = 0x80 | unicode >>> 18 & 0x3F;
 165 | 			utf8Buffer[ offset++ ] = 0x80 | unicode >>> 12 & 0x3F;
 166 | 			utf8Buffer[ offset++ ] = 0x80 | unicode >>>  6 & 0x3F;
 167 | 			utf8Buffer[ offset++ ] = 0x80 | unicode        & 0x3F;
 168 | 		}
 169 | 		else {
 170 | 			// ( >>>32 ) is not possible in ECMAScript. So use ( /0x40000000 ).
 171 | 			utf8Buffer[ offset++ ] = 0xFC | unicode  / 0x40000000;
 172 | 			utf8Buffer[ offset++ ] = 0x80 | unicode >>> 24 & 0x3F;
 173 | 			utf8Buffer[ offset++ ] = 0x80 | unicode >>> 18 & 0x3F;
 174 | 			utf8Buffer[ offset++ ] = 0x80 | unicode >>> 12 & 0x3F;
 175 | 			utf8Buffer[ offset++ ] = 0x80 | unicode >>>  6 & 0x3F;
 176 | 			utf8Buffer[ offset++ ] = 0x80 | unicode        & 0x3F;
 177 | 		}
 178 | 		return offset;
 179 | 	}
 180 | 
 181 | 	function setUnicodeBuffer( unicode, unicodeBuffer, offset ) {
 182 | 		unicodeBuffer[ offset++ ] = unicode & 0xFF;
 183 | 		unicodeBuffer[ offset++ ] = unicode >> 8;
 184 | 		return offset;
 185 | 	}
 186 | 
 187 | 	// UCS2 = UTF16LE(no-BOM)
 188 | 	// UCS2 -> UTF8
 189 | 	jconv.defineEncoding({
 190 | 		name: 'UCS2toUTF8',
 191 | 
 192 | 		convert: function( buf ) {
 193 | 			var setUtf8Buf = setUtf8Buffer;
 194 | 
 195 | 			var len        = buf.length,
 196 | 				utf8Buf = new Buffer( len * 3 ),
 197 | 				offset     = 0,
 198 | 				unicode;
 199 | 
 200 | 			for( var i = 0; i < len; ) {
 201 | 				var buf1 = buf[ i++ ],
 202 | 					buf2 = buf[ i++ ];
 203 | 
 204 | 				unicode = ( buf2 << 8 ) + buf1;
 205 | 
 206 | 				offset = setUtf8Buf( unicode, utf8Buf, offset );
 207 | 			}
 208 | 			return utf8Buf.slice( 0, offset );
 209 | 		}
 210 | 	});
 211 | 
 212 | 	// UCS2 -> SJIS
 213 | 	jconv.defineEncoding({
 214 | 		name: 'UCS2toSJIS',
 215 | 
 216 | 		convert: function( buf ) {
 217 | 			var tableSjisInv = tables[ 'SJISInverted' ],
 218 | 				unknownSjis  = tableSjisInv[ unknown ];
 219 | 
 220 | 			var len     = buf.length,
 221 | 				sjisBuf = new Buffer( len ),
 222 | 				offset  = 0,
 223 | 				unicode;
 224 | 
 225 | 			for( var i = 0; i <len; ) {
 226 | 				var buf1 = buf[ i++ ],
 227 | 					buf2 = buf[ i++ ];
 228 | 
 229 | 				unicode = ( buf2 << 8 ) + buf1;
 230 | 
 231 | 				// ASCII
 232 | 				if( unicode < 0x80 ) {
 233 | 					sjisBuf[ offset++ ] = unicode;
 234 | 				}
 235 | 				// HALFWIDTH_KATAKANA
 236 | 				else if( 0xFF61 <= unicode && unicode <= 0xFF9F ) {
 237 | 					sjisBuf[ offset++ ] = unicode - 0xFEC0;
 238 | 				}
 239 | 				// KANJI
 240 | 				else {
 241 | 					var code = tableSjisInv[ unicode ] || unknownSjis;
 242 | 					sjisBuf[ offset++ ] = code >> 8;
 243 | 					sjisBuf[ offset++ ] = code & 0xFF;
 244 | 				}
 245 | 			}
 246 | 			return sjisBuf.slice( 0, offset );
 247 | 		}
 248 | 	});
 249 | 
 250 | 	// UCS2 -> JIS
 251 | 	jconv.defineEncoding({
 252 | 		name: 'UCS2toJIS',
 253 | 
 254 | 		convert: function( buf ) {
 255 | 			var tableJisInv    = tables[ 'JISInverted' ],
 256 | 				tableJisExtInv = tables[ 'JISEXTInverted' ],
 257 | 				unknownJis     = tableJisInv[ unknown ];
 258 | 
 259 | 			var len      = buf.length,
 260 | 				jisBuf   = new Buffer( len * 3 + 4 ),
 261 | 				offset   = 0,
 262 | 				unicode,
 263 | 				sequence = 0;
 264 | 
 265 | 			for( var i = 0; i < len; ) {
 266 | 				var buf1 = buf[ i++ ],
 267 | 					buf2 = buf[ i++ ];
 268 | 
 269 | 				unicode = ( buf2 << 8 ) + buf1;
 270 | 
 271 | 				// ASCII
 272 | 				if( unicode < 0x80 ) {
 273 | 					if( sequence !== 0 ) {
 274 | 						sequence = 0;
 275 | 						jisBuf[ offset++ ] = 0x1B;
 276 | 						jisBuf[ offset++ ] = 0x28;
 277 | 						jisBuf[ offset++ ] = 0x42;
 278 | 					}
 279 | 					jisBuf[ offset++ ] = unicode;
 280 | 				}
 281 | 				// HALFWIDTH_KATAKANA
 282 | 				else if( 0xFF61 <= unicode && unicode <= 0xFF9F ) {
 283 | 					if( sequence !== 1 ) {
 284 | 						sequence = 1;
 285 | 						jisBuf[ offset++ ] = 0x1B;
 286 | 						jisBuf[ offset++ ] = 0x28;
 287 | 						jisBuf[ offset++ ] = 0x49;
 288 | 					}
 289 | 					jisBuf[ offset++ ] = unicode - 0xFF40;
 290 | 				}
 291 | 				else {
 292 | 					var code = tableJisInv[ unicode ];
 293 | 					if( code ) {
 294 | 						// KANJI
 295 | 						if( sequence !== 2 ) {
 296 | 							sequence = 2;
 297 | 							jisBuf[ offset++ ] = 0x1B;
 298 | 							jisBuf[ offset++ ] = 0x24;
 299 | 							jisBuf[ offset++ ] = 0x42;
 300 | 						}
 301 | 						jisBuf[ offset++ ] = code >> 8;
 302 | 						jisBuf[ offset++ ] = code & 0xFF;
 303 | 					}
 304 | 					else {
 305 | 						var ext = tableJisExtInv[ unicode ];
 306 | 						if( ext ) {
 307 | 							// EXTENSION
 308 | 							if( sequence !== 3 ) {
 309 | 								sequence = 3;
 310 | 								jisBuf[ offset++ ] = 0x1B;
 311 | 								jisBuf[ offset++ ] = 0x24;
 312 | 								jisBuf[ offset++ ] = 0x28;
 313 | 								jisBuf[ offset++ ] = 0x44;
 314 | 							}
 315 | 							jisBuf[ offset++ ] = ext >> 8;
 316 | 							jisBuf[ offset++ ] = ext & 0xFF;
 317 | 						}
 318 | 						else {
 319 | 							// UNKNOWN
 320 | 							if( sequence !== 2 ) {
 321 | 								sequence = 2;
 322 | 								jisBuf[ offset++ ] = 0x1B;
 323 | 								jisBuf[ offset++ ] = 0x24;
 324 | 								jisBuf[ offset++ ] = 0x42;
 325 | 							}
 326 | 							jisBuf[ offset++ ] = unknownJis >> 8;
 327 | 							jisBuf[ offset++ ] = unknownJis & 0xFF;
 328 | 						}
 329 | 					}
 330 | 				}
 331 | 			}
 332 | 
 333 | 			// Add ASCII ESC
 334 | 			if( sequence !== 0 ) {
 335 | 				sequence = 0;
 336 | 				jisBuf[ offset++ ] = 0x1B;
 337 | 				jisBuf[ offset++ ] = 0x28;
 338 | 				jisBuf[ offset++ ] = 0x42;
 339 | 			}
 340 | 			return	jisBuf.slice( 0, offset );
 341 | 		}
 342 | 	});
 343 | 
 344 | 	// UCS2 -> EUCJP
 345 | 	jconv.defineEncoding({
 346 | 		name: 'UCS2toEUCJP',
 347 | 
 348 | 		convert: function( buf ) {
 349 | 			var tableJisInv    = tables[ 'JISInverted' ],
 350 | 				tableJisExtInv = tables[ 'JISEXTInverted' ],
 351 | 				unknownJis     = tableJisInv[ unknown ];
 352 | 
 353 | 			var len     = buf.length,
 354 | 				eucBuf  = new Buffer( len * 2 ),
 355 | 				offset  = 0,
 356 | 				unicode;
 357 | 
 358 | 			for( var i = 0; i < len; ) {
 359 | 				var buf1 = buf[ i++ ],
 360 | 					buf2 = buf[ i++ ];
 361 | 
 362 | 				unicode = ( buf2 << 8 ) + buf1;
 363 | 
 364 | 				// ASCII
 365 | 				if( unicode < 0x80 ) {
 366 | 					eucBuf[ offset++ ] = unicode;
 367 | 				}
 368 | 				// HALFWIDTH_KATAKANA
 369 | 				else if( 0xFF61 <= unicode && unicode <= 0xFF9F ) {
 370 | 					eucBuf[ offset++ ] = 0x8E;
 371 | 					eucBuf[ offset++ ] = unicode - 0xFFC0;
 372 | 				}
 373 | 				else {
 374 | 					// KANJI
 375 | 					var jis = tableJisInv[ unicode ];
 376 | 					if( jis ) {
 377 | 						eucBuf[ offset++ ] = ( jis >> 8 ) - 0x80;
 378 | 						eucBuf[ offset++ ] = ( jis & 0xFF ) - 0x80;
 379 | 					}
 380 | 					else {
 381 | 						// EXTENSION
 382 | 						var ext = tableJisExtInv[ unicode ];
 383 | 						if( ext ) {
 384 | 							eucBuf[ offset++ ] = 0x8F;
 385 | 							eucBuf[ offset++ ] = ( ext >> 8 ) - 0x80;
 386 | 							eucBuf[ offset++ ] = ( ext & 0xFF ) - 0x80;
 387 | 						}
 388 | 						// UNKNOWN
 389 | 						else {
 390 | 							eucBuf[ offset++ ] = ( unknownJis >> 8 ) - 0x80;
 391 | 							eucBuf[ offset++ ] = ( unknownJis & 0xFF ) - 0x80;
 392 | 						}
 393 | 					}
 394 | 				}
 395 | 			}
 396 | 			return eucBuf.slice( 0, offset );
 397 | 		}
 398 | 	});
 399 | 
 400 | 	// UTF8 -> UCS2
 401 | 	jconv.defineEncoding({
 402 | 		name: 'UTF8toUCS2',
 403 | 
 404 | 		convert: function( buf ) {
 405 | 			var setUnicodeBuf = setUnicodeBuffer;
 406 | 
 407 | 			var len        = buf.length,
 408 | 				unicodeBuf = new Buffer( len * 2 ),
 409 | 				offset     = 0,
 410 | 				unicode;
 411 | 
 412 | 			for( var i = 0; i < len; ) {
 413 | 				var buf1 = buf[ i++ ];
 414 | 
 415 | 				switch( buf1 >> 4 ) {
 416 | 					case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
 417 | 						unicode = buf1;
 418 | 					break;
 419 | 					case 12: case 13:
 420 | 						unicode = (buf1 & 0x1F) <<  6 | buf[ i++ ] & 0x3F;
 421 | 					break;
 422 | 					case 14:
 423 | 						unicode = (buf1 & 0x0F) << 12 | (buf[ i++ ] & 0x3F) <<  6 | buf[ i++ ] & 0x3F;
 424 | 					break;
 425 | 					default:
 426 | 						unicode = (buf1 & 0x07) << 18 | (buf[ i++ ] & 0x3F) << 12 | (buf[ i++ ] & 0x3F) << 6 | buf[ i++ ] & 0x3F;
 427 | 					break;
 428 | 				}
 429 | 				offset = setUnicodeBuf( unicode, unicodeBuf, offset );
 430 | 			}
 431 | 			return unicodeBuf.slice( 0, offset );
 432 | 		}
 433 | 	});
 434 | 
 435 | 	// UTF8 -> SJIS
 436 | 	jconv.defineEncoding({
 437 | 		name: 'UTF8toSJIS',
 438 | 
 439 | 		convert: function( buf ) {
 440 | 			var tableSjisInv = tables[ 'SJISInverted' ],
 441 | 				unknownSjis  = tableSjisInv[ unknown ];
 442 | 
 443 | 			var len     = buf.length,
 444 | 				sjisBuf = new Buffer( len * 2 ),
 445 | 				offset  = 0,
 446 | 				unicode;
 447 | 
 448 | 			for( var i = 0; i <len; ) {
 449 | 				var buf1 = buf[ i++ ];
 450 | 
 451 | 				switch( buf1 >> 4 ) {
 452 | 					case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
 453 | 						unicode = buf1;
 454 | 					break;
 455 | 					case 12: case 13:
 456 | 						unicode = (buf1 & 0x1F) <<  6 | buf[ i++ ] & 0x3F;
 457 | 					break;
 458 | 					case 14:
 459 | 						unicode = (buf1 & 0x0F) << 12 | (buf[ i++ ] & 0x3F) <<  6 | buf[ i++ ] & 0x3F;
 460 | 					break;
 461 | 					default:
 462 | 						unicode = (buf1 & 0x07) << 18 | (buf[ i++ ] & 0x3F) << 12 | (buf[ i++ ] & 0x3F) << 6 | buf[ i++ ] & 0x3F;
 463 | 					break;
 464 | 				}
 465 | 
 466 | 				// ASCII
 467 | 				if( unicode < 0x80 ) {
 468 | 					sjisBuf[ offset++ ] = unicode;
 469 | 				}
 470 | 				// HALFWIDTH_KATAKANA
 471 | 				else if( 0xFF61 <= unicode && unicode <= 0xFF9F ) {
 472 | 					sjisBuf[ offset++ ] = unicode - 0xFEC0;
 473 | 				}
 474 | 				// KANJI
 475 | 				else {
 476 | 					var code = tableSjisInv[ unicode ] || unknownSjis;
 477 | 					sjisBuf[ offset++ ] = code >> 8;
 478 | 					sjisBuf[ offset++ ] = code & 0xFF;
 479 | 				}
 480 | 			}
 481 | 			return sjisBuf.slice( 0, offset );
 482 | 		}
 483 | 	});
 484 | 
 485 | 	// UTF8 -> JIS
 486 | 	jconv.defineEncoding({
 487 | 		name: 'UTF8toJIS',
 488 | 
 489 | 		convert: function( buf ) {
 490 | 			var tableJisInv    = tables[ 'JISInverted' ],
 491 | 				tableJisExtInv = tables[ 'JISEXTInverted' ],
 492 | 				unknownJis     = tableJisInv[ unknown ];
 493 | 
 494 | 			var len      = buf.length,
 495 | 				jisBuf   = new Buffer( len * 3 + 4 ),
 496 | 				offset   = 0,
 497 | 				unicode,
 498 | 				sequence = 0;
 499 | 
 500 | 			for( var i = 0; i < len; ) {
 501 | 				var buf1 = buf[ i++ ];
 502 | 
 503 | 				switch( buf1 >> 4 ) {
 504 | 					case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
 505 | 						unicode = buf1;
 506 | 					break;
 507 | 					case 12: case 13:
 508 | 						unicode = (buf1 & 0x1F) <<  6 | buf[ i++ ] & 0x3F;
 509 | 					break;
 510 | 					case 14:
 511 | 						unicode = (buf1 & 0x0F) << 12 | (buf[ i++ ] & 0x3F) <<  6 | buf[ i++ ] & 0x3F;
 512 | 					break;
 513 | 					default:
 514 | 						unicode = (buf1 & 0x07) << 18 | (buf[ i++ ] & 0x3F) << 12 | (buf[ i++ ] & 0x3F) << 6 | buf[ i++ ] & 0x3F;
 515 | 					break;
 516 | 				}
 517 | 
 518 | 				// ASCII
 519 | 				if( unicode < 0x80 ) {
 520 | 					if( sequence !== 0 ) {
 521 | 						sequence = 0;
 522 | 						jisBuf[ offset++ ] = 0x1B;
 523 | 						jisBuf[ offset++ ] = 0x28;
 524 | 						jisBuf[ offset++ ] = 0x42;
 525 | 					}
 526 | 					jisBuf[ offset++ ] = unicode;
 527 | 				}
 528 | 				// HALFWIDTH_KATAKANA
 529 | 				else if( 0xFF61 <= unicode && unicode <= 0xFF9F ) {
 530 | 					if( sequence !== 1 ) {
 531 | 						sequence = 1;
 532 | 						jisBuf[ offset++ ] = 0x1B;
 533 | 						jisBuf[ offset++ ] = 0x28;
 534 | 						jisBuf[ offset++ ] = 0x49;
 535 | 					}
 536 | 					jisBuf[ offset++ ] = unicode - 0xFF40;
 537 | 				}
 538 | 				else {
 539 | 					var code = tableJisInv[ unicode ];
 540 | 					if( code ) {
 541 | 						// KANJI
 542 | 						if( sequence !== 2 ) {
 543 | 							sequence = 2;
 544 | 							jisBuf[ offset++ ] = 0x1B;
 545 | 							jisBuf[ offset++ ] = 0x24;
 546 | 							jisBuf[ offset++ ] = 0x42;
 547 | 						}
 548 | 						jisBuf[ offset++ ] = code >> 8;
 549 | 						jisBuf[ offset++ ] = code & 0xFF;
 550 | 					}
 551 | 					else {
 552 | 						var ext = tableJisExtInv[ unicode ];
 553 | 						if( ext ) {
 554 | 							// EXTENSION
 555 | 							if( sequence !== 3 ) {
 556 | 								sequence = 3;
 557 | 								jisBuf[ offset++ ] = 0x1B;
 558 | 								jisBuf[ offset++ ] = 0x24;
 559 | 								jisBuf[ offset++ ] = 0x28;
 560 | 								jisBuf[ offset++ ] = 0x44;
 561 | 							}
 562 | 							jisBuf[ offset++ ] = ext >> 8;
 563 | 							jisBuf[ offset++ ] = ext & 0xFF;
 564 | 						}
 565 | 						else {
 566 | 							// UNKNOWN
 567 | 							if( sequence !== 2 ) {
 568 | 								sequence = 2;
 569 | 								jisBuf[ offset++ ] = 0x1B;
 570 | 								jisBuf[ offset++ ] = 0x24;
 571 | 								jisBuf[ offset++ ] = 0x42;
 572 | 							}
 573 | 							jisBuf[ offset++ ] = unknownJis >> 8;
 574 | 							jisBuf[ offset++ ] = unknownJis & 0xFF;
 575 | 						}
 576 | 					}
 577 | 				}
 578 | 			}
 579 | 
 580 | 			// Add ASCII ESC
 581 | 			if( sequence !== 0 ) {
 582 | 				sequence = 0;
 583 | 				jisBuf[ offset++ ] = 0x1B;
 584 | 				jisBuf[ offset++ ] = 0x28;
 585 | 				jisBuf[ offset++ ] = 0x42;
 586 | 			}
 587 | 			return jisBuf.slice( 0, offset );
 588 | 		}
 589 | 	});
 590 | 
 591 | 	// UTF8 -> EUCJP
 592 | 	jconv.defineEncoding({
 593 | 		name: 'UTF8toEUCJP',
 594 | 
 595 | 		convert: function( buf ) {
 596 | 			var tableJisInv    = tables[ 'JISInverted' ],
 597 | 				tableJisExtInv = tables[ 'JISEXTInverted' ],
 598 | 				unknownJis     = tableJisInv[ unknown ];
 599 | 
 600 | 			var len     = buf.length,
 601 | 				eucBuf  = new Buffer( len * 2 ),
 602 | 				offset  = 0,
 603 | 				unicode;
 604 | 
 605 | 			for( var i = 0; i < len; ) {
 606 | 				var buf1 = buf[ i++ ];
 607 | 
 608 | 				switch( buf1 >> 4 ) {
 609 | 					case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
 610 | 						unicode = buf1;
 611 | 					break;
 612 | 					case 12: case 13:
 613 | 						unicode = (buf1 & 0x1F) <<  6 | buf[ i++ ] & 0x3F;
 614 | 					break;
 615 | 					case 14:
 616 | 						unicode = (buf1 & 0x0F) << 12 | (buf[ i++ ] & 0x3F) <<  6 | buf[ i++ ] & 0x3F;
 617 | 					break;
 618 | 					default:
 619 | 						unicode = (buf1 & 0x07) << 18 | (buf[ i++ ] & 0x3F) << 12 | (buf[ i++ ] & 0x3F) << 6 | buf[ i++ ] & 0x3F;
 620 | 					break;
 621 | 				}
 622 | 
 623 | 				// ASCII
 624 | 				if( unicode < 0x80 ) {
 625 | 					eucBuf[ offset++ ] = unicode;
 626 | 				}
 627 | 				// HALFWIDTH_KATAKANA
 628 | 				else if( 0xFF61 <= unicode && unicode <= 0xFF9F ) {
 629 | 					eucBuf[ offset++ ] = 0x8E;
 630 | 					eucBuf[ offset++ ] = unicode - 0xFFC0;
 631 | 				}
 632 | 				else {
 633 | 					// KANJI
 634 | 					var jis = tableJisInv[ unicode ];
 635 | 					if( jis ) {
 636 | 						eucBuf[ offset++ ] = ( jis >> 8 ) - 0x80;
 637 | 						eucBuf[ offset++ ] = ( jis & 0xFF ) - 0x80;
 638 | 					}
 639 | 					else {
 640 | 						// EXTENSION
 641 | 						var ext = tableJisExtInv[ unicode ];
 642 | 						if( ext ) {
 643 | 							eucBuf[ offset++ ] = 0x8F;
 644 | 							eucBuf[ offset++ ] = ( ext >> 8 ) - 0x80;
 645 | 							eucBuf[ offset++ ] = ( ext & 0xFF ) - 0x80;
 646 | 						}
 647 | 						// UNKNOWN
 648 | 						else {
 649 | 							eucBuf[ offset++ ] = ( unknownJis >> 8 ) - 0x80;
 650 | 							eucBuf[ offset++ ] = ( unknownJis & 0xFF ) - 0x80;
 651 | 						}
 652 | 					}
 653 | 				}
 654 | 			}
 655 | 			return eucBuf.slice( 0, offset );
 656 | 		}
 657 | 	});
 658 | 
 659 | 	// SJIS -> UCS2
 660 | 	jconv.defineEncoding({
 661 | 		name: 'SJIStoUCS2',
 662 | 
 663 | 		convert: function( buf ) {
 664 | 			var tableSjis     = tables[ 'SJIS' ],
 665 | 				setUnicodeBuf = setUnicodeBuffer;
 666 | 
 667 | 			var len        = buf.length,
 668 | 				unicodeBuf = new Buffer( len * 3 ),
 669 | 				offset     = 0,
 670 | 				unicode;
 671 | 
 672 | 			for( var i = 0; i < len; ) {
 673 | 				var buf1 = buf[ i++ ];
 674 | 
 675 | 				// ASCII
 676 | 				if( buf1 < 0x80 ) {
 677 | 					unicode = buf1;
 678 | 				}
 679 | 				// HALFWIDTH_KATAKANA
 680 | 				else if( 0xA0 <= buf1 && buf1 <= 0xDF ) {
 681 | 					unicode = buf1 + 0xFEC0;
 682 | 				}
 683 | 				// KANJI
 684 | 				else {
 685 | 					var code = ( buf1 << 8 ) + buf[ i++ ];
 686 | 					unicode  = tableSjis[ code ] || unknown;
 687 | 				}
 688 | 				offset = setUnicodeBuf( unicode, unicodeBuf, offset );
 689 | 			}
 690 | 			return unicodeBuf.slice( 0, offset );
 691 | 		}
 692 | 	});
 693 | 
 694 | 	// SJIS -> UTF8
 695 | 	jconv.defineEncoding({
 696 | 		name: 'SJIStoUTF8',
 697 | 
 698 | 		convert: function( buf ) {
 699 | 			var tableSjis = tables[ 'SJIS' ],
 700 | 				setUtf8Buf = setUtf8Buffer;
 701 | 
 702 | 			var len     = buf.length,
 703 | 				utf8Buf = new Buffer( len * 3 ),
 704 | 				offset  = 0,
 705 | 				unicode;
 706 | 
 707 | 			for( var i = 0; i < len; ) {
 708 | 				var buf1 = buf[ i++ ];
 709 | 
 710 | 				// ASCII
 711 | 				if( buf1 < 0x80 ) {
 712 | 					unicode = buf1;
 713 | 				}
 714 | 				// HALFWIDTH_KATAKANA
 715 | 				else if( 0xA0 <= buf1 && buf1 <= 0xDF ) {
 716 | 					unicode = buf1 + 0xFEC0;
 717 | 				}
 718 | 				// KANJI
 719 | 				else {
 720 | 					var code = ( buf1 << 8 ) + buf[ i++ ];
 721 | 					unicode  = tableSjis[ code ] || unknown;
 722 | 				}
 723 | 				offset = setUtf8Buf( unicode, utf8Buf, offset );
 724 | 			}
 725 | 			return utf8Buf.slice( 0, offset );
 726 | 		}
 727 | 	});
 728 | 
 729 | 	// SJIS -> JIS
 730 | 	jconv.defineEncoding({
 731 | 		name: 'SJIStoJIS',
 732 | 
 733 | 		convert: function( buf ) {
 734 | 			var tableSjis   = tables[ 'SJIS' ],
 735 | 				tableJisInv = tables[ 'JISInverted' ];
 736 | 
 737 | 			var len      = buf.length,
 738 | 				jisBuf   = new Buffer( len * 3 + 4 ),
 739 | 				offset   = 0,
 740 | 				sequence = 0;
 741 | 
 742 | 			for( var i = 0; i < len; ) {
 743 | 				var buf1 = buf[ i++ ];
 744 | 
 745 | 				// ASCII
 746 | 				if( buf1 < 0x80 ) {
 747 | 					if( sequence !== 0 ) {
 748 | 						sequence = 0;
 749 | 						jisBuf[ offset++ ] = 0x1B;
 750 | 						jisBuf[ offset++ ] = 0x28;
 751 | 						jisBuf[ offset++ ] = 0x42;
 752 | 					}
 753 | 					jisBuf[ offset++ ] = buf1;
 754 | 				}
 755 | 				// HALFWIDTH_KATAKANA
 756 | 				else if( 0xA1 <= buf1 && buf1 <= 0xDF ) {
 757 | 					if( sequence !== 1 ) {
 758 | 						sequence = 1;
 759 | 						jisBuf[ offset++ ] = 0x1B;
 760 | 						jisBuf[ offset++ ] = 0x28;
 761 | 						jisBuf[ offset++ ] = 0x49;
 762 | 					}
 763 | 					jisBuf[ offset++ ] = buf1 - 0x80;
 764 | 				}
 765 | 				// KANJI
 766 | 				else if( buf1 <= 0xEE ) {
 767 | 					if( sequence !== 2 ) {
 768 | 						sequence = 2;
 769 | 						jisBuf[ offset++ ] = 0x1B;
 770 | 						jisBuf[ offset++ ] = 0x24;
 771 | 						jisBuf[ offset++ ] = 0x42;
 772 | 					}
 773 | 					var buf2 = buf[ i++ ];
 774 | 					buf1 <<= 1;
 775 | 					if( buf2 < 0x9F ) {
 776 | 						if( buf1 < 0x13F ) {
 777 | 							buf1 -= 0xE1;
 778 | 						}
 779 | 						else {
 780 | 							buf1 -= 0x61;
 781 | 						}
 782 | 						if( buf2 > 0x7E ) {
 783 | 							buf2 -= 0x20;
 784 | 						}
 785 | 						else {
 786 | 							buf2 -= 0x1F;
 787 | 						}
 788 | 					}
 789 | 					else {
 790 | 						if( buf1 < 0x13F ) {
 791 | 							buf1 -= 0xE0;
 792 | 						}
 793 | 						else {
 794 | 							buf1 -= 0x60;
 795 | 						}
 796 | 						buf2 -= 0x7E;
 797 | 					}
 798 | 					jisBuf[ offset++ ] = buf1;
 799 | 					jisBuf[ offset++ ] = buf2;
 800 | 				}
 801 | 				// IBM EXTENSION -> the other
 802 | 				else if( buf1 >= 0xFA ) {
 803 | 					if( sequence !== 2 ) {
 804 | 						sequence = 2;
 805 | 						jisBuf[ offset++ ] = 0x1B;
 806 | 						jisBuf[ offset++ ] = 0x24;
 807 | 						jisBuf[ offset++ ] = 0x42;
 808 | 					}
 809 | 					var sjis    = ( buf1 << 8 ) + buf[ i++ ],
 810 | 						unicode = tableSjis[ sjis ] || unknown,
 811 | 						code    = tableJisInv[ unicode ];
 812 | 
 813 | 					jisBuf[ offset++ ] = code >> 8;
 814 | 					jisBuf[ offset++ ] = code & 0xFF;
 815 | 				}
 816 | 			}
 817 | 
 818 | 			// Add ASCII ESC
 819 | 			if( sequence !== 0 ) {
 820 | 				sequence = 0;
 821 | 				jisBuf[ offset++ ] = 0x1B;
 822 | 				jisBuf[ offset++ ] = 0x28;
 823 | 				jisBuf[ offset++ ] = 0x42;
 824 | 			}
 825 | 			return jisBuf.slice( 0, offset );
 826 | 		}
 827 | 	});
 828 | 
 829 | 	// SJIS -> EUCJP
 830 | 	jconv.defineEncoding({
 831 | 		name: 'SJIStoEUCJP',
 832 | 
 833 | 		convert: function( buf ) {
 834 | 			var tableSjis   = tables[ 'SJIS' ],
 835 | 				tableJisInv = tables[ 'JISInverted' ];
 836 | 
 837 | 			var len     = buf.length,
 838 | 				eucBuf  = new Buffer( len * 2 ),
 839 | 				offset  = 0;
 840 | 
 841 | 			for( var i = 0; i < len; ) {
 842 | 				var buf1 = buf[ i++ ];
 843 | 
 844 | 				// ASCII
 845 | 				if( buf1 < 0x80 ) {
 846 | 					eucBuf[ offset++ ] = buf1;
 847 | 				}
 848 | 				// HALFWIDTH_KATAKANA
 849 | 				else if( 0xA1 <= buf1 && buf1 <= 0xDF ) {
 850 | 					eucBuf[ offset++ ] = 0x8E;
 851 | 					eucBuf[ offset++ ] = buf1;
 852 | 				}
 853 | 				// KANJI
 854 | 				else if( buf1 <= 0xEE ) {
 855 | 					var buf2 = buf[ i++ ];
 856 | 					buf1 <<= 1;
 857 | 					if( buf2 < 0x9F ) {
 858 | 						if( buf1 < 0x13F ) {
 859 | 							buf1 -= 0x61;
 860 | 						}
 861 | 						else {
 862 | 							buf1 -= 0xE1;
 863 | 						}
 864 | 						if( buf2 > 0x7E ) {
 865 | 							buf2 += 0x60;
 866 | 						}
 867 | 						else {
 868 | 							buf2 += 0x61;
 869 | 						}
 870 | 					}
 871 | 					else {
 872 | 						if( buf1 < 0x13F ) {
 873 | 							buf1 -= 0x60;
 874 | 						}
 875 | 						else {
 876 | 							buf1 -= 0xE0;
 877 | 						}
 878 | 						buf2 += 0x02;
 879 | 					}
 880 | 					eucBuf[ offset++ ] = buf1;
 881 | 					eucBuf[ offset++ ] = buf2;
 882 | 				}
 883 | 				// IBM EXTENSION -> the other
 884 | 				else if( buf1 >= 0xFA ) {
 885 | 					var sjis    = ( buf1 << 8 ) + buf[ i++ ],
 886 | 						unicode = tableSjis[ sjis ] || unknown,
 887 | 						jis     = tableJisInv[ unicode ];
 888 | 
 889 | 					eucBuf[ offset++ ] = ( jis >> 8 ) - 0x80;
 890 | 					eucBuf[ offset++ ] = ( jis & 0xFF ) - 0x80;
 891 | 				}
 892 | 			}
 893 | 			return eucBuf.slice( 0, offset );
 894 | 		}
 895 | 	});
 896 | 
 897 | 	// JIS -> UCS2
 898 | 	jconv.defineEncoding({
 899 | 		name: 'JIStoUCS2',
 900 | 
 901 | 		convert: function( buf ) {
 902 | 			var tableJis      = tables[ 'JIS' ],
 903 | 				tableJisExt   = tables[ 'JISEXT' ],
 904 | 				setUnicodeBuf = setUnicodeBuffer;
 905 | 
 906 | 			var len        = buf.length,
 907 | 				unicodeBuf = new Buffer( len * 2 ),
 908 | 				offset     = 0,
 909 | 				unicode,
 910 | 				sequence   = 0;
 911 | 
 912 | 			for( var i = 0; i < len; ) {
 913 | 				var buf1 = buf[ i++ ];
 914 | 
 915 | 				// ESC Sequence
 916 | 				if( buf1 === 0x1b ) {
 917 | 					var buf2 = buf[ i++ ],
 918 | 						buf3 = buf[ i++ ];
 919 | 					switch( buf2 ) {
 920 | 						case 0x28:
 921 | 							if( buf3 === 0x42 || buf === 0xA1 ) {
 922 | 								sequence = 0;
 923 | 							}
 924 | 							else if( buf3 === 0x49 ) {
 925 | 								sequence = 1;
 926 | 							}
 927 | 						break;
 928 | 						case 0x26:
 929 | 							sequence = 2;
 930 | 							i += 3;
 931 | 						break;
 932 | 						case 0x24:
 933 | 							if( buf3 === 0x40 || buf3 === 0x42 ) {
 934 | 								sequence = 2;
 935 | 							}
 936 | 							else if( buf3 === 0x28 ) {
 937 | 								sequence = 3;
 938 | 								i++;
 939 | 							}
 940 | 						break;
 941 | 					}
 942 | 					continue;
 943 | 				}
 944 | 
 945 | 				switch( sequence ) {
 946 | 					// ASCII
 947 | 					case 0:
 948 | 						unicode = buf1;
 949 | 					break;
 950 | 					// HALFWIDTH_KATAKANA
 951 | 					case 1:
 952 | 						unicode = buf1 + 0xFF40;
 953 | 					break;
 954 | 					// KANJI
 955 | 					case 2:
 956 | 						var code = ( buf1 << 8 ) + buf[ i++ ];
 957 | 						unicode  = tableJis[ code ] || unknown;
 958 | 					break;
 959 | 					// EXTENSION
 960 | 					case 3:
 961 | 						var code = ( buf1 << 8 ) + buf[ i++ ];
 962 | 						unicode  = tableJisExt[ code ] || unknown;
 963 | 					break;
 964 | 				}
 965 | 				offset = setUnicodeBuf( unicode, unicodeBuf, offset );
 966 | 			}
 967 | 			return unicodeBuf.slice( 0, offset );
 968 | 		}
 969 | 	});
 970 | 
 971 | 	// JIS -> UTF8
 972 | 	jconv.defineEncoding({
 973 | 		name: 'JIStoUTF8',
 974 | 
 975 | 		convert: function( buf ) {
 976 | 			var tableJis    = tables[ 'JIS' ],
 977 | 				tableJisExt = tables[ 'JISEXT' ],
 978 | 				setUtf8Buf   = setUtf8Buffer;
 979 | 
 980 | 			var len      = buf.length,
 981 | 				utf8Buf  = new Buffer( len * 2 ),
 982 | 				offset   = 0,
 983 | 				unicode,
 984 | 				sequence = 0;
 985 | 
 986 | 			for( var i = 0; i < len; ) {
 987 | 				var buf1 = buf[ i++ ];
 988 | 
 989 | 				// ESC Sequence
 990 | 				if( buf1 === 0x1b ) {
 991 | 					var buf2 = buf[ i++ ],
 992 | 						buf3 = buf[ i++ ];
 993 | 					switch( buf2 ) {
 994 | 						case 0x28:
 995 | 							if( buf3 === 0x42 || buf === 0xA1 ) {
 996 | 								sequence = 0;
 997 | 							}
 998 | 							else if( buf3 === 0x49 ) {
 999 | 								sequence = 1;
1000 | 							}
1001 | 						break;
1002 | 						case 0x26:
1003 | 							sequence = 2;
1004 | 							i += 3;
1005 | 						break;
1006 | 						case 0x24:
1007 | 							if( buf3 === 0x40 || buf3 === 0x42 ) {
1008 | 								sequence = 2;
1009 | 							}
1010 | 							else if( buf3 === 0x28 ) {
1011 | 								sequence = 3;
1012 | 								i++;
1013 | 							}
1014 | 						break;
1015 | 					}
1016 | 					continue;
1017 | 				}
1018 | 
1019 | 				switch( sequence ) {
1020 | 					// ASCII
1021 | 					case 0:
1022 | 						unicode = buf1;
1023 | 					break;
1024 | 					// HALFWIDTH_KATAKANA
1025 | 					case 1:
1026 | 						unicode = buf1 + 0xFF40;
1027 | 					break;
1028 | 					// KANJI
1029 | 					case 2:
1030 | 						var code = ( buf1 << 8 ) + buf[ i++ ];
1031 | 						unicode  = tableJis[ code ] || unknown;
1032 | 					break;
1033 | 					// EXTENSION
1034 | 					case 3:
1035 | 						var code = ( buf1 << 8 ) + buf[ i++ ];
1036 | 						unicode  = tableJisExt[ code ] || unknown;
1037 | 					break;
1038 | 				}
1039 | 				offset = setUtf8Buf( unicode, utf8Buf, offset );
1040 | 			}
1041 | 			return utf8Buf.slice( 0, offset );
1042 | 		}
1043 | 	});
1044 | 
1045 | 	// JIS -> SJIS
1046 | 	jconv.defineEncoding({
1047 | 		name: 'JIStoSJIS',
1048 | 
1049 | 		convert: function( buf ) {
1050 | 			var tableSjis    = tables[ 'SJIS' ],
1051 | 				tableSjisInv = tables[ 'SJISInverted' ],
1052 | 				unknownSjis  = tableSjisInv[ unknown ];
1053 | 
1054 | 			var len      = buf.length,
1055 | 				sjisBuf  = new Buffer( len * 2 ),
1056 | 				offset   = 0,
1057 | 				sequence = 0;
1058 | 
1059 | 			for( var i = 0; i < len; ) {
1060 | 				var buf1 = buf[ i++ ];
1061 | 
1062 | 				// ESC Sequence
1063 | 				if( buf1 === 0x1b ) {
1064 | 					var buf2 = buf[ i++ ],
1065 | 						buf3 = buf[ i++ ];
1066 | 					switch( buf2 ) {
1067 | 						case 0x28:
1068 | 							if( buf3 === 0x42 || buf === 0xA1 ) {
1069 | 								sequence = 0;
1070 | 							}
1071 | 							else if( buf3 === 0x49 ) {
1072 | 								sequence = 1;
1073 | 							}
1074 | 						break;
1075 | 						case 0x26:
1076 | 							sequence = 2;
1077 | 							i += 3;
1078 | 						break;
1079 | 						case 0x24:
1080 | 							if( buf3 === 0x40 || buf3 === 0x42 ) {
1081 | 								sequence = 2;
1082 | 							}
1083 | 							else if( buf3 === 0x28 ) {
1084 | 								sequence = 3;
1085 | 								i++;
1086 | 							}
1087 | 						break;
1088 | 					}
1089 | 					continue;
1090 | 				}
1091 | 
1092 | 				switch( sequence ) {
1093 | 					// ASCII
1094 | 					case 0:
1095 | 						sjisBuf[ offset++ ] = buf1;
1096 | 					break;
1097 | 					// HALFWIDTH_KATAKANA
1098 | 					case 1:
1099 | 						sjisBuf[ offset++ ] = buf1 + 0x80;
1100 | 					break;
1101 | 					// KANJI
1102 | 					case 2:
1103 | 						var buf2 = buf[ i++ ];
1104 | 						if( buf1 & 0x01 ) {
1105 | 							buf1 >>= 1;
1106 | 							if( buf1 < 0x2F ) {
1107 | 								buf1 += 0x71;
1108 | 							}
1109 | 							else {
1110 | 								buf1 -= 0x4F;
1111 | 							}
1112 | 							if( buf2 > 0x5F ) {
1113 | 								buf2 += 0x20;
1114 | 							}
1115 | 							else {
1116 | 								buf2 += 0x1F;
1117 | 							}
1118 | 						}
1119 | 						else {
1120 | 							buf1 >>= 1;
1121 | 							if( buf1 <= 0x2F ) {
1122 | 								buf1 += 0x70;
1123 | 							}
1124 | 							else {
1125 | 								buf1 -= 0x50;
1126 | 							}
1127 | 							buf2 += 0x7E;
1128 | 						}
1129 | 						// NEC SELECT IBM EXTENSION -> IBM EXTENSION.
1130 | 						var sjis = ( (buf1 & 0xFF) << 8 ) + buf2;
1131 | 						if( 0xED40 <= sjis && sjis <= 0xEEFC ) {
1132 | 							var unicode   = tableSjis[ sjis ],
1133 | 								sjisFixed = tableSjisInv[ unicode ] || unknownSjis;
1134 | 
1135 | 							buf1 = sjisFixed >> 8;
1136 | 							buf2 = sjisFixed & 0xFF;
1137 | 						}
1138 | 						sjisBuf[ offset++ ] = buf1;
1139 | 						sjisBuf[ offset++ ] = buf2;
1140 | 					break;
1141 | 					// EXTENSION
1142 | 					case 3:
1143 | 						sjisBuf[ offset++ ] = unknownSjis >> 8;
1144 | 						sjisBuf[ offset++ ] = unknownSjis & 0xFF;
1145 | 						i++;
1146 | 					break;
1147 | 				}
1148 | 			}
1149 | 			return sjisBuf.slice( 0, offset );
1150 | 		}
1151 | 	});
1152 | 
1153 | 	// JIS -> EUCJP
1154 | 	jconv.defineEncoding({
1155 | 		name: 'JIStoEUCJP',
1156 | 
1157 | 		convert: function( buf ) {
1158 | 			var len      = buf.length,
1159 | 				eucBuf   = new Buffer( len * 2 ),
1160 | 				offset   = 0,
1161 | 				sequence = 0;
1162 | 
1163 | 			for( var i = 0; i < len; ) {
1164 | 				var buf1 = buf[ i++ ];
1165 | 
1166 | 				// ESC Sequence
1167 | 				if( buf1 === 0x1b ) {
1168 | 					var buf2 = buf[ i++ ],
1169 | 						buf3 = buf[ i++ ];
1170 | 					switch( buf2 ) {
1171 | 						case 0x28:
1172 | 							if( buf3 === 0x42 || buf === 0xA1 ) {
1173 | 								sequence = 0;
1174 | 							}
1175 | 							else if( buf3 === 0x49 ) {
1176 | 								sequence = 1;
1177 | 							}
1178 | 						break;
1179 | 						case 0x26:
1180 | 							sequence = 2;
1181 | 							i += 3;
1182 | 						break;
1183 | 						case 0x24:
1184 | 							if( buf3 === 0x40 || buf3 === 0x42 ) {
1185 | 								sequence = 2;
1186 | 							}
1187 | 							else if( buf3 === 0x28 ) {
1188 | 								sequence = 3;
1189 | 								i++;
1190 | 							}
1191 | 						break;
1192 | 					}
1193 | 					continue;
1194 | 				}
1195 | 
1196 | 				switch( sequence ) {
1197 | 					// ASCII
1198 | 					case 0:
1199 | 						eucBuf[ offset++ ] = buf1;
1200 | 					break;
1201 | 					// HALFWIDTH_KATAKANA
1202 | 					case 1:
1203 | 						eucBuf[ offset++ ] = 0x8E;
1204 | 						eucBuf[ offset++ ] = buf1 + 0x80;
1205 | 					break;
1206 | 					// KANJI
1207 | 					case 2:
1208 | 						eucBuf[ offset++ ] = buf1 + 0x80;
1209 | 						eucBuf[ offset++ ] = buf[ i++ ] + 0x80;
1210 | 					break;
1211 | 					// EXTENSION
1212 | 					case 3:
1213 | 						eucBuf[ offset++ ] = 0x8F;
1214 | 						eucBuf[ offset++ ] = buf1 + 0x80;
1215 | 						eucBuf[ offset++ ] = buf[ i++ ] + 0x80;
1216 | 					break;
1217 | 				}
1218 | 			}
1219 | 			return eucBuf.slice( 0, offset );
1220 | 		}
1221 | 	});
1222 | 
1223 | 	// EUCJP -> UCS2
1224 | 	jconv.defineEncoding({
1225 | 		name: 'EUCJPtoUCS2',
1226 | 
1227 | 		convert: function( buf ) {
1228 | 			var tableJis      = tables[ 'JIS' ],
1229 | 				tableJisExt   = tables[ 'JISEXT' ],
1230 | 				setUnicodeBuf = setUnicodeBuffer;
1231 | 
1232 | 			var len        = buf.length,
1233 | 				unicodeBuf = new Buffer( len * 2 ),
1234 | 				offset     = 0,
1235 | 				unicode;
1236 | 
1237 | 			for( var i = 0; i < len; ) {
1238 | 				var buf1 = buf[ i++ ];
1239 | 
1240 | 				// ASCII
1241 | 				if( buf1 < 0x80 ) {
1242 | 					unicode = buf1;
1243 | 				}
1244 | 				// HALFWIDTH_KATAKANA
1245 | 				else if( buf1 === 0x8E ) {
1246 | 					unicode = buf[ i++ ] + 0xFEC0;
1247 | 				}
1248 | 				// EXTENSION
1249 | 				else if( buf1 === 0x8F ) {
1250 | 					var jisbuf2 = buf[ i++ ] - 0x80,
1251 | 						jisbuf3 = buf[ i++ ] - 0x80,
1252 | 						jis = ( jisbuf2 << 8 ) + jisbuf3;
1253 | 					unicode = tableJisExt[ jis ] || unknown;
1254 | 				}
1255 | 				// KANJI
1256 | 				else {
1257 | 					var jisbuf1 = buf1 - 0x80,
1258 | 						jisbuf2 = buf[ i++ ] - 0x80,
1259 | 						jis = ( jisbuf1 << 8 ) + jisbuf2;
1260 | 					unicode = tableJis[ jis ] || unknown;
1261 | 				}
1262 | 				offset = setUnicodeBuf( unicode, unicodeBuf, offset );
1263 | 			}
1264 | 			return unicodeBuf.slice( 0, offset );
1265 | 		}
1266 | 	});
1267 | 
1268 | 	// EUCJP -> UTF8
1269 | 	jconv.defineEncoding({
1270 | 		name: 'EUCJPtoUTF8',
1271 | 
1272 | 		convert: function( buf ) {
1273 | 			var tableJis    = tables[ 'JIS' ],
1274 | 				tableJisExt = tables[ 'JISEXT' ],
1275 | 				setUtf8Buf   = setUtf8Buffer;
1276 | 
1277 | 			var len     = buf.length,
1278 | 				utf8Buf = new Buffer( len * 2 ),
1279 | 				offset  = 0,
1280 | 				unicode;
1281 | 
1282 | 			for( var i = 0; i < len; ) {
1283 | 				var buf1 = buf[ i++ ];
1284 | 
1285 | 				// ASCII
1286 | 				if( buf1 < 0x80 ) {
1287 | 					unicode = buf1;
1288 | 				}
1289 | 				// HALFWIDTH_KATAKANA
1290 | 				else if( buf1 === 0x8E ) {
1291 | 					unicode = buf[ i++ ] + 0xFEC0;
1292 | 				}
1293 | 				// EXTENSION
1294 | 				else if( buf1 === 0x8F ) {
1295 | 					var jisbuf2 = buf[ i++ ] - 0x80,
1296 | 						jisbuf3 = buf[ i++ ] - 0x80,
1297 | 						jis = ( jisbuf2 << 8 ) + jisbuf3;
1298 | 					unicode = tableJisExt[ jis ] || unknown;
1299 | 				}
1300 | 				// KANJI
1301 | 				else {
1302 | 					var jisbuf1 = buf1 - 0x80,
1303 | 						jisbuf2 = buf[ i++ ] - 0x80,
1304 | 						jis = ( jisbuf1 << 8 ) + jisbuf2;
1305 | 					unicode = tableJis[ jis ] || unknown;
1306 | 				}
1307 | 				offset = setUtf8Buf( unicode, utf8Buf, offset );
1308 | 			}
1309 | 			return utf8Buf.slice( 0, offset );
1310 | 		}
1311 | 	});
1312 | 
1313 | 	// EUCJP -> SJIS
1314 | 	jconv.defineEncoding({
1315 | 		name: 'EUCJPtoSJIS',
1316 | 
1317 | 		convert: function( buf ) {
1318 | 			var tableSjis    = tables[ 'SJIS' ],
1319 | 				tableSjisInv = tables[ 'SJISInverted' ],
1320 | 				unknownSjis  = tableSjisInv[ unknown ];
1321 | 
1322 | 			var len     = buf.length,
1323 | 				sjisBuf = new Buffer( len * 2 ),
1324 | 				offset  = 0;
1325 | 
1326 | 			for( var i = 0; i < len; ) {
1327 | 				var buf1 = buf[ i++ ];
1328 | 
1329 | 				// ASCII
1330 | 				if( buf1 < 0x80 ) {
1331 | 					sjisBuf[ offset++ ] = buf1;
1332 | 				}
1333 | 				// HALFWIDTH_KATAKANA
1334 | 				else if( buf1 === 0x8E ) {
1335 | 					sjisBuf[ offset++ ] = buf[ i++ ];
1336 | 				}
1337 | 				// EXTENSION
1338 | 				else if( buf1 === 0x8F ) {
1339 | 					sjisBuf[ offset++ ] = unknownSjis >> 8;
1340 | 					sjisBuf[ offset++ ] = unknownSjis & 0xFF;
1341 | 					i += 2;
1342 | 				}
1343 | 				// KANJI
1344 | 				else {
1345 | 					var buf2 = buf[ i++ ];
1346 | 					if( buf1 & 0x01 ) {
1347 | 						buf1 >>= 1;
1348 | 						if( buf1 < 0x6F ) {
1349 | 							buf1 += 0x31;
1350 | 						}
1351 | 						else {
1352 | 							buf1 += 0x71;
1353 | 						}
1354 | 						if( buf2 > 0xDF ) {
1355 | 							buf2 -= 0x60;
1356 | 						}
1357 | 						else {
1358 | 							buf2 -= 0x61;
1359 | 						}
1360 | 					}
1361 | 					else {
1362 | 						buf1 >>= 1;
1363 | 						if( buf1 <= 0x6F ) {
1364 | 							buf1 += 0x30;
1365 | 						}
1366 | 						else {
1367 | 							buf1 += 0x70;
1368 | 						}
1369 | 						buf2 -= 0x02;
1370 | 					}
1371 | 					// NEC SELECT IBM EXTENSION -> IBM EXTENSION.
1372 | 					var sjis = ( (buf1 & 0xFF) << 8 ) + buf2;
1373 | 					if( 0xED40 <= sjis && sjis <= 0xEEFC ) {
1374 | 						var unicode   = tableSjis[ sjis ],
1375 | 							sjisFixed = tableSjisInv[ unicode ] || unknownSjis;
1376 | 
1377 | 						buf1 = sjisFixed >> 8;
1378 | 						buf2 = sjisFixed & 0xFF;
1379 | 					}
1380 | 					sjisBuf[ offset++ ] = buf1;
1381 | 					sjisBuf[ offset++ ] = buf2;
1382 | 				}
1383 | 			}
1384 | 			return sjisBuf.slice( 0, offset );
1385 | 		}
1386 | 	});
1387 | 
1388 | 	// EUCJP -> JIS
1389 | 	jconv.defineEncoding({
1390 | 		name: 'EUCJPtoJIS',
1391 | 
1392 | 		convert: function( buf ) {
1393 | 			var len      = buf.length,
1394 | 				jisBuf   = new Buffer( len * 3 + 4 ),
1395 | 				offset   = 0,
1396 | 				sequence = 0;
1397 | 
1398 | 			for( var i = 0; i < len; ) {
1399 | 				var buf1 = buf[ i++ ];
1400 | 
1401 | 				// ASCII
1402 | 				if( buf1 < 0x80 ) {
1403 | 					if( sequence !== 0 ) {
1404 | 						sequence = 0;
1405 | 						jisBuf[ offset++ ] = 0x1B;
1406 | 						jisBuf[ offset++ ] = 0x28;
1407 | 						jisBuf[ offset++ ] = 0x42;
1408 | 					}
1409 | 					jisBuf[ offset++ ] = buf1;
1410 | 				}
1411 | 				// HALFWIDTH_KATAKANA
1412 | 				else if( buf1 === 0x8E ) {
1413 | 					if( sequence !== 1 ) {
1414 | 						sequence = 1;
1415 | 						jisBuf[ offset++ ] = 0x1B;
1416 | 						jisBuf[ offset++ ] = 0x28;
1417 | 						jisBuf[ offset++ ] = 0x49;
1418 | 					}
1419 | 					jisBuf[ offset++ ] = buf[ i++ ] - 0x80;
1420 | 				}
1421 | 				// EXTENSION
1422 | 				else if( buf1 === 0x8F ) {
1423 | 					if( sequence !== 3 ) {
1424 | 						sequence = 3;
1425 | 						jisBuf[ offset++ ] = 0x1B;
1426 | 						jisBuf[ offset++ ] = 0x24;
1427 | 						jisBuf[ offset++ ] = 0x28;
1428 | 						jisBuf[ offset++ ] = 0x44;
1429 | 					}
1430 | 					jisBuf[ offset++ ] = buf[ i++ ] - 0x80;
1431 | 					jisBuf[ offset++ ] = buf[ i++ ] - 0x80;
1432 | 				}
1433 | 				// KANJI
1434 | 				else {
1435 | 					if( sequence !== 2 ) {
1436 | 						sequence = 2;
1437 | 						jisBuf[ offset++ ] = 0x1B;
1438 | 						jisBuf[ offset++ ] = 0x24;
1439 | 						jisBuf[ offset++ ] = 0x42;
1440 | 					}
1441 | 					jisBuf[ offset++ ] = buf1 - 0x80;
1442 | 					jisBuf[ offset++ ] = buf[ i++ ] - 0x80;
1443 | 				}
1444 | 			}
1445 | 
1446 | 			// Add ASCII ESC
1447 | 			if( sequence !== 0 ) {
1448 | 				sequence = 0;
1449 | 				jisBuf[ offset++ ] = 0x1B;
1450 | 				jisBuf[ offset++ ] = 0x28;
1451 | 				jisBuf[ offset++ ] = 0x42;
1452 | 			}
1453 | 			return jisBuf.slice( 0, offset );
1454 | 		}
1455 | 	});
1456 | 
1457 | })();
1458 | 


--------------------------------------------------------------------------------