'>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
'コスプレグラフィック作成スクリプト               by はにわ 2009/08/16 ver1.00
'>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
'■概要
'　モンスターACT/SPRファイルをプレイヤー髪型ACT/SPRファイルに変換します
'
'■※注意※
'　何分待っても処理が終わらない場合はバグが起きている可能性があります
'　自己責任になりますがタスクマネージャからwscript.exeを強制終了して下さい
'
'■使い方
'　1)下記『エラーになるケース』及び『補足』を良くお読み下さい
'　2)モンスターACTファイルをこのスクリプトにD&Dして下さい
'　　フォルダごとD&Dする事も出来ます
'　3)数十秒で処理が終わり、〜_player.actと〜_player.sprファイルが作成されます
'
'■エラーになるケース
'　メモリが足りない(メモリに1.5GBの空きが必要です)
'　SPRファイルがACTファイルと同じフォルダに無い
'　パスやファイル名にハングル文字が含まれている
'　モンスターACTの中に攻撃や死亡等のモーションが無い
'　モンスターグラフィックが大きい(例:魔王モロク)
'　モンスターグラフィックが多い
'　正常終了するけどファイルをactorで見るとおかしい(例:オークヒーロー)
'
'■補足
'　出来たファイルはactorでチェックすることをお勧めします
'　出来たファイルはクライアントで一通りの表示位置を確認することをお勧めします
'　重い、遅い、バグ有りなのは現在のところ仕様です
'　プログラム内のコメントが適当なのも仕様です
'
'■課題
'　上記『エラーになるケース』の解決
'　座標計算がイマイチなので表示位置ずれやモーションぶれが起きている
'　死亡時画像として死亡モーションの最後の画像を使っているのでおかしい場合がある
'　パレットの都合上、半透明にならない(例:ボンゴン攻撃時の残影がはっきり見える)
'　モンスター固有の効果音を出せない(クライアントの仕様の為)
'　SPRファイルサイズが大きくなる(例:月夜花80KB→500KB)
'　スキル使用時に一瞬消える
'
'■感謝
'　本スクリプト作成にあたり、actorを大変参考にさせて頂きました。感謝m(_ _)m
'>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Option Explicit

'=================================================================
'動作切替オプション
'=================================================================
Const FLG_USE_MEMORY = 2			'2       :必要メモリ量(1.5GB) / 変換可能ACT(並)
									'1       :必要メモリ量(1.1GB) / 変換可能ACT(小)
									'それ以外:必要メモリ量(800MB) / 変換可能ACT(極少)
									
Const FLG_ERROR_SKIP = 0			'1:実行エラー無視 それ以外:実行エラーでストップ

'=================================================================
'定数宣言
'=================================================================
Const ENCODE_UNICODE = "unicode"

'StreamTypeEnum
Const adTypeBinary = 1
Const adTypeText = 2
Const adWriteCreate = 1
Const adWriteOver = 2

Const NUM_ACT_PLAYER = 12			'プレイヤーACTの数(13-1=12)
Const NUM_ORIENT = 7				'向きの数(8-1=7)
Const NUM_SOUND_FILE_NAME = 40		'効果音ファイル名の長さ
Const NUM_YOFS_PULS = 0				'Yoffs補正値
Const NUM_YOFS_STANDUP = 64			'Yoffs補正値(立ち)
Const NUM_YOFS_SITDOWN = 43			'Yoffs補正値(座り)
Const NUM_YOFS_PICKUP = 41			'Yoffs補正値(アイテム拾い)
Const NUM_PI = 3.1415926535897932	'座標変換用

Const STR_FILE_ADD = "_player"		'変換後ACT/SPRファイル名への付与文字列

'*********************************************************************
'メイン処理
'*********************************************************************
Dim oParam							'引数
Dim iPrmCnt							'引数カウンタ
Dim iPrcCnt							'処理数カウンタ

Set oParam = WScript.Arguments		'引数取得

iPrcCnt = 0							'処理数を初期化

'引数の数だけループ
For iPrmCnt=0 To oParam.Count-1
	Execute oParam(iPrmCnt), iPrcCnt
Next

'処理終了メッセージ
if iPrcCnt > 0 then
	WScript.echo "Finish."
else
	WScript.echo "Target Not Found."
end if

'*********************************************************************
'フォルダ展開ファンクション
'*********************************************************************
Function Execute(ByVal fName, ByRef iPrcCnt)
	Dim sFso
	Dim sFile
	Dim sFolder
	Dim sSubFolder
	Dim iCnt
	
	Set sFso = WScript.CreateObject("Scripting.FileSystemObject")
	
	'ファイルの場合
	If sFso.FileExists(fName) = True Then
		'拡張子が.ACTであるもののみを処理する
		if UCase(Right(fName, 4)) = ".ACT" then
			'変換後のキーワードを含まないものを対象とする
			if InStr(fName,STR_FILE_ADD) = 0 then
				'変換処理
				Convert(Left(fName, Len(fName)-4))
				'処理数+1
				iPrcCnt = iPrcCnt + 1
			end if
		end if
	
	'フォルダの場合
	elseif sFso.FolderExists(fName) = True Then
		Set sFolder = sFso.GetFolder(fName)
		
		'フォルダ内のファイルの数だけループ
		for Each sFile In sFolder.Files
			Execute sFolder.Path & "\" & sFile.Name, iPrcCnt
		next
		
		'フォルダ内のサブフォルダの数だけループ
		for Each sSubFolder In sFolder.SubFolders
			Execute sFolder.Path & "\" & sSubFolder.Name, iPrcCnt
		next
		
	end if
	
End Function

'*********************************************************************
'変換ファンクション
'*********************************************************************
Function Convert(fName)
	'エラー無視設定
	if FLG_ERROR_SKIP = 1 then
		On Error Resume Next
	end if
	
	'=================================================================
	'変数宣言
	'=================================================================
	Dim sInAct							'変換前ACTファイル名
	Dim sOutAct							'変換後ACTファイル名
	Dim sInSpr							'変換前SPRファイル名
	Dim sOutSpr							'変換後SPRファイル名
	Dim sInp							'変換前ACTファイルストリーム
	Dim sOut							'変換後ACTファイルストリーム
	Dim bStream							'VBScriptバイトデータ操作クラス
	Dim iImgS							'イメージサイズ
	Dim iImgX							'イメージ幅
	Dim iImgY							'イメージ高さ
	Dim iPos							'読み込み位置
	Dim iInPos							'読み込み位置(入力)
	Dim iOutPos							'読み込み位置(出力)
	Dim iSprNo							'スプライトNo
	Dim sFso							'FileSystemObject
	
	'ACTデータ配列
	Dim sHeader()						'ヘッダー情報
	Dim sFrmNum()						'フレーム数
	Dim sFrame()						'フレーム情報
	Dim sSprite()						'スプライト情報
	Dim sExtent()						'拡張情報
	Dim sSndNum()						'効果音数
	Dim sSound()						'効果音情報
	Dim sInterval()						'アニメーション間隔情報
	Dim sExtCns()						'拡張情報固定値
	'SPRデータ配列
	Dim sSprHead()						'ヘッダー情報
	Dim sImage()						'イメージ情報
	Dim sImageSyn()						'合成後イメージ情報
	Dim sImageCmp()						'圧縮後イメージ情報
	Dim sImageData()					'イメージデータ
	Dim sImageDataSyn()					'合成後イメージデータ
	Dim sImageDataCmp()					'圧縮後イメージデータ
	Dim sPallet()						'パレットデータ
	'ACT-SPR対応
	Dim sActSpr()						'ACT-SPR対応
	
	if FLG_USE_MEMORY = 2 then
		'ACTデータ配列
		ReDim sHeader(5, 3)					'ヘッダー情報(6情報 * 最大4byte)
		ReDim sFrmNum(12, 8, 3)				'フレーム数(act数 * 8方向 * 4byte)
		ReDim sFrame(12, 7, 99, 10, 3)		'フレーム情報(act数 * 8方向 * 100フレーム * 11情報 * 4byte)
		ReDim sSprite(12, 7, 99, 29, 10, 3)	'スプライト情報(act数 * 8方向 * 100フレーム * 30スプライト * 11情報 * 4byte)
		ReDim sExtent(12, 7, 99, 29, 4, 3)	'拡張情報(act数 * 8方向 * 100フレーム * 30個 * 4情報 * 4byte)
		ReDim sSndNum(3)					'効果音数(4byte)
		ReDim sSound(49,39)					'効果音情報(50個 * 40byte)
		ReDim sInterval(12, 7, 3)			'アニメーション間隔情報(act数 * 8方向 * 4byte)
		ReDim sExtCns(12, 7, 1)				'拡張情報固定値(act数 * 8方向 * 4情報)
		'SPRデータ配列
		ReDim sSprHead(2, 3)				'ヘッダー情報(3情報 * 最大4byte)
		ReDim sImage(299, 2 ,1)				'イメージ情報(300イメージ * 3情報 * 2byte)
		ReDim sImageSyn(399, 2 ,1)			'合成後イメージ情報(400イメージ * 3情報 * 2byte)
		ReDim sImageCmp(399, 2 ,1)			'圧縮後イメージ情報(400イメージ * 3情報 * 2byte)
		ReDim sImageData(299, 255, 255)		'イメージデータ(300イメージ * 最大縦256ドット * 最大横256ドット)
		ReDim sImageDataSyn(399, 255, 255)	'合成後イメージデータ(400イメージ * 最大縦256ドット * 最大横256ドット)
		ReDim sImageDataCmp(399, 65536)		'圧縮後イメージデータ(400イメージ * 65536+1byte(最大縦256ドット*最大横256ドット+圧縮情報1byte))
		ReDim sPallet(255, 3)				'パレットデータ(256色 * 4byte)
		'ACT-SPR対応
		ReDim sActSpr(12, 8, 79, 2)			'ACT-SPR対応(act数 * 8方向 * 80フレーム * 3情報)
	
	elseif FLG_USE_MEMORY = 1 then
		'ACTデータ配列
		ReDim sHeader(5, 3)					'ヘッダー情報(6情報 * 最大4byte)
		ReDim sFrmNum(12, 8, 3)				'フレーム数(act数 * 8方向 * 4byte)
		ReDim sFrame(12, 7, 79, 10, 3)		'フレーム情報(act数 * 8方向 * 80フレーム * 11情報 * 4byte)
		ReDim sSprite(12, 7, 79, 29, 10, 3)	'スプライト情報(act数 * 8方向 * 80フレーム * 30スプライト * 11情報 * 4byte)
		ReDim sExtent(12, 7, 79, 29, 4, 3)	'拡張情報(act数 * 8方向 * 80フレーム * 30個 * 4情報 * 4byte)
		ReDim sSndNum(3)					'効果音数(4byte)
		ReDim sSound(49,39)					'効果音情報(50個 * 40byte)
		ReDim sInterval(12, 7, 3)			'アニメーション間隔情報(act数 * 8方向 * 4byte)
		ReDim sExtCns(12, 7, 1)				'拡張情報固定値(act数 * 8方向 * 4情報)
		'SPRデータ配列
		ReDim sSprHead(2, 3)				'ヘッダー情報(3情報 * 最大4byte)
		ReDim sImage(199, 2 ,1)				'イメージ情報(200イメージ * 3情報 * 2byte)
		ReDim sImageSyn(299, 2 ,1)			'合成後イメージ情報(300イメージ * 3情報 * 2byte)
		ReDim sImageCmp(299, 2 ,1)			'圧縮後イメージ情報(300イメージ * 3情報 * 2byte)
		ReDim sImageData(199, 255, 255)		'イメージデータ(200イメージ * 最大縦256ドット * 最大横256ドット)
		ReDim sImageDataSyn(299, 255, 255)	'合成後イメージデータ(300イメージ * 最大縦256ドット * 最大横256ドット)
		ReDim sImageDataCmp(299, 65536)		'圧縮後イメージデータ(300イメージ * 65536+1byte(最大縦256ドット*最大横256ドット+圧縮情報1byte))
		ReDim sPallet(255, 3)				'パレットデータ(256色 * 4byte)
		'ACT-SPR対応
		ReDim sActSpr(12, 8, 79, 2)			'ACT-SPR対応(act数 * 8方向 * 80フレーム * 3情報)
	
	else
		'ACTデータ配列
		ReDim sHeader(5, 3)					'ヘッダー情報(6情報 * 最大4byte)
		ReDim sFrmNum(12, 8, 3)				'フレーム数(act数 * 8方向 * 4byte)
		ReDim sFrame(12, 7, 49, 10, 3)		'フレーム情報(act数 * 8方向 * 50フレーム * 11情報 * 4byte)
		ReDim sSprite(12, 7, 49, 19, 10, 3)	'スプライト情報(act数 * 8方向 * 50フレーム * 20スプライト * 11情報 * 4byte)
		ReDim sExtent(12, 7, 49, 19, 4, 3)	'拡張情報(act数 * 8方向 * 50フレーム * 20個 * 4情報 * 4byte)
		ReDim sSndNum(3)					'効果音数(4byte)
		ReDim sSound(49,39)					'効果音情報(50個 * 40byte)
		ReDim sInterval(12, 7, 3)			'アニメーション間隔情報(act数 * 8方向 * 4byte)
		ReDim sExtCns(12, 7, 1)				'拡張情報固定値(act数 * 8方向 * 4情報)
		'SPRデータ配列
		ReDim sSprHead(2, 3)				'ヘッダー情報(3情報 * 最大4byte)
		ReDim sImage(199, 2 ,1)				'イメージ情報(200イメージ * 3情報 * 2byte)
		ReDim sImageSyn(199, 2 ,1)			'合成後イメージ情報(200イメージ * 3情報 * 2byte)
		ReDim sImageCmp(199, 2 ,1)			'圧縮後イメージ情報(200イメージ * 3情報 * 2byte)
		ReDim sImageData(199, 255, 255)		'イメージデータ(200イメージ * 最大縦256ドット * 最大横256ドット)
		ReDim sImageDataSyn(199, 255, 255)	'合成後イメージデータ(200イメージ * 最大縦256ドット * 最大横256ドット)
		ReDim sImageDataCmp(199, 65536)		'圧縮後イメージデータ(200イメージ * 65536+1byte(最大縦256ドット*最大横256ドット+圧縮情報1byte))
		ReDim sPallet(255, 3)				'パレットデータ(256色 * 4byte)
		'ACT-SPR対応
		ReDim sActSpr(12, 8, 79, 2)			'ACT-SPR対応(act数 * 8方向 * 80フレーム * 3情報)
	end if
	
	'カウンタ
	Dim iActCnt							'ACTカウンタ
	Dim iOriCnt							'向きカウンタ
	Dim iFrmCnt							'フレームカウンタ
	Dim iPalCnt							'パレットカウンタ
	Dim iSprCnt							'スプライトカウンタ
	Dim iExtCnt							'拡張情報数カウンタ
	Dim iSndCnt							'効果音カウンタ
	Dim iSefCnt							'効果音ファイル名カウンタ
	Dim iImgCnt							'イメージカウンタ
	Dim iPlayActCnt						'プレイヤーACTカウンタ
	Dim iFrmCntExt						'フレームカウンタ(拡張)
	Dim iSprCntExt						'スプライトカウンタ(拡張)
	Dim iImgSCnt						'圧縮イメージ展開/圧縮カウンタ
	Dim iZeroCnt						'圧縮イメージ&H00データカウンタ
	Dim iCmpImgCnt						'圧縮イメージ数
	Dim iXCnt							'幅カウンタ
	Dim iYCnt							'高さカウンタ
	Dim iSCnt							'サイズカウンタ
	
	Dim iBuf							'数値バッファ
	Dim iActNum							'アニメーション数
	Dim iFrmNum							'フレーム数
	Dim iPalNum							'パレット数
	Dim iSprNum							'スプライト数
	Dim iExtNum							'拡張情報数
	Dim iSndNum							'効果音数
	Dim iImgNum							'イメージ数
	Dim iXMaxNum						'幅最大値
	Dim iYMaxNum						'高さ最大値
	Dim iXofsNum
	Dim iYofsNum
	Dim iXImgNum
	Dim iYImgNum
	Dim iRImgNum
	Dim iMirrNum
	Dim iRotNum
	Dim iRight
	Dim iLeft
	Dim iTop
	Dim iBottom
	Dim iRightMax
	Dim iLeftMax
	Dim iTopMax
	Dim iBottomMax
	Dim iXPos
	Dim iYPos
	Dim iYCntSyn
	Dim iXCntSyn
	Dim iRad
	Dim iImgSyn
	Dim iRotX
	Dim iRotY
	Dim iSprSyn
	
	Dim iXofsVal						'Xoffs補正用
	Dim iXofsValTop						'Xoffs補正用
	Dim iXofsValBtm						'Xoffs補正用
	Dim sXofsValTop						'Xoffs補正用
	Dim sXofsValBtm						'Xoffs補正用
	Dim iYofsVal						'Yoffs補正用
	Dim iYofsValTop						'Yoffs補正用
	Dim iYofsValBtm						'Yoffs補正用
	Dim sYofsValTop						'Yoffs補正用
	Dim sYofsValBtm						'Yoffs補正用
	
	Dim iTypeCd							'ACTファイルフォーマットタイプ
	
	'=================================================================
	'初期設定
	'=================================================================
	sInAct = fName & ".act"
	sOutAct = fName & STR_FILE_ADD & ".act"
	sInSpr = fName & ".spr"
	sOutSpr = fName & STR_FILE_ADD & ".spr"
	
	Set sInp = CreateObject("ADODB.Stream")
	sInp.Type = adTypeBinary

	Set sOut = CreateObject("ADODB.Stream")
	sOut.Type = adTypeBinary

	Set bStream = New ByteStream
	
	'FileSystemObject呼び出し
	Set sFso = WScript.CreateObject("Scripting.FileSystemObject")
	
	'拡張情報固定値
	'act No0〜No7
	sExtCns(0, 0, 0) = "00000001"
	sExtCns(0, 0, 1) = "FFFFFFC9"
	sExtCns(0, 1, 0) = "FFFFFFFD"
	sExtCns(0, 1, 1) = "FFFFFFC8"
	sExtCns(0, 2, 0) = "FFFFFFFD"
	sExtCns(0, 2, 1) = "FFFFFFC8"
	sExtCns(0, 3, 0) = "0000000D"
	sExtCns(0, 3, 1) = "FFFFFFB8"
	sExtCns(0, 4, 0) = "0000000C"
	sExtCns(0, 4, 1) = "FFFFFFB9"
	sExtCns(0, 5, 0) = "FFFFFFF4"
	sExtCns(0, 5, 1) = "FFFFFFB8"
	sExtCns(0, 6, 0) = "00000004"
	sExtCns(0, 6, 1) = "FFFFFFC8"
	sExtCns(0, 7, 0) = "00000004"
	sExtCns(0, 7, 1) = "FFFFFFC8"
	'act No8〜No15
	sExtCns(1, 0, 0) = "00000000"
	sExtCns(1, 0, 1) = "FFFFFFC7"
	sExtCns(1, 1, 0) = "FFFFFFFC"
	sExtCns(1, 1, 1) = "FFFFFFC7"
	sExtCns(1, 2, 0) = "FFFFFFFC"
	sExtCns(1, 2, 1) = "FFFFFFC7"
	sExtCns(1, 3, 0) = "0000000E"
	sExtCns(1, 3, 1) = "FFFFFFB8"
	sExtCns(1, 4, 0) = "0000000C"
	sExtCns(1, 4, 1) = "FFFFFFB9"
	sExtCns(1, 5, 0) = "FFFFFFF3"
	sExtCns(1, 5, 1) = "FFFFFFB8"
	sExtCns(1, 6, 0) = "00000005"
	sExtCns(1, 6, 1) = "FFFFFFC7"
	sExtCns(1, 7, 0) = "00000005"
	sExtCns(1, 7, 1) = "FFFFFFC7"
	'act No16〜No23
	sExtCns(2, 0, 0) = "00000000"
	sExtCns(2, 0, 1) = "FFFFFFDC"
	sExtCns(2, 1, 0) = "FFFFFFFC"
	sExtCns(2, 1, 1) = "FFFFFFDD"
	sExtCns(2, 2, 0) = "FFFFFFFC"
	sExtCns(2, 2, 1) = "FFFFFFDD"
	sExtCns(2, 3, 0) = "0000000C"
	sExtCns(2, 3, 1) = "FFFFFFCC"
	sExtCns(2, 4, 0) = "0000000C"
	sExtCns(2, 4, 1) = "FFFFFFCD"
	sExtCns(2, 5, 0) = "00000005"
	sExtCns(2, 5, 1) = "FFFFFFDC"
	sExtCns(2, 6, 0) = "00000005"
	sExtCns(2, 6, 1) = "FFFFFFDD"
	sExtCns(2, 7, 0) = "00000005"
	sExtCns(2, 7, 1) = "FFFFFFDD"
	'act No24〜No31
	sExtCns(3, 0, 0) = "FFFFFFF9"
	sExtCns(3, 0, 1) = "FFFFFFC8"
	sExtCns(3, 1, 0) = "FFFFFFF9"
	sExtCns(3, 1, 1) = "FFFFFFC8"
	sExtCns(3, 2, 0) = "FFFFFFF9"
	sExtCns(3, 2, 1) = "FFFFFFC8"
	sExtCns(3, 3, 0) = "FFFFFFF9"
	sExtCns(3, 3, 1) = "FFFFFFC8"
	sExtCns(3, 4, 0) = "00000008"
	sExtCns(3, 4, 1) = "FFFFFFC8"
	sExtCns(3, 5, 0) = "00000008"
	sExtCns(3, 5, 1) = "FFFFFFC8"
	sExtCns(3, 6, 0) = "00000008"
	sExtCns(3, 6, 1) = "FFFFFFC8"
	sExtCns(3, 7, 0) = "00000008"
	sExtCns(3, 7, 1) = "FFFFFFC8"
	'act No32〜No39
	sExtCns(4, 0, 0) = "FFFFFFFA"
	sExtCns(4, 0, 1) = "FFFFFFC7"
	sExtCns(4, 1, 0) = "FFFFFFFA"
	sExtCns(4, 1, 1) = "FFFFFFC7"
	sExtCns(4, 2, 0) = "0000000E"
	sExtCns(4, 2, 1) = "FFFFFFB8"
	sExtCns(4, 3, 0) = "0000000E"
	sExtCns(4, 3, 1) = "FFFFFFB8"
	sExtCns(4, 4, 0) = "FFFFFFF3"
	sExtCns(4, 4, 1) = "FFFFFFB8"
	sExtCns(4, 5, 0) = "FFFFFFF3"
	sExtCns(4, 5, 1) = "FFFFFFB8"
	sExtCns(4, 6, 0) = "00000007"
	sExtCns(4, 6, 1) = "FFFFFFC7"
	sExtCns(4, 7, 0) = "00000007"
	sExtCns(4, 7, 1) = "FFFFFFC7"
	'act No40〜No47
	sExtCns(5, 0, 0) = "FFFFFFFC"
	sExtCns(5, 0, 1) = "FFFFFFC7"
	sExtCns(5, 1, 0) = "FFFFFFFC"
	sExtCns(5, 1, 1) = "FFFFFFC7"
	sExtCns(5, 2, 0) = "0000000F"
	sExtCns(5, 2, 1) = "FFFFFFB8"
	sExtCns(5, 3, 0) = "0000000F"
	sExtCns(5, 3, 1) = "FFFFFFB8"
	sExtCns(5, 4, 0) = "FFFFFFF2"
	sExtCns(5, 4, 1) = "FFFFFFB8"
	sExtCns(5, 5, 0) = "FFFFFFF2"
	sExtCns(5, 5, 1) = "FFFFFFB8"
	sExtCns(5, 6, 0) = "00000005"
	sExtCns(5, 6, 1) = "FFFFFFC7"
	sExtCns(5, 7, 0) = "00000005"
	sExtCns(5, 7, 1) = "FFFFFFC7"
	'act No48〜No55
	sExtCns(6, 0, 0) = "0000000D"
	sExtCns(6, 0, 1) = "FFFFFFC9"
	sExtCns(6, 1, 0) = "0000000D"
	sExtCns(6, 1, 1) = "FFFFFFC9"
	sExtCns(6, 2, 0) = "00000007"
	sExtCns(6, 2, 1) = "FFFFFFC0"
	sExtCns(6, 3, 0) = "00000007"
	sExtCns(6, 3, 1) = "FFFFFFC0"
	sExtCns(6, 4, 0) = "FFFFFFFA"
	sExtCns(6, 4, 1) = "FFFFFFC0"
	sExtCns(6, 5, 0) = "FFFFFFFA"
	sExtCns(6, 5, 1) = "FFFFFFC0"
	sExtCns(6, 6, 0) = "FFFFFFF4"
	sExtCns(6, 6, 1) = "FFFFFFC9"
	sExtCns(6, 7, 0) = "FFFFFFF4"
	sExtCns(6, 7, 1) = "FFFFFFC9"
	'act No56〜No63
	sExtCns(7, 0, 0) = "0000001D"
	sExtCns(7, 0, 1) = "FFFFFFCD"
	sExtCns(7, 1, 0) = "0000001D"
	sExtCns(7, 1, 1) = "FFFFFFCD"
	sExtCns(7, 2, 0) = "00000018"
	sExtCns(7, 2, 1) = "FFFFFFCB"
	sExtCns(7, 3, 0) = "00000018"
	sExtCns(7, 3, 1) = "FFFFFFCB"
	sExtCns(7, 4, 0) = "FFFFFFE9"
	sExtCns(7, 4, 1) = "FFFFFFCB"
	sExtCns(7, 5, 0) = "FFFFFFE9"
	sExtCns(7, 5, 1) = "FFFFFFCB"
	sExtCns(7, 6, 0) = "FFFFFFE4"
	sExtCns(7, 6, 1) = "FFFFFFCD"
	sExtCns(7, 7, 0) = "FFFFFFE4"
	sExtCns(7, 7, 1) = "FFFFFFCD"
	'act No64〜No71
	sExtCns(8, 0, 0) = "00000039"
	sExtCns(8, 0, 1) = "FFFFFFE6"
	sExtCns(8, 1, 0) = "00000039"
	sExtCns(8, 1, 1) = "FFFFFFE6"
	sExtCns(8, 2, 0) = "00000020"
	sExtCns(8, 2, 1) = "FFFFFFEF"
	sExtCns(8, 3, 0) = "00000020"
	sExtCns(8, 3, 1) = "FFFFFFEF"
	sExtCns(8, 4, 0) = "FFFFFFE1"
	sExtCns(8, 4, 1) = "FFFFFFEF"
	sExtCns(8, 5, 0) = "FFFFFFE1"
	sExtCns(8, 5, 1) = "FFFFFFEF"
	sExtCns(8, 6, 0) = "FFFFFFC8"
	sExtCns(8, 6, 1) = "FFFFFFE6"
	sExtCns(8, 7, 0) = "FFFFFFC8"
	sExtCns(8, 7, 1) = "FFFFFFE6"
	'act No72〜No79
	sExtCns(9, 0, 0) = "FFFFFFFB"
	sExtCns(9, 0, 1) = "FFFFFFC7"
	sExtCns(9, 1, 0) = "FFFFFFFB"
	sExtCns(9, 1, 1) = "FFFFFFC7"
	sExtCns(9, 2, 0) = "FFFFFFFB"
	sExtCns(9, 2, 1) = "FFFFFFC7"
	sExtCns(9, 3, 0) = "FFFFFFFB"
	sExtCns(9, 3, 1) = "FFFFFFC7"
	sExtCns(9, 4, 0) = "FFFFFFFB"
	sExtCns(9, 4, 1) = "FFFFFFC7"
	sExtCns(9, 5, 0) = "FFFFFFFB"
	sExtCns(9, 5, 1) = "FFFFFFC7"
	sExtCns(9, 6, 0) = "FFFFFFFB"
	sExtCns(9, 6, 1) = "FFFFFFC7"
	sExtCns(9, 7, 0) = "FFFFFFFB"
	sExtCns(9, 7, 1) = "FFFFFFC7"
	'act No80〜No87
	sExtCns(10, 0, 0) = "FFFFFFFB"
	sExtCns(10, 0, 1) = "FFFFFFC7"
	sExtCns(10, 1, 0) = "FFFFFFFB"
	sExtCns(10, 1, 1) = "FFFFFFC7"
	sExtCns(10, 2, 0) = "0000000E"
	sExtCns(10, 2, 1) = "FFFFFFB9"
	sExtCns(10, 3, 0) = "0000000E"
	sExtCns(10, 3, 1) = "FFFFFFB9"
	sExtCns(10, 4, 0) = "FFFFFFF3"
	sExtCns(10, 4, 1) = "FFFFFFB9"
	sExtCns(10, 5, 0) = "FFFFFFF3"
	sExtCns(10, 5, 1) = "FFFFFFB9"
	sExtCns(10, 6, 0) = "00000006"
	sExtCns(10, 6, 1) = "FFFFFFC7"
	sExtCns(10, 7, 0) = "00000006"
	sExtCns(10, 7, 1) = "FFFFFFC7"
	'act No88〜No95
	sExtCns(11, 0, 0) = "FFFFFFFB"
	sExtCns(11, 0, 1) = "FFFFFFC6"
	sExtCns(11, 1, 0) = "FFFFFFFB"
	sExtCns(11, 1, 1) = "FFFFFFC6"
	sExtCns(11, 2, 0) = "0000000D"
	sExtCns(11, 2, 1) = "FFFFFFB8"
	sExtCns(11, 3, 0) = "0000000D"
	sExtCns(11, 3, 1) = "FFFFFFB8"
	sExtCns(11, 4, 0) = "FFFFFFF4"
	sExtCns(11, 4, 1) = "FFFFFFB8"
	sExtCns(11, 5, 0) = "FFFFFFF4"
	sExtCns(11, 5, 1) = "FFFFFFB8"
	sExtCns(11, 6, 0) = "00000006"
	sExtCns(11, 6, 1) = "FFFFFFC6"
	sExtCns(11, 7, 0) = "00000006"
	sExtCns(11, 7, 1) = "FFFFFFC6"
	'act No96〜No103
	sExtCns(12, 0, 0) = "FFFFFFFA"
	sExtCns(12, 0, 1) = "FFFFFFC7"
	sExtCns(12, 1, 0) = "FFFFFFFA"
	sExtCns(12, 1, 1) = "FFFFFFC7"
	sExtCns(12, 2, 0) = "0000000F"
	sExtCns(12, 2, 1) = "FFFFFFB8"
	sExtCns(12, 3, 0) = "0000000F"
	sExtCns(12, 3, 1) = "FFFFFFB8"
	sExtCns(12, 4, 0) = "FFFFFFF2"
	sExtCns(12, 4, 1) = "FFFFFFB8"
	sExtCns(12, 5, 0) = "FFFFFFF2"
	sExtCns(12, 5, 1) = "FFFFFFB8"
	sExtCns(12, 6, 0) = "00000007"
	sExtCns(12, 6, 1) = "FFFFFFC7"
	sExtCns(12, 7, 0) = "00000007"
	sExtCns(12, 7, 1) = "FFFFFFC7"
	
	'=================================================================
	'変換前SPRファイル読み取り
	'=================================================================

	'-----------------------------------
	'変換前SPRファイルオープン
	'-----------------------------------
	sInp.Open
	sInp.LoadFromFile sInSpr

	'-----------------------------------
	'ヘッダー部
	'-----------------------------------
	'ヘッダー情報(固定値/マジック+バージョン)
	sSprHead(0, 0) = ByteReadInt(sInp)
	sSprHead(0, 1) = ByteReadInt(sInp)
	sSprHead(0, 2) = ByteReadInt(sInp)
	sSprHead(0, 3) = ByteReadInt(sInp)
	'圧縮イメージ数
	sSprHead(1, 0) = ByteReadInt(sInp)
	sSprHead(1, 1) = ByteReadInt(sInp)
	'フラットイメージ数
	sSprHead(2, 0) = ByteReadInt(sInp)
	sSprHead(2, 1) = ByteReadInt(sInp)
	
	'-----------------------------------
	'圧縮イメージ部
	'-----------------------------------
	'圧縮イメージ数
	iImgNum = sSprHead(1, 1) * 16^2 _
			+ sSprHead(1, 0)

	for iImgCnt=0 to iImgNum-1
		'幅
		sImage(iImgCnt, 0, 0) = ByteReadInt(sInp)
		sImage(iImgCnt, 0, 1) = ByteReadInt(sInp)
		'高さ
		sImage(iImgCnt, 1, 0) = ByteReadInt(sInp)
		sImage(iImgCnt, 1, 1) = ByteReadInt(sInp)
		'サイズ
		sImage(iImgCnt, 2, 0) = ByteReadInt(sInp)
		sImage(iImgCnt, 2, 1) = ByteReadInt(sInp)
		
		iImgX = sImage(iImgCnt, 0, 1) * 16^2 _
				+ sImage(iImgCnt, 0, 0)
		iImgY = sImage(iImgCnt, 1, 1) * 16^2 _
				+ sImage(iImgCnt, 1, 0)
		
		'圧縮データを展開しながら読み込む
		for iYCnt=0 to iImgY-1
			for iXCnt=0 to iImgX-1
				'1byte読み込み
				sImageData(iImgCnt, iYCnt, iXCnt) = ByteReadInt(sInp)
				
				'読み込みデータが&H00であるか
				if sImageData(iImgCnt, iYCnt, iXCnt) = 0 then
					'次の1byteの数値分だけ&H00を連続させる
					iBuf = ByteReadInt(sInp)
					for iZeroCnt=2 to iBuf
						iXCnt = iXCnt + 1
						if iXCnt > iImgX-1 then
							iXCnt = 0
							iYCnt = iYCnt + 1
						end if
						sImageData(iImgCnt, iYCnt, iXCnt) = 0
					next
				end if
			next
		next
		
	next
	
	'-----------------------------------
	'フラットイメージ部
	'-----------------------------------
	'フラットイメージ数
	iImgNum = sSprHead(2, 1) * 16^2 _
			+ sSprHead(2, 0)
	
	'圧縮イメージ数
	iCmpImgCnt = sSprHead(1, 1) * 16^2 _
			+ sSprHead(1, 0)
	
	for iImgCnt=0 to iImgNum-1
		'幅
		sImage(iImgCnt+iCmpImgCnt, 0, 0) = ByteReadInt(sInp)
		sImage(iImgCnt+iCmpImgCnt, 0, 1) = ByteReadInt(sInp)
		'高さ
		sImage(iImgCnt+iCmpImgCnt, 1, 0) = ByteReadInt(sInp)
		sImage(iImgCnt+iCmpImgCnt, 1, 1) = ByteReadInt(sInp)
		
		iImgX = sImage(iImgCnt+iCmpImgCnt, 0, 1) * 16^2 _
				+ sImage(iImgCnt+iCmpImgCnt, 0, 0)
		iImgY = sImage(iImgCnt+iCmpImgCnt, 1, 1) * 16^2 _
				+ sImage(iImgCnt+iCmpImgCnt, 1, 0)
		
		'フラットデータ読み込み
		for iYCnt=0 to iImgY-1
			for iXCnt=0 to iImgX-1
				'1byte読み込み
				sImageData(iImgCnt+iCmpImgCnt, iYCnt, iXCnt) = ByteReadInt(sInp)
			next
		next
	next

	'-----------------------------------
	'パレット部
	'-----------------------------------
	for iPalCnt=0 to 256-1
		sPallet(iPalCnt, 0) = ByteReadInt(sInp)
		sPallet(iPalCnt, 1) = ByteReadInt(sInp)
		sPallet(iPalCnt, 2) = ByteReadInt(sInp)
		sPallet(iPalCnt, 3) = ByteReadInt(sInp)
	next

	'-----------------------------------
	'変換前SPRファイルクローズ
	'-----------------------------------
	sInp.Close


	'=================================================================
	'変換前ACTファイル読み取り
	'=================================================================

	'-----------------------------------
	'変換前ACTファイルオープン
	'-----------------------------------
	sInp.Open
	sInp.LoadFromFile sInAct

	'-----------------------------------
	'ヘッダー部
	'-----------------------------------
	sInp.Position = 0
	
	'ACTバージョン
	sHeader(0, 0) = ByteReadInt(sInp)
	sHeader(0, 1) = ByteReadInt(sInp)
	'フォーマットタイプ
	sHeader(1, 0) = ByteReadInt(sInp)
	sHeader(1, 1) = ByteReadInt(sInp)
	'アニメーション数
	sHeader(2, 0) = ByteReadInt(sInp)
	sHeader(2, 1) = ByteReadInt(sInp)
	'??(Header3)
	sHeader(3, 0) = ByteReadInt(sInp)
	sHeader(3, 1) = ByteReadInt(sInp)
	'??(Header4)
	sHeader(4, 0) = ByteReadInt(sInp)
	sHeader(4, 1) = ByteReadInt(sInp)
	sHeader(4, 2) = ByteReadInt(sInp)
	sHeader(4, 3) = ByteReadInt(sInp)
	'??(Header5)
	sHeader(5, 0) = ByteReadInt(sInp)
	sHeader(5, 1) = ByteReadInt(sInp)
	sHeader(5, 2) = ByteReadInt(sInp)
	sHeader(5, 3) = ByteReadInt(sInp)
	
	'ACT数取得(アニメーション数÷向き数)
	iActNum = sHeader(2, 1) * 16^2 _
			+ sHeader(2, 0)
	iActNum = iActNum / (NUM_ORIENT+1)
	
	'フォーマットタイプ取得
	iTypeCd = Right("0" & Hex(sHeader(1, 1)), 2) _
			& Right("0" & Hex(sHeader(1, 0)), 2)
	
	'-----------------------------------
	'フレーム部
	'-----------------------------------
	'act数だけループ
	for iActCnt=0 to iActNum-1
		
		'向き数だけループ(8方向固定)
		for iOriCnt=0 to NUM_ORIENT
			
			'フレーム数
			sFrmNum(iActCnt, iOriCnt, 0) = ByteReadInt(sInp)
			sFrmNum(iActCnt, iOriCnt, 1) = ByteReadInt(sInp)
			sFrmNum(iActCnt, iOriCnt, 2) = ByteReadInt(sInp)
			sFrmNum(iActCnt, iOriCnt, 3) = ByteReadInt(sInp)

			'フレーム数
			iFrmNum = sFrmNum(iActCnt, iOriCnt, 3) * 16^6 _
					+ sFrmNum(iActCnt, iOriCnt, 2) * 16^4 _
					+ sFrmNum(iActCnt, iOriCnt, 1) * 16^2 _
					+ sFrmNum(iActCnt, iOriCnt, 0)
			
			'フレーム数だけループ
			for iFrmCnt=0 to iFrmNum-1
				
				'フレーム情報(パレット0〜7)
				for iPalCnt=0 to 7
					sFrame(iActCnt, iOriCnt, iFrmCnt, iPalCnt, 0) = ByteReadInt(sInp)
					sFrame(iActCnt, iOriCnt, iFrmCnt, iPalCnt, 1) = ByteReadInt(sInp)
					sFrame(iActCnt, iOriCnt, iFrmCnt, iPalCnt, 2) = ByteReadInt(sInp)
					sFrame(iActCnt, iOriCnt, iFrmCnt, iPalCnt, 3) = ByteReadInt(sInp)
				next

				'フレーム情報(使用スプライト数)
				sFrame(iActCnt, iOriCnt, iFrmCnt, 8, 0) = ByteReadInt(sInp)
				sFrame(iActCnt, iOriCnt, iFrmCnt, 8, 1) = ByteReadInt(sInp)
				sFrame(iActCnt, iOriCnt, iFrmCnt, 8, 2) = ByteReadInt(sInp)
				sFrame(iActCnt, iOriCnt, iFrmCnt, 8, 3) = ByteReadInt(sInp)

				'スプライト数
				iSprNum = sFrame(iActCnt, iOriCnt, iFrmCnt, 8, 3) * 16^6 _
						+ sFrame(iActCnt, iOriCnt, iFrmCnt, 8, 2) * 16^4 _
						+ sFrame(iActCnt, iOriCnt, iFrmCnt, 8, 1) * 16^2 _
						+ sFrame(iActCnt, iOriCnt, iFrmCnt, 8, 0)
				
				'スプライト情報(スプライト数だけループ)
				for iSprCnt=0 to iSprNum-1
					'スプライト情報(Xoffs)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 0, 0) = ByteReadInt(sInp)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 0, 1) = ByteReadInt(sInp)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 0, 2) = ByteReadInt(sInp)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 0, 3) = ByteReadInt(sInp)
					'スプライト情報(Yoffs)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 1, 0) = ByteReadInt(sInp)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 1, 1) = ByteReadInt(sInp)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 1, 2) = ByteReadInt(sInp)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 1, 3) = ByteReadInt(sInp)
					'スプライト情報(SprNo)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 2, 0) = ByteReadInt(sInp)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 2, 1) = ByteReadInt(sInp)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 2, 2) = ByteReadInt(sInp)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 2, 3) = ByteReadInt(sInp)
					'スプライト情報(Mirror)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 3, 0) = ByteReadInt(sInp)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 3, 1) = ByteReadInt(sInp)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 3, 2) = ByteReadInt(sInp)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 3, 3) = ByteReadInt(sInp)
					'スプライト情報(Color)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 4, 0) = ByteReadInt(sInp)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 4, 1) = ByteReadInt(sInp)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 4, 2) = ByteReadInt(sInp)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 4, 3) = ByteReadInt(sInp)
					
					'ヘッダー情報(フォーマットタイプが0x0203の場合)
					if iTypeCd = "0203" then
						'スプライト情報(XMag)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 5, 0) = ByteReadInt(sInp)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 5, 1) = ByteReadInt(sInp)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 5, 2) = ByteReadInt(sInp)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 5, 3) = ByteReadInt(sInp)
						'スプライト情報(YMag)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 6, 0) = sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 5, 0)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 6, 1) = sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 5, 1)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 6, 2) = sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 5, 2)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 6, 3) = sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 5, 3)
					'ヘッダー情報(フォーマットタイプが0x0203以外の場合)
					else
						'スプライト情報(XMag)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 5, 0) = ByteReadInt(sInp)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 5, 1) = ByteReadInt(sInp)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 5, 2) = ByteReadInt(sInp)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 5, 3) = ByteReadInt(sInp)
						'スプライト情報(YMag)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 6, 0) = ByteReadInt(sInp)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 6, 1) = ByteReadInt(sInp)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 6, 2) = ByteReadInt(sInp)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 6, 3) = ByteReadInt(sInp)
					end if
					
					'スプライト情報(Rot)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 7, 0) = ByteReadInt(sInp)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 7, 1) = ByteReadInt(sInp)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 7, 2) = ByteReadInt(sInp)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 7, 3) = ByteReadInt(sInp)
					'スプライト情報(Type)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 8, 0) = ByteReadInt(sInp)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 8, 1) = ByteReadInt(sInp)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 8, 2) = ByteReadInt(sInp)
					sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 8, 3) = ByteReadInt(sInp)
					
					'ヘッダー情報(フォーマットタイプが0x0204の場合)
					if iTypeCd = "0204" then
						'スプライトNo
						iSprNo = sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 2, 3) * 16^6 _
								+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 2, 2) * 16^4 _
								+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 2, 1) * 16^2 _
								+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 2, 0)
						'スプライト情報(SprW)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 9, 0) = sImage(iSprNo, 0, 0)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 9, 1) = sImage(iSprNo, 0, 1)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 9, 2) = 0
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 9, 3) = 0
						'スプライト情報(SprH)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 10, 0) = sImage(iSprNo, 1, 0)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 10, 1) = sImage(iSprNo, 1, 1)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 10, 2) = 0
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 10, 3) = 0
					
					'ヘッダー情報(フォーマットタイプが0x0205の場合)
					elseif iTypeCd = "0205" then
						'スプライト情報(SprW)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 9, 0) = ByteReadInt(sInp)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 9, 1) = ByteReadInt(sInp)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 9, 2) = ByteReadInt(sInp)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 9, 3) = ByteReadInt(sInp)
						'スプライト情報(SprH)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 10, 0) = ByteReadInt(sInp)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 10, 1) = ByteReadInt(sInp)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 10, 2) = ByteReadInt(sInp)
						sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 10, 3) = ByteReadInt(sInp)
						
					end if
					
				next

				'フレーム情報(効果音No)
				sFrame(iActCnt, iOriCnt, iFrmCnt, 9, 0) = ByteReadInt(sInp)
				sFrame(iActCnt, iOriCnt, iFrmCnt, 9, 1) = ByteReadInt(sInp)
				sFrame(iActCnt, iOriCnt, iFrmCnt, 9, 2) = ByteReadInt(sInp)
				sFrame(iActCnt, iOriCnt, iFrmCnt, 9, 3) = ByteReadInt(sInp)

				'フレーム情報(拡張情報数)
				sFrame(iActCnt, iOriCnt, iFrmCnt, 10, 0) = ByteReadInt(sInp)
				sFrame(iActCnt, iOriCnt, iFrmCnt, 10, 1) = ByteReadInt(sInp)
				sFrame(iActCnt, iOriCnt, iFrmCnt, 10, 2) = ByteReadInt(sInp)
				sFrame(iActCnt, iOriCnt, iFrmCnt, 10, 3) = ByteReadInt(sInp)

				'拡張情報数
				iExtNum = sFrame(iActCnt, iOriCnt, iFrmCnt, 10, 3) * 16^6 _
						+ sFrame(iActCnt, iOriCnt, iFrmCnt, 10, 2) * 16^4 _
						+ sFrame(iActCnt, iOriCnt, iFrmCnt, 10, 1) * 16^2 _
						+ sFrame(iActCnt, iOriCnt, iFrmCnt, 10, 0)
				
				'拡張情報(拡張情報数だけループ)
				for iExtCnt=0 to iExtNum-1
					'拡張情報(Ext)
					sExtent(iActCnt, iOriCnt, iFrmCnt, iExtCnt, 0, 0) = ByteReadInt(sInp)
					sExtent(iActCnt, iOriCnt, iFrmCnt, iExtCnt, 0, 1) = ByteReadInt(sInp)
					sExtent(iActCnt, iOriCnt, iFrmCnt, iExtCnt, 0, 2) = ByteReadInt(sInp)
					sExtent(iActCnt, iOriCnt, iFrmCnt, iExtCnt, 0, 3) = ByteReadInt(sInp)
					'拡張情報(ExtXoffs)
					sExtent(iActCnt, iOriCnt, iFrmCnt, iExtCnt, 1, 0) = ByteReadInt(sInp)
					sExtent(iActCnt, iOriCnt, iFrmCnt, iExtCnt, 1, 1) = ByteReadInt(sInp)
					sExtent(iActCnt, iOriCnt, iFrmCnt, iExtCnt, 1, 2) = ByteReadInt(sInp)
					sExtent(iActCnt, iOriCnt, iFrmCnt, iExtCnt, 1, 3) = ByteReadInt(sInp)
					'拡張情報(ExtYoffs)
					sExtent(iActCnt, iOriCnt, iFrmCnt, iExtCnt, 2, 0) = ByteReadInt(sInp)
					sExtent(iActCnt, iOriCnt, iFrmCnt, iExtCnt, 2, 1) = ByteReadInt(sInp)
					sExtent(iActCnt, iOriCnt, iFrmCnt, iExtCnt, 2, 2) = ByteReadInt(sInp)
					sExtent(iActCnt, iOriCnt, iFrmCnt, iExtCnt, 2, 3) = ByteReadInt(sInp)
					'拡張情報(terminate)
					sExtent(iActCnt, iOriCnt, iFrmCnt, iExtCnt, 3, 0) = ByteReadInt(sInp)
					sExtent(iActCnt, iOriCnt, iFrmCnt, iExtCnt, 3, 1) = ByteReadInt(sInp)
					sExtent(iActCnt, iOriCnt, iFrmCnt, iExtCnt, 3, 2) = ByteReadInt(sInp)
					sExtent(iActCnt, iOriCnt, iFrmCnt, iExtCnt, 3, 3) = ByteReadInt(sInp)
				next
			next

		next
		
	next
	
	'-----------------------------------
	'効果音部
	'-----------------------------------
	'効果音数
	sSndNum(0) = ByteReadInt(sInp)
	sSndNum(1) = ByteReadInt(sInp)
	sSndNum(2) = ByteReadInt(sInp)
	sSndNum(3) = ByteReadInt(sInp)

	'効果音数
	iSndNum = sSndNum(3) * 16^6 _
			+ sSndNum(2) * 16^4 _
			+ sSndNum(1) * 16^2 _
			+ sSndNum(0)
	
	'効果音ファイル名
	for iSndCnt=0 to iSndNum-1
		for iSefCnt=0 to NUM_SOUND_FILE_NAME-1
			sSound(iSndCnt, iSefCnt) = ByteReadInt(sInp)
		next
	next

	'-----------------------------------
	'アニメーション再生間隔部
	'-----------------------------------
	'act数だけループ(モンスターACTのみを考慮しているので4固定)
	for iActCnt=0 to iActNum-1
		
		'向き数だけループ(8方向固定)
		for iOriCnt=0 to NUM_ORIENT
			'アニメーション間隔
			sInterval(iActCnt, iOriCnt, 0) = ByteReadInt(sInp)
			sInterval(iActCnt, iOriCnt, 1) = ByteReadInt(sInp)
			sInterval(iActCnt, iOriCnt, 2) = ByteReadInt(sInp)
			sInterval(iActCnt, iOriCnt, 3) = ByteReadInt(sInp)
		next

	next

	'-----------------------------------
	'変換前ACTファイルクローズ
	'-----------------------------------
	sInp.Close
	
	
	'=================================================================
	'SPR変換処理
	'=================================================================
	
	'-----------------------------------
	'フレーム内イメージ合成処理
	'-----------------------------------
	
	'合成後イメージNo
	iImgSyn = 0
	
	'act00〜act04を対象とする
	for iActCnt=0 to 4
		
		'向き数だけループ(斜めは飛ばす)
		for iOriCnt=0 to NUM_ORIENT step 2
			
			'フレーム数
			iFrmNum = sFrmNum(iActCnt, iOriCnt, 3) * 16^6 _
					+ sFrmNum(iActCnt, iOriCnt, 2) * 16^4 _
					+ sFrmNum(iActCnt, iOriCnt, 1) * 16^2 _
					+ sFrmNum(iActCnt, iOriCnt, 0)
			
			'フレーム数だけループ
			for iFrmCnt=0 to iFrmNum-1
				
				'ACT-SPR対応表に新SprNoをセット
				sActSpr(iActCnt, iOriCnt, iFrmCnt, 0) = iImgSyn
				sActSpr(iActCnt, iOriCnt+1, iFrmCnt, 0) = iImgSyn
				
				'スプライト数
				iSprNum = sFrame(iActCnt, iOriCnt, iFrmCnt, 8, 3) * 16^6 _
						+ sFrame(iActCnt, iOriCnt, iFrmCnt, 8, 2) * 16^4 _
						+ sFrame(iActCnt, iOriCnt, iFrmCnt, 8, 1) * 16^2 _
						+ sFrame(iActCnt, iOriCnt, iFrmCnt, 8, 0)
				
				'合成イメージ数だけループ
				iRightMax = ""
				iLeftMax = ""
				iTopMax = ""
				iBottomMax = ""
				for iSprCnt=iSprNum-1 to 0 step -1
					
					'スプライト情報(SprNo)
					iImgNum = sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 2, 3) * 16^6 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 2, 2) * 16^4 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 2, 1) * 16^2 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 2, 0)
					
					'スプライト情報(Xoffs)
					iXofsNum = sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 0, 3) * 16^6 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 0, 2) * 16^4 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 0, 1) * 16^2 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 0, 0)
					'OxF000000000より大きければ負数なので反転させる
					if iXofsNum > 128*16^6 then
						iXofsNum = iXofsNum - (255*16^6+255*16^4+255*16^2+255) - 1
					end if
					
					'スプライト情報(Yoffs)
					iYofsNum = sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 1, 3) * 16^6 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 1, 2) * 16^4 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 1, 1) * 16^2 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 1, 0)
					'OxF000000000より大きければ負数なので反転させる
					if iYofsNum > 128*16^6 then
						iYofsNum = iYofsNum - (255*16^6+255*16^4+255*16^2+255) - 1
					end if
					
					'スプライト情報(Rot)
					iRotNum = sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 7, 3) * 16^6 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 7, 2) * 16^4 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 7, 1) * 16^2 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 7, 0)
					
					'画像幅
					iXImgNum = sImage(iImgNum, 0, 1) * 16^2 _
							+ sImage(iImgNum, 0, 0)
					
					'画像高さ
					iYImgNum = sImage(iImgNum, 1, 1) * 16^2 _
							+ sImage(iImgNum, 1, 0)
					
					'画像半径(画像中心から角までの長さ)(端数計算面倒なので+1)
					iRImgNum = IntEx(((IntEx(iXImgNum/2))^2 + (IntEx(iYImgNum/2))^2)^0.5) + 1
					
					'回転していない場合
					if iRotNum = 0 then
						'右端座標=X座標+画像幅/2
						iRight  = iXofsNum + IntEx(iXImgNum / 2)
						'左端座標=X座標-画像幅/2
						iLeft   = iXofsNum - IntEx(iXImgNum / 2)
						'上端座標=Y座標+画像高さ/2
						iTop    = iYofsNum + IntEx(iYImgNum / 2)
						'下端座標=Y座標-画像高さ/2
						iBottom = iYofsNum - IntEx(iYImgNum / 2)
					'回転している場合(角度を考慮した値を求めるのは面倒だから最大値(45度の場合)で計算)
					else
						'右端座標=X座標+画像半径
						iRight  = iXofsNum + iRImgNum
						'左端座標=X座標-画像半径
						iLeft   = iXofsNum - iRImgNum
						'上端座標=Y座標+画像半径
						iTop    = iYofsNum + iRImgNum
						'下端座標=Y座標-画像半径
						iBottom = iYofsNum - iRImgNum
					end if
					
					'最大座標＆基点座標設定
					if iRightMax = "" then
						iRightMax = iRight
					end if
					if iLeftMax = "" then
						iLeftMax = iLeft
						'sActSpr(iActCnt, iOriCnt, iFrmCnt, 1) = iXofsNum
						'sActSpr(iActCnt, iOriCnt+1, iFrmCnt, 1) = iXofsNum
					end if
					if iTopMax = "" then
						iTopMax = iTop
					end if
					if iBottomMax = "" then
						iBottomMax = iBottom
						'sActSpr(iActCnt, iOriCnt, iFrmCnt, 2) = iYofsNum
						'sActSpr(iActCnt, iOriCnt+1, iFrmCnt, 2) = iYofsNum
					end if
					
					'最大座標＆基点座標置き換え
					if iRight > iRightMax then
						'sActSpr(iActCnt, iOriCnt, iFrmCnt, 1) = sActSpr(iActCnt, iOriCnt, iFrmCnt, 1) - IntEx((iRight-iRightMax)/2)
						'sActSpr(iActCnt, iOriCnt+1, iFrmCnt, 1) = sActSpr(iActCnt, iOriCnt+1, iFrmCnt, 1) - IntEx((iRight-iRightMax)/2)
						iRightMax = iRight
					end if
					if iLeft < iLeftMax then
						'sActSpr(iActCnt, iOriCnt, iFrmCnt, 1) = sActSpr(iActCnt, iOriCnt, iFrmCnt, 1) + IntEx((iLeft-iLeftMax)/2)
						'sActSpr(iActCnt, iOriCnt+1, iFrmCnt, 1) = sActSpr(iActCnt, iOriCnt+1, iFrmCnt, 1) + IntEx((iLeft-iLeftMax)/2)
						iLeftMax = iLeft
					end if
					if iTop > iTopMax then
						'sActSpr(iActCnt, iOriCnt, iFrmCnt, 2) = sActSpr(iActCnt, iOriCnt, iFrmCnt, 2) + IntEx((iTop-iTopMax)/2)
						'sActSpr(iActCnt, iOriCnt+1, iFrmCnt, 2) = sActSpr(iActCnt, iOriCnt+1, iFrmCnt, 2) + IntEx((iTop-iTopMax)/2)
						iTopMax = iTop
					end if
					if iBottom < iBottomMax then
						'sActSpr(iActCnt, iOriCnt, iFrmCnt, 2) = sActSpr(iActCnt, iOriCnt, iFrmCnt, 2) - IntEx((iBottom-iBottomMax)/2)
						'sActSpr(iActCnt, iOriCnt+1, iFrmCnt, 2) = sActSpr(iActCnt, iOriCnt+1, iFrmCnt, 2) - IntEx((iBottom-iBottomMax)/2)
						iBottomMax = iBottom
					end if
					
				next
				
				'合成後幅=右端座標-左端座標
				iXMaxNum = iRightMax - iLeftMax + 1
				sImageSyn(iImgSyn, 0, 0) = iXMaxNum mod 256
				sImageSyn(iImgSyn, 0, 1) = IntEx(iXMaxNum / 256)
				
				'合成後高さ=上端座標-下端座標
				iYMaxNum = iTopMax - iBottomMax + 1
				sImageSyn(iImgSyn, 1, 0) = iYMaxNum mod 256
				sImageSyn(iImgSyn, 1, 1) = IntEx(iYMaxNum / 256)
				
				'合成後X軸中心座標
				iXPos = IntEx(iRightMax/2 + iLeftMax/2)
				
				'合成後Y軸中心座標
				iYPos = IntEx(iTopMax/2 + iBottomMax/2)
				
				'合成後X基点座標
				sActSpr(iActCnt, iOriCnt, iFrmCnt, 1) = iLeftMax + IntEx(iXMaxNum/2)
				sActSpr(iActCnt, iOriCnt+1, iFrmCnt, 1) = iLeftMax + IntEx(iXMaxNum/2)
				
				'合成後Y基点座標
				sActSpr(iActCnt, iOriCnt, iFrmCnt, 2) = iBottomMax + IntEx(iYMaxNum/2)
				sActSpr(iActCnt, iOriCnt+1, iFrmCnt, 2) = iBottomMax + IntEx(iYMaxNum/2)
				
				'下地作成
				for iYCnt=0 to iYMaxNum-1
					for iXCnt=0 to iXMaxNum-1
						sImageDataSyn(iImgSyn, iYCnt, iXCnt) = 0
					next
				next
				
				'優先度の低い画像から下地へ上書きしていく
				for iSprCnt=0 to iSprNum-1
					'スプライト情報(SprNo)
					iImgNum = sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 2, 3) * 16^6 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 2, 2) * 16^4 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 2, 1) * 16^2 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 2, 0)
					
					'スプライト情報(Xoffs)
					iXofsNum = sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 0, 3) * 16^6 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 0, 2) * 16^4 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 0, 1) * 16^2 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 0, 0)
					'OxF000000000より大きければ負数なので反転させる
					if iXofsNum > 128*16^6 then
						iXofsNum = iXofsNum - (255*16^6+255*16^4+255*16^2+255) - 1
					end if
					
					'スプライト情報(Yoffs)
					iYofsNum = sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 1, 3) * 16^6 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 1, 2) * 16^4 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 1, 1) * 16^2 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 1, 0)
					'OxF000000000より大きければ負数なので反転させる
					if iYofsNum > 128*16^6 then
						iYofsNum = iYofsNum - (255*16^6+255*16^4+255*16^2+255) - 1
					end if
					
					'スプライト情報(Mirror)
					iMirrNum = sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 3, 3) * 16^6 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 3, 2) * 16^4 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 3, 1) * 16^2 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 3, 0)
					
					'スプライト情報(Rot)
					iRotNum = sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 7, 3) * 16^6 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 7, 2) * 16^4 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 7, 1) * 16^2 _
							+ sSprite(iActCnt, iOriCnt, iFrmCnt, iSprCnt, 7, 0)
					
					'合成前画像幅
					iXImgNum = sImage(iImgNum, 0, 1) * 16^2 _
							+ sImage(iImgNum, 0, 0)
					
					'合成前画像高さ
					iYImgNum = sImage(iImgNum, 1, 1) * 16^2 _
							+ sImage(iImgNum, 1, 0)
					
					'ラジアン
					if iMirrNum = 1 then
						iRad = (iRotNum) * NUM_PI / 180
					else
						iRad = -1 * (iRotNum) * NUM_PI / 180
					end if
					
					'位置補正値算出(X軸)
					iXofsNum = Abs(iLeftMax - (iXofsNum - IntEx(iXImgNum/2))) + 1
					
					'位置補正値算出(Y軸)
					iYofsNum = Abs(iBottomMax - (iYofsNum - IntEx(iYImgNum/2))) + 1
					
					'貼り付け画像の末尾まで1ドットづつループ処理
					for iYCnt=0 to iYImgNum-1
						for iXCnt=0 to iXImgNum-1
							'&H00(透過指定色)でなければ下地に書き込み
							if sImageData(iImgNum, iYCnt, iXCnt) <> 0 then
								'回転後の座標を算出
								iRotX = iXImgNum - IntEx(iXImgNum/2 + cos(iRad) * (iXImgNum/2 - iXCnt) + sin(iRad) * (iYImgNum/2 - iYCnt))
								iRotY = iYImgNum - IntEx(iYImgNum/2 + (-1) * sin(iRad) * (iXImgNum/2 - iXCnt) + cos(iRad) * (iYImgNum/2 - iYCnt))
								
								'上書き位置を算出
								if iMirrNum = 0 then
									iXCntSyn = iXofsNum + iRotX
									iYCntSyn = iYofsNum + iRotY
								else
									iXCntSyn = iXofsNum + iXImgNum - iRotX
									iYCntSyn = iYofsNum + iRotY
								end if
								
								'下地へ上書き
								if iYCntSyn > 0 and iXCntSyn > 0 then
									sImageDataSyn(iImgSyn, iYCntSyn, iXCntSyn) = sImageData(iImgNum, iYCnt, iXCnt)
								end if
							end if
						next
					next
				next
				
				'画像補正(1ドット抜けを潰す)
				for iYCnt=1 to iYMaxNum-2
					for iXCnt=1 to iXMaxNum-2
						'透過色ドットを対象とする
						if sImageDataSyn(iImgSyn, iYCnt, iXCnt) = 0 then
							'上下左右ドットが透過色ではない場合
							if sImageDataSyn(iImgSyn, iYCnt, iXCnt-1) <> 0 then
							if sImageDataSyn(iImgSyn, iYCnt-1, iXCnt) <> 0 then
							if sImageDataSyn(iImgSyn, iYCnt, iXCnt+1) <> 0 then
							if sImageDataSyn(iImgSyn, iYCnt+1, iXCnt) <> 0 then
								'左ドットの色をコピーする
								sImageDataSyn(iImgSyn, iYCnt, iXCnt) = sImageDataSyn(iImgSyn, iYCnt, iXCnt-1)
							end if
							end if
							end if
							end if
						end if
					next
				next
				
				iImgSyn = iImgSyn + 1
			next
		next
	next
	
	'-----------------------------------
	'イメージ圧縮処理
	'-----------------------------------
	for iImgCnt=0 to iImgSyn-1
		'幅
		sImageCmp(iImgCnt, 0, 0) = sImageSyn(iImgCnt, 0, 0)
		sImageCmp(iImgCnt, 0, 1) = sImageSyn(iImgCnt, 0, 1)
		
		'高さ
		sImageCmp(iImgCnt, 1, 0) = sImageSyn(iImgCnt, 1, 0)
		sImageCmp(iImgCnt, 1, 1) = sImageSyn(iImgCnt, 1, 1)
		
		iXImgNum = sImageCmp(iImgCnt, 0, 1) * 16^2 _
				+ sImageCmp(iImgCnt, 0, 0)
				
		iYImgNum = sImageCmp(iImgCnt, 1, 1) * 16^2 _
				+ sImageCmp(iImgCnt, 1, 0)
		
		'圧縮データ作成
		iOutPos = 0
		iZeroCnt = 0
		for iYCnt=0 to iYImgNum-1
			for iXCnt=0 to iXImgNum-1
				if sImageDataSyn(iImgCnt, iYCnt, iXCnt) = 0 then
					'&H00カウンタを1つ増やす
					iZeroCnt = iZeroCnt + 1
					'&H00カウンタが255になったら&H00と&HFFを書き込む
					if iZeroCnt = 255 then
						sImageDataCmp(iImgCnt, iOutPos) = 0
						iOutPos = iOutPos + 1
						sImageDataCmp(iImgCnt, iOutPos) = 255
						iOutPos = iOutPos + 1
						iZeroCnt = 0
					end if
				else
					'&H00カウンタが1以上なら&H00とカウント数を書き込む
					if iZeroCnt >= 1 then
						sImageDataCmp(iImgCnt, iOutPos) = 0
						iOutPos = iOutPos + 1
						sImageDataCmp(iImgCnt, iOutPos) = iZeroCnt
						iOutPos = iOutPos + 1
						iZeroCnt = 0
					end if
					'圧縮前データをそのまま圧縮後データへ書き込む
					sImageDataCmp(iImgCnt, iOutPos) = sImageDataSyn(iImgCnt, iYCnt, iXCnt)
					
					iOutPos = iOutPos + 1
				end if
			next
		next
		
		'&H00カウンタが1以上なら&H00とカウント数を書き込む
		if iZeroCnt >= 1 then
			sImageDataCmp(iImgCnt, iOutPos) = 0
			iOutPos = iOutPos + 1
			sImageDataCmp(iImgCnt, iOutPos) = iZeroCnt
			iOutPos = iOutPos + 1
			iZeroCnt = 0
		end if
		
		'圧縮後サイズ
		sImageCmp(iImgCnt, 2, 0) = iOutPos mod 256
		sImageCmp(iImgCnt, 2, 1) = IntEx(iOutPos / 256)
	next
	
	
	'=================================================================
	'変換後SPRファイル生成
	'=================================================================
	
	'-----------------------------------
	'変換後SPRファイルオープン
	'-----------------------------------
	sOut.Open
	
	'-----------------------------------
	'ヘッダー部
	'-----------------------------------
	'ヘッダー情報(固定値/マジック+バージョン)
	sOut.Write = bStream.getByte(sSprHead(0, 0))
	sOut.Write = bStream.getByte(sSprHead(0, 1))
	sOut.Write = bStream.getByte(sSprHead(0, 2))
	sOut.Write = bStream.getByte(sSprHead(0, 3))
	'ヘッダー情報(圧縮イメージ数)
	sOut.Write = bStream.getByte(iImgSyn mod 256)
	sOut.Write = bStream.getByte(IntEx(iImgSyn / 256))
	'ヘッダー情報(フラットイメージ数)
	sOut.Write = bStream.getByte(0)
	sOut.Write = bStream.getByte(0)
	
	'-----------------------------------
	'圧縮イメージ部
	'-----------------------------------
	for iImgCnt=0 to iImgSyn-1
		'幅
		sOut.Write = bStream.getByte(sImageCmp(iImgCnt, 0, 0))
		sOut.Write = bStream.getByte(sImageCmp(iImgCnt, 0, 1))
		'高さ
		sOut.Write = bStream.getByte(sImageCmp(iImgCnt, 1, 0))
		sOut.Write = bStream.getByte(sImageCmp(iImgCnt, 1, 1))
		'圧縮後サイズ
		sOut.Write = bStream.getByte(sImageCmp(iImgCnt, 2, 0))
		sOut.Write = bStream.getByte(sImageCmp(iImgCnt, 2, 1))
		
		iImgS = sImageCmp(iImgCnt, 2, 1) * 16^2 _
				+ sImageCmp(iImgCnt, 2, 0)
		
		'圧縮データ
		for iSCnt=0 to iImgS-1
			sOut.Write = bStream.getByte(sImageDataCmp(iImgCnt, iSCnt))
		next
	next
	
	'-----------------------------------
	'フラットイメージ部
	'-----------------------------------
	'全て圧縮イメージにするのでフラットイメージは書き込まない
	
	'-----------------------------------
	'パレット部
	'-----------------------------------
	for iPalCnt=0 to 256-1
		sOut.Write = bStream.getByte(sPallet(iPalCnt, 0))
		sOut.Write = bStream.getByte(sPallet(iPalCnt, 1))
		sOut.Write = bStream.getByte(sPallet(iPalCnt, 2))
		sOut.Write = bStream.getByte(sPallet(iPalCnt, 3))
	next
	
	'-----------------------------------
	'変換後SPRファイルクローズ
	'-----------------------------------
	sOut.SaveToFile sOutSpr, adWriteOver
	sOut.Flush
	sOut.Close
	
	
	'=================================================================
	'変換後ACTファイル生成
	'=================================================================

	'-----------------------------------
	'変換後ACTファイルオープン
	'-----------------------------------
	sOut.Open

	'-----------------------------------
	'ヘッダー部
	'-----------------------------------
	'ヘッダー情報(ACTバージョン)
	sOut.Write = bStream.getByte(sHeader(0, 0))
	sOut.Write = bStream.getByte(sHeader(0, 1))
	'ヘッダー情報(フォーマットタイプ)
	sOut.Write = bStream.getByte(4)				'固定(0x0204)
	sOut.Write = bStream.getByte(2)				'固定(0x0204)
	'ヘッダー情報(アニメーション数)
	sOut.Write = bStream.getByte(104)			'固定(13act * 8方向 = 104)
	sOut.Write = bStream.getByte(0)				'固定(13act * 8方向 = 104)
	'ヘッダー情報(??)
	sOut.Write = bStream.getByte(sHeader(3, 0))
	sOut.Write = bStream.getByte(sHeader(3, 1))
	'ヘッダー情報(??)
	sOut.Write = bStream.getByte(sHeader(4, 0))
	sOut.Write = bStream.getByte(sHeader(4, 1))
	sOut.Write = bStream.getByte(sHeader(4, 2))
	sOut.Write = bStream.getByte(sHeader(4, 3))
	'ヘッダー情報(??)
	sOut.Write = bStream.getByte(sHeader(5, 0))
	sOut.Write = bStream.getByte(sHeader(5, 1))
	sOut.Write = bStream.getByte(sHeader(5, 2))
	sOut.Write = bStream.getByte(sHeader(5, 3))
	
	'-----------------------------------
	'フレーム部
	'-----------------------------------
	'act00〜act12を生成する
	for iPlayActCnt=0 to NUM_ACT_PLAYER
		
		'向き数だけループ(8方向固定)
		for iOriCnt=0 to NUM_ORIENT
			
			Select Case iPlayActCnt
				'act00(立ち/固定)、act02(座り)、act03(拾い)、act09(立ち/正面)、act12(スキル2)
				Case 0, 2, 3, 9, 12
					'コピー元データとして変換前act00(立ち)を指定
					iActCnt=0
					
					'フレーム数
					sOut.Write = bStream.getByte(3)
					sOut.Write = bStream.getByte(0)
					sOut.Write = bStream.getByte(0)
					sOut.Write = bStream.getByte(0)
					
					'フレーム数
					iFrmNum = 3
				
				'act01(移動)
				Case 1
					'コピー元データとして変換前act01(移動)を指定
					iActCnt=1
					
					'フレーム数
					sOut.Write = bStream.getByte(sFrmNum(iActCnt, iOriCnt, 0))
					sOut.Write = bStream.getByte(sFrmNum(iActCnt, iOriCnt, 1))
					sOut.Write = bStream.getByte(sFrmNum(iActCnt, iOriCnt, 2))
					sOut.Write = bStream.getByte(sFrmNum(iActCnt, iOriCnt, 3))
					
					'フレーム数
					iFrmNum = sFrmNum(iActCnt, iOriCnt, 3) * 16^6 _
							+ sFrmNum(iActCnt, iOriCnt, 2) * 16^4 _
							+ sFrmNum(iActCnt, iOriCnt, 1) * 16^2 _
							+ sFrmNum(iActCnt, iOriCnt, 0)
				
				'act04(立ち/アニメ)
				Case 4
					'コピー元データとして変換前act00(立ち)を指定
					iActCnt=0
					
					'フレーム数
					sOut.Write = bStream.getByte(sFrmNum(iActCnt, iOriCnt, 0))
					sOut.Write = bStream.getByte(sFrmNum(iActCnt, iOriCnt, 1))
					sOut.Write = bStream.getByte(sFrmNum(iActCnt, iOriCnt, 2))
					sOut.Write = bStream.getByte(sFrmNum(iActCnt, iOriCnt, 3))
					
					'フレーム数
					iFrmNum = sFrmNum(iActCnt, iOriCnt, 3) * 16^6 _
							+ sFrmNum(iActCnt, iOriCnt, 2) * 16^4 _
							+ sFrmNum(iActCnt, iOriCnt, 1) * 16^2 _
							+ sFrmNum(iActCnt, iOriCnt, 0)
				
				'act05(スキル3)、act10(攻撃)、act11(スキル1)
				Case 5, 10, 11
					'コピー元データとして変換前act02(攻撃)を指定
					iActCnt=2
					
					'フレーム数
					sOut.Write = bStream.getByte(sFrmNum(iActCnt, iOriCnt, 0))
					sOut.Write = bStream.getByte(sFrmNum(iActCnt, iOriCnt, 1))
					sOut.Write = bStream.getByte(sFrmNum(iActCnt, iOriCnt, 2))
					sOut.Write = bStream.getByte(sFrmNum(iActCnt, iOriCnt, 3))
					
					'フレーム数
					iFrmNum = sFrmNum(iActCnt, iOriCnt, 3) * 16^6 _
							+ sFrmNum(iActCnt, iOriCnt, 2) * 16^4 _
							+ sFrmNum(iActCnt, iOriCnt, 1) * 16^2 _
							+ sFrmNum(iActCnt, iOriCnt, 0)
				
				'act06(ダメージ/アニメ)
				Case 6
					'コピー元データとして変換前act03(ダメージ)を指定
					iActCnt=3
					
					'フレーム数
					sOut.Write = bStream.getByte(sFrmNum(iActCnt, iOriCnt, 0))
					sOut.Write = bStream.getByte(sFrmNum(iActCnt, iOriCnt, 1))
					sOut.Write = bStream.getByte(sFrmNum(iActCnt, iOriCnt, 2))
					sOut.Write = bStream.getByte(sFrmNum(iActCnt, iOriCnt, 3))
					
					'フレーム数
					iFrmNum = sFrmNum(iActCnt, iOriCnt, 3) * 16^6 _
							+ sFrmNum(iActCnt, iOriCnt, 2) * 16^4 _
							+ sFrmNum(iActCnt, iOriCnt, 1) * 16^2 _
							+ sFrmNum(iActCnt, iOriCnt, 0)
				
				'act07(ダメージ/固定)
				Case 7
					'コピー元データとして変換前act03(ダメージ)を指定
					iActCnt=3
					
					'フレーム数
					sOut.Write = bStream.getByte(1)
					sOut.Write = bStream.getByte(0)
					sOut.Write = bStream.getByte(0)
					sOut.Write = bStream.getByte(0)
					
					'フレーム数
					iFrmNum = 1
					
				'act08(ダウン/固定)
				Case 8
					'※特殊 : モンスターのダウンアニメーションの最後の1フレームを使用する
					
					'コピー元データとして変換前act04(ダウン)を指定
					iActCnt=4
					
					'フレーム数
					sOut.Write = bStream.getByte(1)
					sOut.Write = bStream.getByte(0)
					sOut.Write = bStream.getByte(0)
					sOut.Write = bStream.getByte(0)
					
					'フレーム数
					iFrmNum = 1
				
			End Select
			
			'フレーム数だけループ
			for iFrmCnt=0 to iFrmNum-1
				
				'※特殊条件
				'※act00などは規定フレーム必要な為、最初の1フレームを規定数だけ使いまわすよう
				'※使用フレームを0固定にする
				if iPlayActCnt = 0 then
					iFrmCntExt = 0
				'※act08(ダウン)はモンスターのダウンアニメーションの最後の1フレームを使用する為
				'※フレームカウンタを最終フレームの値にする
				elseif iPlayActCnt = 8 then
					iFrmCnt = sFrmNum(iActCnt, iOriCnt, 3) * 16^6 _
							+ sFrmNum(iActCnt, iOriCnt, 2) * 16^4 _
							+ sFrmNum(iActCnt, iOriCnt, 1) * 16^2 _
							+ sFrmNum(iActCnt, iOriCnt, 0) _
							- 1
					iFrmCntExt = iFrmCnt
				else
					iFrmCntExt = iFrmCnt
				end if
				
				'フレーム情報(パレット0〜7)
				for iPalCnt=0 to 7
					sOut.Write = bStream.getByte(sFrame(iActCnt, iOriCnt, iFrmCntExt, iPalCnt, 0))
					sOut.Write = bStream.getByte(sFrame(iActCnt, iOriCnt, iFrmCntExt, iPalCnt, 1))
					sOut.Write = bStream.getByte(sFrame(iActCnt, iOriCnt, iFrmCntExt, iPalCnt, 2))
					sOut.Write = bStream.getByte(sFrame(iActCnt, iOriCnt, iFrmCntExt, iPalCnt, 3))
				next
				
				'フレーム情報(使用スプライト数)(SprNo=-1と変換後Spr1枚の計2枚)
				iSprNum = 2
				sOut.Write = bStream.getByte(2)
				sOut.Write = bStream.getByte(0)
				sOut.Write = bStream.getByte(0)
				sOut.Write = bStream.getByte(0)
				
				'スプライト情報(スプライト数だけループ)
				for iSprCnt=0 to iSprNum-1
					
					'※特殊条件
					'SprNoが-1のデータを作る
					if iSprCnt = 0 then
						iSprCntExt = 0
					else
						iSprCntExt = iSprCnt -1
					end if
					
					'スプライト情報(Xoffs)
					iXofsVal = sActSpr(iActCnt, iOriCnt, iFrmCntExt, 1)
					'10進数から16進数へ変換(Hexがオーバーフローを起こすので分割する)
					iXofsValTop = IntEx(iXofsVal / 16^4)
					iXofsValBtm = iXofsVal - iXofsValTop * 16^4
					if iXofsVal >= 0 then
						sXofsValTop = Right("0000" & Hex(iXofsValTop),4)
						sXofsValBtm = Right("0000" & Hex(iXofsValBtm),4)
					else
						if iXofsValTop = 0 then
							sXofsValTop = "FFFF"
						else
							sXofsValTop = Right("FFFF" & Hex(iXofsValTop),4)
						end if
						sXofsValBtm = Right("FFFF" & Hex(iXofsValBtm),4)
					end if
					sOut.Write = bStream.getByte(CInt("&H0" & Mid(sXofsValBtm, 3, 2)))
					sOut.Write = bStream.getByte(CInt("&H0" & Mid(sXofsValBtm, 1, 2)))
					sOut.Write = bStream.getByte(CInt("&H0" & Mid(sXofsValTop, 3, 2)))
					sOut.Write = bStream.getByte(CInt("&H0" & Mid(sXofsValTop, 1, 2)))
					
					'スプライト情報(Yoffs)
					iYofsVal = sActSpr(iActCnt, iOriCnt, iFrmCntExt, 2)
					'地面に下ろす為にYoffsに補正を入れる
					iYofsVal = iYofsVal + NUM_YOFS_PULS
					'10進数から16進数へ変換(Hexがオーバーフローを起こすので分割する)
					iYofsValTop = IntEx(iYofsVal / 16^4)
					iYofsValBtm = iYofsVal - iYofsValTop * 16^4
					if iYofsVal >= 0 then
						sYofsValTop = Right("0000" & Hex(iYofsValTop),4)
						sYofsValBtm = Right("0000" & Hex(iYofsValBtm),4)
					else
						if iYofsValTop = 0 then
							sYofsValTop = "FFFF"
						else
							sYofsValTop = Right("FFFF" & Hex(iYofsValTop),4)
						end if
						sYofsValBtm = Right("FFFF" & Hex(iYofsValBtm),4)
					end if
					sOut.Write = bStream.getByte(CInt("&H0" & Mid(sYofsValBtm, 3, 2)))
					sOut.Write = bStream.getByte(CInt("&H0" & Mid(sYofsValBtm, 1, 2)))
					sOut.Write = bStream.getByte(CInt("&H0" & Mid(sYofsValTop, 3, 2)))
					sOut.Write = bStream.getByte(CInt("&H0" & Mid(sYofsValTop, 1, 2)))
					
					'スプライト情報(SprNo)
					if iSprCnt = 0 then
						sOut.Write = bStream.getByte(255)
						sOut.Write = bStream.getByte(255)
						sOut.Write = bStream.getByte(255)
						sOut.Write = bStream.getByte(255)
					else
						'変換後SprNoを算出
						iSprSyn = sActSpr(iActCnt, iOriCnt, iFrmCntExt, 0)
						sOut.Write = bStream.getByte(iSprSyn mod 256)
						sOut.Write = bStream.getByte(IntEx(iSprSyn / 256))
						sOut.Write = bStream.getByte(0)
						sOut.Write = bStream.getByte(0)
					end if
					
					'スプライト情報(Mirror)
					sOut.Write = bStream.getByte(0)
					sOut.Write = bStream.getByte(0)
					sOut.Write = bStream.getByte(0)
					sOut.Write = bStream.getByte(0)
					'スプライト情報(Color)
					sOut.Write = bStream.getByte(255)
					sOut.Write = bStream.getByte(255)
					sOut.Write = bStream.getByte(255)
					sOut.Write = bStream.getByte(255)
					'スプライト情報(XMag)
					sOut.Write = bStream.getByte(0)
					sOut.Write = bStream.getByte(0)
					sOut.Write = bStream.getByte(128)
					sOut.Write = bStream.getByte(63)
					'スプライト情報(YMag)
					sOut.Write = bStream.getByte(0)
					sOut.Write = bStream.getByte(0)
					sOut.Write = bStream.getByte(128)
					sOut.Write = bStream.getByte(63)
					'スプライト情報(Rot)
					sOut.Write = bStream.getByte(0)
					sOut.Write = bStream.getByte(0)
					sOut.Write = bStream.getByte(0)
					sOut.Write = bStream.getByte(0)
					'スプライト情報(Type)
					sOut.Write = bStream.getByte(sSprite(iActCnt, iOriCnt, iFrmCntExt, iSprCntExt, 8, 0))
					sOut.Write = bStream.getByte(sSprite(iActCnt, iOriCnt, iFrmCntExt, iSprCntExt, 8, 1))
					sOut.Write = bStream.getByte(sSprite(iActCnt, iOriCnt, iFrmCntExt, iSprCntExt, 8, 2))
					sOut.Write = bStream.getByte(sSprite(iActCnt, iOriCnt, iFrmCntExt, iSprCntExt, 8, 3))
					
				next
				
				'フレーム情報(効果音No)(効果音無しとするのでFFFFFFFF固定)
				sOut.Write = bStream.getByte(255)
				sOut.Write = bStream.getByte(255)
				sOut.Write = bStream.getByte(255)
				sOut.Write = bStream.getByte(255)
				
				'フレーム情報(拡張情報数)
				sOut.Write = bStream.getByte(1)
				sOut.Write = bStream.getByte(0)
				sOut.Write = bStream.getByte(0)
				sOut.Write = bStream.getByte(0)
				'拡張情報(Ext)(0x0045FA48固定?)
				sOut.Write = bStream.getByte(72)
				sOut.Write = bStream.getByte(250)
				sOut.Write = bStream.getByte(69)
				sOut.Write = bStream.getByte(0)
				'拡張情報(ExtXoffs)
				sOut.Write = bStream.getByte(CInt("&H0" & Mid(sExtCns(iPlayActCnt, iOriCnt, 0), 7, 2)))
				sOut.Write = bStream.getByte(CInt("&H0" & Mid(sExtCns(iPlayActCnt, iOriCnt, 0), 5, 2)))
				sOut.Write = bStream.getByte(CInt("&H0" & Mid(sExtCns(iPlayActCnt, iOriCnt, 0), 3, 2)))
				sOut.Write = bStream.getByte(CInt("&H0" & Mid(sExtCns(iPlayActCnt, iOriCnt, 0), 1, 2)))
				'拡張情報(ExtYoffs)
				sOut.Write = bStream.getByte(CInt("&H0" & Mid(sExtCns(iPlayActCnt, iOriCnt, 1), 7, 2)))
				sOut.Write = bStream.getByte(CInt("&H0" & Mid(sExtCns(iPlayActCnt, iOriCnt, 1), 5, 2)))
				sOut.Write = bStream.getByte(CInt("&H0" & Mid(sExtCns(iPlayActCnt, iOriCnt, 1), 3, 2)))
				sOut.Write = bStream.getByte(CInt("&H0" & Mid(sExtCns(iPlayActCnt, iOriCnt, 1), 1, 2)))
				'拡張情報(terminate)
				sOut.Write = bStream.getByte(0)
				sOut.Write = bStream.getByte(0)
				sOut.Write = bStream.getByte(0)
				sOut.Write = bStream.getByte(0)
				
			next
			
		next
		
	next

	'-----------------------------------
	'効果音部
	'-----------------------------------
	'効果音数
	sOut.Write = bStream.getByte(sSndNum(0))
	sOut.Write = bStream.getByte(sSndNum(1))
	sOut.Write = bStream.getByte(sSndNum(2))
	sOut.Write = bStream.getByte(sSndNum(3))

	'効果音数
	iSndNum = sSndNum(3) * 16^6 _
			+ sSndNum(2) * 16^4 _
			+ sSndNum(1) * 16^2 _
			+ sSndNum(0)

	'効果音ファイル名
	for iSndCnt=0 to iSndNum-1
		for iSefCnt=0 to NUM_SOUND_FILE_NAME-1
			sOut.Write = bStream.getByte(sSound(iSndCnt, iSefCnt))
		next
	next

	'-----------------------------------
	'アニメーション再生間隔部
	'-----------------------------------
	'act00〜act12を生成する
	for iPlayActCnt=0 to NUM_ACT_PLAYER

		Select Case iPlayActCnt
			'act00(立ち/固定)、act02(座り)、act03(拾い)、act09(立ち/正面)、act12(スキル2)
			Case 0, 2, 3, 9, 12
				'コピー元データとして変換前act00(立ち)を指定
				iActCnt=0
				
			'act01(移動)
			Case 1
				'コピー元データとして変換前act01(移動)を指定
				iActCnt=1

			'act04(立ち/アニメ)
			Case 4
				'コピー元データとして変換前act00(立ち)を指定
				iActCnt=0
				
			'act05(スキル3)、act10(攻撃)、act11(スキル1)
			Case 5, 10, 11
				'コピー元データとして変換前act02(攻撃)を指定
				iActCnt=2
				
			'act06(ダメージ/アニメ)
			Case 6
				'コピー元データとして変換前act03(ダメージ)を指定
				iActCnt=3
				
			'act07(ダメージ/固定)
			Case 7
				'コピー元データとして変換前act03(ダメージ)を指定
				iActCnt=3
				
			'act08(ダウン/固定)
			Case 8
				'コピー元データとして変換前act04(ダウン)を指定
				iActCnt=4
		End Select
		
		'向き数だけループ
		for iOriCnt=0 to NUM_ORIENT
			'アニメーション間隔
			sOut.Write = bStream.getByte(sInterval(iActCnt, iOriCnt, 0))
			sOut.Write = bStream.getByte(sInterval(iActCnt, iOriCnt, 1))
			sOut.Write = bStream.getByte(sInterval(iActCnt, iOriCnt, 2))
			sOut.Write = bStream.getByte(sInterval(iActCnt, iOriCnt, 3))
		next
	next
	
	'-----------------------------------
	'変換後ACTファイルクローズ
	'-----------------------------------
	sOut.SaveToFile sOutAct, adWriteOver
	sOut.Flush
	sOut.Close
	
	'エラー無視設定
	if FLG_ERROR_SKIP = 1 then
		On Error Goto 0
	end if
	
End Function

'*********************************************************************
' IntExファンクション
'*********************************************************************
Function IntEx(iTmp)
	if iTmp >= 0 then
		IntEx = Int(iTmp)
	else
		IntEx = Int(iTmp * (-1)) * (-1)
	end if
End Function

''*********************************************************************
'' ByteReadファンクション
''*********************************************************************
'Function ByteRead(sTmp)
'	Dim str
'	str = Hex(AscB(sTmp.Read(1)))
'	if Len(str) = 2 then
'		ByteRead = str
'	else
'		ByteRead = "0" & str
'	end if
'End Function

'*********************************************************************
' ByteReadIntファンクション
'*********************************************************************
Function ByteReadInt(sTmp)
	ByteReadInt = AscB(sTmp.Read(1))
End Function

'*********************************************************************
' ByteStreamクラス(ネットからの拾いもの)
'*********************************************************************
Class ByteStream
	Private innerArray(255)
	'=================================================================
	' クラスの初期化処理
	'=================================================================
	Private Sub Class_Initialize()

		Dim wkStream
		Set wkStream = WScript.CreateObject("ADODB.Stream")
		wkStream.Type = adTypeText
		wkStream.Charset = ENCODE_UNICODE
		wkStream.Open

		Dim i
		For i=0 To &hff
			wkStream.WriteText ChrW(i)
		Next
		wkStream.Position = 0
		wkStream.Type = adTypeBinary

		If ("fe" = LCase(Hex(AscB(wkStream.Read(1))))) Then
			wkStream.Position = 2
		End If

		For i=0 To &hff
			wkStream.Position = wkStream.Position + 1
			innerArray(i) = wkStream.Read(1)
		Next

		wkStream.Close
		Set wkStream = Nothing
	End Sub
	'=================================================================
	' 指定した数値のByte()を返す
	'=================================================================
	Public Function getByte(num)
		If (num < 0) Or (UBound(innerArray) < num) Then
			getByte = innerArray(0) '0x00を返す
		Else
			getByte = innerArray(num)
		End If
	End Function
End Class