public static void TypeDescListGetterTest()
{
var instance = new DatabaseMergedData();
var changedPropertyList = new List <string>();
instance.PropertyChanged += (sender, args) => { changedPropertyList.Add(args.PropertyName); };
var errorOccured = false;
try
{
var _ = instance.TypeDescList;
}
catch (Exception ex)
{
logger.Exception(ex);
errorOccured = true;
}
// エラーが発生しないこと
Assert.IsFalse(errorOccured);
// プロパティ変更通知が発火していないこと
Assert.AreEqual(changedPropertyList.Count, 0);
}
// _/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
// Public Method
// _/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
/// <summary>
/// ファイルを同期的に読み込む
/// </summary>
/// <returns>読み込んだデータ</returns>
/// <exception cref="InvalidOperationException">
/// すでにファイルを読み込んでいる場合、
/// またはファイルが正しく読み込めなかった場合
/// </exception>
public DatabaseMergedData ReadSync()
{
lock (readLock)
{
Logger.Info(FileIOMessage.StartFileRead(GetType()));
if (!(Data is null))
{
throw new InvalidOperationException(
$"すでに読み込み完了しています。");
}
var datFileReader = new DatabaseDatFileReader(DatFilePath, DbKind);
var dataSettingList = datFileReader.ReadSync().SettingList;
var projectFile = new DatabaseProjectFileReader(ProjectFilePath, DbKind);
var typeSettingList = projectFile.ReadSync().TypeSettingList;
Data = new DatabaseMergedData(typeSettingList, dataSettingList);
Logger.Info(FileIOMessage.EndFileRead(GetType()));
return(Data);
}
}
public static void WriteSyncTest(DatabaseMergedData outputDat, DBKind dbKind)
{
DatabaseMergedDataWriter writer = null;
if (dbKind == DBKind.User)
{
var datFilePath =
(ChangeableDatabaseDatFilePath)
$@"{DatabaseMergedDataTestItemGenerator.TestWorkRootDir}\DatabaseMergedDataWriterTest\CDatabase.dat";
var projectFilePath =
(ChangeableDatabaseProjectFilePath)
$@"{DatabaseMergedDataTestItemGenerator.TestWorkRootDir}\DatabaseMergedDataWriterTest\CDatabase.project";
writer = new DatabaseMergedDataWriter(outputDat, datFilePath, projectFilePath);
}
else if (dbKind == DBKind.System)
{
var datFilePath =
(ChangeableDatabaseDatFilePath)
$@"{DatabaseMergedDataTestItemGenerator.TestWorkRootDir}\DatabaseMergedDataWriterTest\SysDatabase.dat";
var projectFilePath =
(ChangeableDatabaseProjectFilePath)
$@"{DatabaseMergedDataTestItemGenerator.TestWorkRootDir}\DatabaseMergedDataWriterTest\SysDatabase.project";
writer = new DatabaseMergedDataWriter(outputDat, datFilePath, projectFilePath);
}
else if (dbKind == DBKind.Changeable)
{
var datFilePath =
(ChangeableDatabaseDatFilePath)
$@"{DatabaseMergedDataTestItemGenerator.TestWorkRootDir}\DatabaseMergedDataWriterTest\CDatabase.dat";
var projectFilePath =
(ChangeableDatabaseProjectFilePath)
$@"{DatabaseMergedDataTestItemGenerator.TestWorkRootDir}\DatabaseMergedDataWriterTest\CDatabase.project";
writer = new DatabaseMergedDataWriter(outputDat, datFilePath, projectFilePath);
}
Assert.NotNull(writer);
var isSuccess = false;
var errorMessage = "";
try
{
writer.WriteSync();
isSuccess = true;
}
catch (Exception e)
{
errorMessage = e.Message;
}
// 出力成功すること
if (!isSuccess)
{
throw new InvalidOperationException(
$"Error message: {errorMessage}");
}
Assert.True(true);
}
async Task <DatabaseMergedData> ReadSystemDB()
{
string datPath = dataPath + "BasicData/SysDataBase.dat";
string projectPath = dataPath + "BasicData/SysDataBase.project";
var dbReader = new DatabaseMergedDataReader();
DatabaseMergedData data = await dbReader.ReadFilesAsync(datPath, projectPath);
return(data);
}
async Task <DatabaseMergedData> ReadDB(string dataPath, string dbName)
{
string datPath = $"{dataPath}BasicData/{dbName}.dat";
string projectPath = $"{dataPath}BasicData/{dbName}.project";
var dbReader = new DatabaseMergedDataReader();
DatabaseMergedData data = await dbReader.ReadFilesAsync(datPath, projectPath);
return(data);
}
public static void ConstructorATest()
{
var errorOccured = false;
try
{
var _ = new DatabaseMergedData();
}
catch (Exception ex)
{
logger.Exception(ex);
errorOccured = true;
}
// エラーが発生しないこと
Assert.IsFalse(errorOccured);
}
/// <summary>
/// コンストラクタ（DatFilePath, ProjectFilePathから生成するコンストラクタの統合版）
/// </summary>
/// <param name="outputData">書き出しデータ</param>
/// <param name="datFilePath">データファイルパス</param>
/// <param name="projectFilePath">プロジェクトファイルパス</param>
/// <exception cref="ArgumentNullException">
/// outputData, datFilePath, projectFilePath が null の場合
/// </exception>
private DatabaseMergedDataWriter(DatabaseMergedData outputData, DatabaseDatFilePath datFilePath,
DatabaseProjectFilePath projectFilePath)
{
if (datFilePath is null)
{
throw new ArgumentNullException(
ErrorMessage.NotNull(nameof(datFilePath)));
}
if (projectFilePath is null)
{
throw new ArgumentNullException(
ErrorMessage.NotNull(nameof(projectFilePath)));
}
Data = outputData;
DatFilePath = datFilePath;
ProjectFilePath = projectFilePath;
}
public static void ConstructorCTest(int typeSettingListLength, int dataSettingListLength,
bool isError)
{
var typeSettingList = CreateTypeSettingList(typeSettingListLength);
var dataSettingList = CreateDataSettingList(dataSettingListLength);
var errorOccured = false;
try
{
var _ = new DatabaseMergedData(typeSettingList, dataSettingList);
}
catch (Exception ex)
{
logger.Exception(ex);
errorOccured = true;
}
// エラーフラグが一致すること
Assert.AreEqual(errorOccured, isError);
}
public static void ConstructorBTest(int typeSettingListLength, int dataSettingListLength,
bool isError)
{
var typeSettingList = CreateTypeSettingList(typeSettingListLength);
DatabaseProject project = null;
if (typeSettingList != null)
{
project = new DatabaseProject
{
TypeSettingList = typeSettingList
};
}
var dataSettingList = CreateDataSettingList(dataSettingListLength);
DatabaseDat dat = null;
if (dataSettingList != null)
{
dat = new DatabaseDat
{
SettingList = dataSettingList
};
}
var errorOccured = false;
try
{
var _ = new DatabaseMergedData(dat, project);
}
catch (Exception ex)
{
logger.Exception(ex);
errorOccured = true;
}
// エラーフラグが一致すること
Assert.AreEqual(errorOccured, isError);
}
public static void GenerateDatabaseDatTest(int listLength, DBKind dbKind)
{
var typeSettingList = CreateTypeSettingList(listLength);
var dataSettingList = CreateDataSettingList(listLength);
var instance = new DatabaseMergedData(typeSettingList, dataSettingList);
var changedPropertyList = new List <string>();
instance.PropertyChanged += (sender, args) => { changedPropertyList.Add(args.PropertyName); };
DatabaseDat result = null;
var errorOccured = false;
try
{
result = instance.GenerateDatabaseDat(dbKind);
}
catch (Exception ex)
{
logger.Exception(ex);
errorOccured = true;
}
// エラーが発生しないこと
Assert.IsFalse(errorOccured);
// データ数が正しいこと
Assert.AreEqual(result.SettingList.Count, listLength);
// DB種別が一致すること
Assert.AreEqual(result.DBKind, dbKind);
for (var i = 0; i < listLength; i++)
{
// 内容が一致すること
Assert.AreEqual(result.SettingList[i].TypeId, dataSettingList[i].TypeId);
}
// プロパティ変更通知が発火していないこと
Assert.AreEqual(changedPropertyList.Count, 0);
}
// _/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
// Constructor
// _/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="commonEventList">[NotNull] イベントコマンドリスト</param>
/// <param name="changeableDatabase">[NotNull] 可変DB</param>
/// <param name="userDatabase">[NotNull] ユーザDB</param>
/// <param name="systemDatabase">[NotNull] システムDB</param>
/// <param name="mapData">[Nullable] マップデータ</param>
public EventCommandSentenceResolver(CommonEventList commonEventList,
DatabaseMergedData changeableDatabase,
DatabaseMergedData userDatabase, DatabaseMergedData systemDatabase,
MapData mapData)
{
CommonEventList = commonEventList ??
throw new ArgumentNullException(ErrorMessage.NotNull(nameof(commonEventList)));
ChangeableDatabase = changeableDatabase ??
throw new ArgumentNullException(ErrorMessage.NotNull(nameof(changeableDatabase)));
UserDatabase = userDatabase ??
throw new ArgumentNullException(ErrorMessage.NotNull(nameof(userDatabase)));
SystemDatabase = systemDatabase ??
throw new ArgumentNullException(ErrorMessage.NotNull(nameof(systemDatabase)));
MapData = mapData;
CommonEvent = new EventCommandSentenceResolver_CommonEvent(this);
DatabaseBasic = new EventCommandSentenceResolver_Database_Basic(this);
DatabaseSpecial = new EventCommandSentenceResolver_Database_Special(this);
MapEvent = new EventCommandSentenceResolver_MapEvent(this);
Variable = new EventCommandSentenceResolver_Variable(this);
VariableAddress = new EventCommandSentenceResolver_VariableAddress(this);
}
public static void SerializeTest()
{
var target = new DatabaseMergedData
{
TypeDescList =
{
new DatabaseTypeDesc
{
Memo = "Memo"
}
}
};
var changedPropertyList = new List <string>();
target.PropertyChanged += (sender, args) => { changedPropertyList.Add(args.PropertyName); };
var clone = DeepCloner.DeepClone(target);
Assert.IsTrue(clone.Equals(target));
// プロパティ変更通知が発火していないこと
Assert.AreEqual(changedPropertyList.Count, 0);
}
public static void GenerateDBTypeTest(int listLength, TypeId typeId,
bool isError)
{
var typeSettingList = CreateTypeSettingList(listLength);
var dataSettingList = CreateDataSettingList(listLength);
var instance = new DatabaseMergedData(typeSettingList, dataSettingList);
var changedPropertyList = new List <string>();
instance.PropertyChanged += (sender, args) => { changedPropertyList.Add(args.PropertyName); };
DBType result = null;
var errorOccured = false;
try
{
result = instance.GenerateDBType(typeId);
}
catch (Exception ex)
{
logger.Exception(ex);
errorOccured = true;
}
// エラーフラグが一致すること
Assert.AreEqual(errorOccured, isError);
if (!errorOccured)
{
// データが正しいこと
Assert.NotNull(result);
Assert.AreEqual(result.TypeName, typeSettingList[typeId].TypeName);
}
// プロパティ変更通知が発火していないこと
Assert.AreEqual(changedPropertyList.Count, 0);
}
public void SetUserDB(int typeID, int dataID, int itemID, int value)
{
DatabaseMergedData db = CoreData.Instance.userDB;
db.GetDataDescList(typeID)[dataID].ItemValueList[itemID] = new DBItemValue(value);
}
async void RenderMap()
{
DatabaseMergedData systemDB = await ReadSystemDB();
var mapDataList = systemDB.GetDataDescList(0);
if (mapNo >= mapDataList.Count)
{
return;
}
string mapPath = dataPath + mapDataList[mapNo].ItemValueList[0].StringValue.ToString();
var mpsReader = new MpsFileReader();
MapData mapData = await mpsReader.ReadFileAsync(mapPath);
string tileSetPath = dataPath + "BasicData/TileSetData.dat";
var reader = new TileSetDataFileReader();
TileSetData setData = await reader.ReadFileAsync(tileSetPath);
TileSetSetting tileSetting = setData.TileSetSettingList[mapData.TileSetId];
ReadBaseTileTexture(tileSetting.BaseTileSetFileName);
ReadAutoTileTextures(tileSetting.AutoTileFileNameList.ToArray());
Texture2D mapTexture
= new Texture2D(mapData.MapSizeWidth * chipSize, mapData.MapSizeHeight * chipSize);
for (int i = 0; i < mapData.MapSizeHeight; i++)
{
for (int j = 0; j < mapData.MapSizeWidth; j++)
{
for (int k = 0; k < 3; k++)
{
int id = mapData.GetLayer(k).Chips[j][i];
if (mapData.GetLayer(k).Chips[j][i].IsAutoTile)
{
RenderAutoTile(mapTexture, j, i, id);
}
else
{
RenderNormalTile(mapTexture, j, i, id);
}
}
}
}
for (int i = 0; i < mapData.MapEvents.Count; i++)
{
int x = mapData.MapEvents[i].Position.X;
int y = mapData.MapEvents[i].Position.Y;
MapEventPage mapEventPage = mapData.MapEvents[i].MapEventPageList[0];
if (mapEventPage.GraphicInfo.IsGraphicTileChip)
{
int tileId = mapEventPage.GraphicInfo.GraphicTileId;
RenderNormalTile(mapTexture, x, y, tileId);
}
else if (!string.IsNullOrEmpty(mapEventPage.GraphicInfo.CharaChipFilePath))
{
string graphicPath = dataPath + mapEventPage.GraphicInfo.CharaChipFilePath;
Debug.Log(graphicPath);
CharaChipDirection charaChipDirection = mapEventPage.GraphicInfo.InitDirection;
Texture2D charaChipTexture = new Texture2D(1, 1);
byte[] bytes = System.IO.File.ReadAllBytes(graphicPath);
charaChipTexture.LoadImage(bytes);
charaChipTexture.filterMode = FilterMode.Point;
RenderCharaChip(mapTexture, x, y, charaChipTexture, charaChipDirection);
}
}
mapTexture.Apply();
mapTexture.filterMode = FilterMode.Point;
Sprite sprite = Sprite.Create(mapTexture,
new Rect(0.0f, 0.0f, mapTexture.width, mapTexture.height), new Vector2(0.5f, 0.5f), 1.0f);
mapSprite.sprite = sprite;
}
public static void DBDataReadTest(DatabaseMergedData resultData, DBKind dbKind)
{
DatabaseMergedDataReader reader = null;
DatabaseDatFilePath datFilePath = null;
DatabaseProjectFilePath projectFilePath = null;
if (dbKind == DBKind.User)
{
datFilePath =
(UserDatabaseDatFilePath)$@"{DatabaseMergedDataTestItemGenerator.TestWorkRootDir}\Database.dat";
projectFilePath =
(UserDatabaseProjectFilePath)
$@"{DatabaseMergedDataTestItemGenerator.TestWorkRootDir}\Database.project";
reader = new DatabaseMergedDataReader(
(UserDatabaseDatFilePath)datFilePath,
(UserDatabaseProjectFilePath)projectFilePath);
}
else if (dbKind == DBKind.Changeable)
{
datFilePath =
(ChangeableDatabaseDatFilePath)
$@"{DatabaseMergedDataTestItemGenerator.TestWorkRootDir}\CDatabase.dat";
projectFilePath =
(ChangeableDatabaseProjectFilePath)
$@"{DatabaseMergedDataTestItemGenerator.TestWorkRootDir}\CDatabase.project";
reader = new DatabaseMergedDataReader(
(ChangeableDatabaseDatFilePath)datFilePath,
(ChangeableDatabaseProjectFilePath)projectFilePath);
}
else if (dbKind == DBKind.System)
{
datFilePath =
(SystemDatabaseDatFilePath)
$@"{DatabaseMergedDataTestItemGenerator.TestWorkRootDir}\SysDatabase.dat";
projectFilePath =
(SystemDatabaseProjectFilePath)
$@"{DatabaseMergedDataTestItemGenerator.TestWorkRootDir}\SysDatabase.project";
reader = new DatabaseMergedDataReader(
(SystemDatabaseDatFilePath)datFilePath,
(SystemDatabaseProjectFilePath)projectFilePath);
}
else
{
Assert.Fail();
}
Assert.NotNull(datFilePath);
Assert.NotNull(projectFilePath);
Assert.NotNull(reader);
var readResult = false;
var errorMessage = "";
try
{
reader.ReadSync();
readResult = true;
}
catch (Exception e)
{
errorMessage = e.Message;
}
// 正しく読めること
if (!readResult)
{
throw new InvalidOperationException(
$"Error Occured. Message : {errorMessage}");
}
Console.WriteLine("Read Test Clear.");
{
// DatabaseDat 一致チェック
var readResultDataBytes = reader.Data.GenerateDatabaseDat().ToBinary();
// 元のデータと一致すること
using (var stream = new FileStream(datFilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
var bufLength = (int)stream.Length;
var buf = new byte[bufLength];
stream.Read(buf, 0, bufLength);
if (readResultDataBytes.Length != bufLength)
{
throw new InvalidOperationException(
$"Data Length Not Match. " +
$"(answerLength: {bufLength}, readResultLength: {readResultDataBytes.Length})");
}
for (long i = 0; i < 0; i++)
{
if (readResultDataBytes[i] != buf[i])
{
throw new InvalidOperationException(
$"Data Byte Not Match. (index: {i}, answer: {buf[i]}," +
$" readResult: {readResultDataBytes[i]})");
}
}
}
// 意図したデータと一致すること
var resultDataBytes = resultData.GenerateDatabaseDat().ToBinary().ToArray();
if (resultDataBytes.Length != readResultDataBytes.Length)
{
throw new InvalidOperationException(
$"Data Length Not Match. " +
$"(answerLength: {resultDataBytes.Length}, readResultLength: {readResultDataBytes.Length})");
}
for (long i = 0; i < 0; i++)
{
if (resultDataBytes[i] != readResultDataBytes[i])
{
throw new InvalidOperationException(
$"Data Byte Not Match. (index: {i}, answer: {resultDataBytes[i]}," +
$" readResult: {readResultDataBytes[i]})");
}
}
}
{
// DatabaseProject 一致チェック
var readResultDataBytes = reader.Data.GenerateDatabaseProject().ToBinary();
// 元のデータと一致すること
using (var stream = new FileStream(projectFilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
var bufLength = (int)stream.Length;
var buf = new byte[bufLength];
stream.Read(buf, 0, bufLength);
if (readResultDataBytes.Length != bufLength)
{
throw new InvalidOperationException(
$"Data Length Not Match. " +
$"(answerLength: {bufLength}, readResultLength: {readResultDataBytes.Length})");
}
for (long i = 0; i < 0; i++)
{
if (readResultDataBytes[i] != buf[i])
{
throw new InvalidOperationException(
$"Data Byte Not Match. (index: {i}, answer: {buf[i]}," +
$" readResult: {readResultDataBytes[i]})");
}
}
}
// 意図したデータと一致すること
var resultDataBytes = resultData.GenerateDatabaseProject().ToBinary().ToArray();
if (resultDataBytes.Length != readResultDataBytes.Length)
{
throw new InvalidOperationException(
$"Data Length Not Match. " +
$"(answerLength: {resultDataBytes.Length}, readResultLength: {readResultDataBytes.Length})");
}
for (long i = 0; i < 0; i++)
{
if (resultDataBytes[i] != readResultDataBytes[i])
{
throw new InvalidOperationException(
$"Data Byte Not Match. (index: {i}, answer: {resultDataBytes[i]}," +
$" readResult: {readResultDataBytes[i]})");
}
}
}
Assert.True(true);
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="outputData">書き出しデータ</param>
/// <param name="datFilePath">データファイルパス</param>
/// <param name="projectFilePath">プロジェクトファイルパス</param>
/// <exception cref="ArgumentNullException">
/// outputData, datFilePath, projectFilePath が null の場合
/// </exception>
public DatabaseMergedDataWriter(DatabaseMergedData outputData, UserDatabaseDatFilePath datFilePath,
UserDatabaseProjectFilePath projectFilePath) : this(outputData, datFilePath,
(DatabaseProjectFilePath)projectFilePath)
{
DbKind = DBKind.User;
}
// _/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
// Constructor
// _/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="outputData">書き出しデータ</param>
/// <param name="datFilePath">データファイルパス</param>
/// <param name="projectFilePath">プロジェクトファイルパス</param>
/// <exception cref="ArgumentNullException">
/// outputData, datFilePath, projectFilePath が null の場合
/// </exception>
public DatabaseMergedDataWriter(DatabaseMergedData outputData, ChangeableDatabaseDatFilePath datFilePath,
ChangeableDatabaseProjectFilePath projectFilePath) : this(outputData, datFilePath,
(DatabaseProjectFilePath)projectFilePath)
{
DbKind = DBKind.Changeable;
}
public string GetUserDBString(int typeID, int dataID, int itemID)
{
DatabaseMergedData db = CoreData.Instance.userDB;
return(db.GetDataDescList(typeID)[dataID].ItemValueList[itemID].StringValue);
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="outputData">書き出しデータ</param>
/// <param name="datFilePath">データファイルパス</param>
/// <param name="projectFilePath">プロジェクトファイルパス</param>
/// <exception cref="ArgumentNullException">
/// outputData, datFilePath, projectFilePath が null の場合
/// </exception>
public DatabaseMergedDataWriter(DatabaseMergedData outputData, SystemDatabaseDatFilePath datFilePath,
SystemDatabaseProjectFilePath projectFilePath) : this(outputData, datFilePath,
(DatabaseProjectFilePath)projectFilePath)
{
DbKind = DBKind.System;
}
public int GetSystemDBInteger(int typeID, int dataID, int itemID)
{
DatabaseMergedData db = CoreData.Instance.systemDB;
return(db.GetDataDescList(typeID)[dataID].ItemValueList[itemID].IntValue);
}
