void Generator::WriteToFile(CFileIO &fIO)
{
fIO.WriteBinary(&iEntType,1);
fIO.WriteBinary(&ScrollOffset,1);
fIO.WriteBinary(&Pos.x,1);
fIO.WriteBinary(&Pos.y,1);
fIO.WriteBinary(&numEnts,1);
fIO.WriteBinary(&tickDelay,1);
mpEntity->WriteToFile(fIO);
}
BOOL CScanner::Load_FileIO( LPCTSTR lpszFileName, BOOL bMultiByte )
{
CFileIO file;
CString fileName = lpszFileName;
fileName.MakeLower();
if( !file.Open(lpszFileName, "rb" ) )
return 0;
m_strFileName = lpszFileName;
return Read( &file, bMultiByte );
}
void CTest::CreateFile(const string& path, size_t offset, size_t size)
{
CFileIO fio;
fio.Open(path, CFileIO::eCreate, CFileIO::eReadWrite);
assert((offset + size) <= m_BufLen);
size_t n = fio.Write(m_Buf + offset, size);
assert(n == size);
fio.Close();
assert(CFile(path).Exists());
}
void Generator::LoadFromFile(CFileIO &fIO)
{
fIO.ReadBinary(&iEntType,1);
fIO.ReadBinary(&ScrollOffset,1);
fIO.ReadBinary(&Pos.x,1);
fIO.ReadBinary(&Pos.y,1);
fIO.ReadBinary(&numEnts,1);
fIO.ReadBinary(&tickDelay,1);
if(!(mpEntity = gpEngine->CreateEntity(iEntType)))
return;
mpEntity->LoadFromFile(fIO);
}
// The method is called after the database is created or loaded.
// This guarantees that the directory is there.
// The file with an identifier could be read or created safely.
// Returns: true if everything is fine.
void CNetScheduleServer::InitNodeID(const string & db_path)
{
CFile node_id_file(CFile::MakePath(
CDirEntry::AddTrailingPathSeparator(db_path),
"NODE_ID"));
if (node_id_file.Exists()) {
// File exists, read the ID from it
CFileIO f;
char buffer[64];
f.Open(node_id_file.GetPath(), CFileIO_Base::eOpen,
CFileIO_Base::eRead);
size_t n = f.Read(buffer, sizeof(buffer));
m_NodeID = string(buffer, n);
NStr::TruncateSpacesInPlace(m_NodeID, NStr::eTrunc_End);
f.Close();
} else {
// No file, need to be created
m_NodeID = "n" + x_GenerateGUID();
CFileIO f;
f.Open(node_id_file.GetPath(), CFileIO_Base::eCreate,
CFileIO_Base::eReadWrite);
f.Write(m_NodeID.data(), m_NodeID.size());
f.Close();
}
}
void ControlledEntity::WriteBufferToFile(CFileIO &fIO)
{
int bufsize = (int)mKeyBuffer.size();
fIO.WriteBinary(&bufsize,1);
if(bufsize>0)
{
list<keyBuffer>::iterator i;
for(i = mKeyBuffer.begin(); i != mKeyBuffer.end(); i++)
{
fIO.WriteBinary(&(*i).tick,1);
fIO.WriteBinary(&(*i).KeyStateChange,1);
fIO.WriteBinary(&(*i).KeyStates,1);
}
}
}
void ControlledEntity::ReadBufferFromFile(CFileIO &fIO)
{
int bufsize,n;
fIO.ReadBinary(&bufsize,1);
if(bufsize>0)
{
for(n=0;n<bufsize;n++)
{
keyBuffer kb;
fIO.ReadBinary(&kb.tick,1);
fIO.ReadBinary(&kb.KeyStateChange,1);
fIO.ReadBinary(&kb.KeyStates,1);
mKeyBuffer.push_back(kb);
}
}
}
bool LoadDemo(demoSystem& dem, int demo)
{
char name[256];
sprintf(name,"Data/Demo%i.dem",demo);
dem.mKeyBuffer.clear();
CFileIO fIO;
if(!fIO.GetFile(name,"rb"))
return false;
fIO.ReadBinary(&dem.iScrollOffset,1);
int bufsize,n;
fIO.ReadBinary(&bufsize,1);
if(bufsize>0)
{
for(n=0;n<bufsize;n++)
{
keyBuffer kb;
fIO.ReadBinary(&kb.tick,1);
fIO.ReadBinary(&kb.KeyStateChange,1);
fIO.ReadBinary(&kb.KeyStates,1);
dem.mKeyBuffer.push_back(kb);
}
}
return true;
}
//================================================================================================//
bool Engine::LoadMapData()
{
char sz[256];
ClearMapArrays();
ClearMapEntities();
CFileIO fIO;
sprintf(sz,"Data/Maps/Stage%i.stg",iStage);
if(!fIO.GetFile(sz,"rb"))
return false;
int x,y;
//read block data
for(x=0;x<400;x++)
{
for(y=0;y<15;y++)
{
fIO.ReadBinary(&mTilesLayer1[x][y].ID,1);
fIO.ReadBinary(&mTilesLayer1[x][y].properties,1);
fIO.ReadBinary(&mTilesLayer2[x][y].ID,1);
fIO.ReadBinary(&mTilesLayer2[x][y].properties,1);
fIO.ReadBinary(&mTilesLayer3[x][y].ID,1);
fIO.ReadBinary(&mTilesLayer3[x][y].properties,1);
}
}
//read entities
int numEnt,n;
fIO.ReadBinary(&numEnt,1);
for(n=0;n<numEnt;n++)
{
Generator g;
g.LoadFromFile(fIO);
mGenerators.push_back(g);
}
fIO.ReadBinary(&numEnt,1);
for(n=0;n<numEnt;n++)
{
AnimGenerator g;
g.LoadFromFile(fIO);
mAnimGenerators.push_back(g);
}
return true;
}
void CLog::Write( const std::string sLog )
{
printf( sLog.c_str() );
// ログ出力モードになっているかをチェック
if( !IsWrite() ) return;
// 今日の日付でファイルを作成する
struct tm *date;
time_t now;
time(&now);
date = localtime(&now);
// ファイル名
char buffa[_MAX_PATH];
SHGetSpecialFolderPath(NULL, buffa, CSIDL_DESKTOPDIRECTORY, FALSE);
sprintf_s( buffa, _MAX_PATH, "%s\\%04d%02d%02d.log", buffa, date->tm_year + 1900, date->tm_mon + 1 , date->tm_mday );
std::ostringstream os;
os << std::setw(2) << date->tm_hour << ":" << std::setw(2) << date->tm_min << "\t" << sLog;
CFileIO io;
io.Write( os.str(), std::ios::app, buffa );
}
void SaveDemo(demoSystem dem)
{
CFileIO fIO;
fIO.GetFile("Data/Demo1.dem","wb");
fIO.WriteBinary(&dem.iScrollOffset,1);
int bufsize = (int)dem.mKeyBuffer.size();
fIO.WriteBinary(&bufsize,1);
if(bufsize>0)
{
list<keyBuffer>::iterator i;
for(i = dem.mKeyBuffer.begin(); i != dem.mKeyBuffer.end(); i++)
{
fIO.WriteBinary(&(*i).tick,1);
fIO.WriteBinary(&(*i).KeyStateChange,1);
fIO.WriteBinary(&(*i).KeyStates,1);
}
}
}
void FireBug::LoadFromFile(CFileIO &fIO)
{
fIO.ReadBinary(&RateofFire,1);
fIO.ReadBinary(&bStartMovement,1);
}
//===============================================================================================
// PROCEDURE: Read
// PURPOSE: Reads a block and returnd FALSE on ERROR.
//
inline BOOL CFileDescriptor::Read(LPVOID lpBuf, UINT uBytesToRead)
{
// MEMBERASSERT();
return m_File.Read(lpBuf, uBytesToRead) ? TRUE : SetLastError(ABF_EREADDATA);
}
void SuperTurret::WriteToFile(CFileIO &fIO)
{
fIO.WriteBinary(&bDirection,1);
}
void Serpent::WriteToFile(CFileIO &fIO)
{
fIO.WriteBinary(&RateofFire,1);
fIO.WriteBinary(&bStartDirection,1);
WriteBufferToFile(fIO);
}
void BreakScenery::LoadFromFile(CFileIO &fIO)
{
fIO.ReadBinary(&frame,1);
fIO.ReadBinary(&iRotation,1);
spr = gpEngine->sprBreak1;
}
void TriggerSpeedUp::LoadFromFile(CFileIO &fIO)
{
fIO.ReadBinary(&iMaxTicks,1);
}
void BreakScenery::WriteToFile(CFileIO &fIO)
{
fIO.WriteBinary(&frame,1);
fIO.WriteBinary(&iRotation,1);
}
// CImpIColumnsInfo::GetColumnInfo -------------------------------------------
//
// @mfunc Returns the column metadata needed by most consumers.
//
// @rdesc HRESULT
// @flag S_OK | The method succeeded
// @flag E_OUTOFMEMORY | Out of memory
// @flag E_INVALIDARG | pcColumns or prginfo or ppStringsbuffer was NULL
//
STDMETHODIMP CImpIColumnsInfo::GetColumnInfo
(
DBORDINAL* pcColumns, //@parm OUT | Number of columns in rowset
DBCOLUMNINFO** prgInfo, //@parm OUT | Array of DBCOLUMNINFO Structures
WCHAR** ppStringsBuffer //@parm OUT | Storage for all string values
)
{
HRESULT hr = S_OK;
DBORDINAL cCols = 0;
DBORDINAL cExtraCols = 0;
DBORDINAL cbHeapUsed = 0;
DBORDINAL cIter = 0;
BYTE * pbHeap = NULL;
WCHAR * pwstrBuffer = NULL;
DBCOLUMNINFO * rgdbcolinfo = NULL;
DBCOLUMNINFO * rgdbInternalcolinfo = NULL;
DBCOLUMNINFO * rgdbExtracolinfo = NULL;
CRowset * pCRowset = NULL;
CFileIO * pFileio = NULL;
//
// Asserts
//
assert(m_pObj);
//
// Check in-params and NULL out-params in case of error
//
if( pcColumns )
*pcColumns = 0;
if( prgInfo )
*prgInfo = NULL;
if( ppStringsBuffer )
*ppStringsBuffer = NULL;
if( !pcColumns || !prgInfo || !ppStringsBuffer )
return E_INVALIDARG;
//
// Get the Column Information off of the Command or Rowset
//
if( m_pObj->GetBaseObjectType() == BOT_COMMAND )
{
//
// Asserts
//
assert(((CCommand *) m_pObj)->m_pCSession);
assert(((CCommand *) m_pObj)->m_pCSession->m_pCDataSource);
//
// Check that a command has been set
//
if( !((CCommand *) m_pObj)->IsCommandSet() )
return DB_E_NOCOMMAND;
//
// Try to open the file...
//
hr = ((CCommand *) m_pObj)->m_pCSession->m_pCDataSource->OpenFile(
((CCommand *) m_pObj)->GetCommandText(), &pFileio);
if( FAILED(hr) )
return hr;
}
else
{
if( m_pObj->GetBaseObjectType() == BOT_ROWSET )
pFileio = ((CRowset *) m_pObj)->GetFileObj();
else
{
pFileio = ((CRow *) m_pObj)->GetFileObj();
cExtraCols = ((CRow *) m_pObj)->GetExtraColCount();
rgdbExtracolinfo = ((CRow *) m_pObj)->GetExtraColumnInfo();
}
}
//
// Get the column count and delete unneeded info
//
cCols = pFileio->GetColumnCnt();
pbHeap = pFileio->GetColNameHeap();
cbHeapUsed = pFileio->GetColNameHeapSize();
rgdbInternalcolinfo = pFileio->GetColInfo();
//
// Return the column information
//
SAFE_ALLOC(rgdbcolinfo, DBCOLUMNINFO, (cCols + cExtraCols) * sizeof(DBCOLUMNINFO));
SAFE_ALLOC(pwstrBuffer, WCHAR, cbHeapUsed);
memcpy(rgdbcolinfo, &(rgdbInternalcolinfo[1]), cCols*sizeof(DBCOLUMNINFO));
memcpy(rgdbcolinfo+cCols, rgdbExtracolinfo, cExtraCols*sizeof(DBCOLUMNINFO));
//
// Need to fix up column ordinals for extra columns
//
for (cIter=cCols; cIter < cCols+cExtraCols; cIter++)
rgdbcolinfo[cIter].iOrdinal = cIter+1;
//
// Copy the heap for column names.
//
if( cbHeapUsed )
{
ptrdiff_t dp;
memcpy(pwstrBuffer, pbHeap, cbHeapUsed);
dp = (DBBYTEOFFSET)pwstrBuffer - (DBBYTEOFFSET)(pbHeap);
dp >>= 1;
// Loop through columns and adjust pointers to column names.
for (ULONG icol=0; icol < cCols; icol++)
{
if( rgdbcolinfo[icol].pwszName )
rgdbcolinfo[icol].pwszName += dp;
}
}
//
// Assign in the values
//
*pcColumns = cCols + cExtraCols;
*prgInfo = rgdbcolinfo;
*ppStringsBuffer = pwstrBuffer;
CLEANUP:
//
// Cleanup the File Information
//
if( m_pObj->GetBaseObjectType() == BOT_COMMAND )
SAFE_DELETE(pFileio);
if( FAILED(hr) )
{
SAFE_DELETE(rgdbcolinfo);
SAFE_DELETE(pwstrBuffer);
}
return hr;
}
// CImpIColumnsInfo::MapColumnIDs --------------------------------------------
//
// @mfunc Returns an array of ordinals of the columns in a rowset that are
// identified by the specified column IDs.
//
// @rdesc HRESULT
// @flag S_OK | The method succeeded
// @flag E_INVALIDARG | cColumnIDs was not 0 and rgColumnIDs was NULL,
// rgColumns was NULL
// @flag DB_E_COLUMNUNAVAILABLE | An element of rgColumnIDs was invalid
//
STDMETHODIMP CImpIColumnsInfo::MapColumnIDs
(
DBORDINAL cColumnIDs, //@parm IN | Number of Column IDs to map
const DBID rgColumnIDs[], //@parm IN | Column IDs to map
DBORDINAL rgColumns[] //@parm OUT | Ordinal values
)
{
DBORDINAL cCols = 0;
ULONG ulError = 0;
//
// Asserts
//
assert(m_pObj);
//
// NO-OP if cColumnIds is 0
//
if( cColumnIDs == 0 )
return S_OK;
//
// Check in-params and NULL out-params in case of error
//
if( !rgColumnIDs || !rgColumns )
return E_INVALIDARG;
//
// Get the Column count
//
if( m_pObj->GetBaseObjectType() == BOT_COMMAND )
{
HRESULT hr = E_FAIL;
CFileIO * pFileio = NULL;
//
// Asserts
//
assert(((CCommand *) m_pObj)->m_pCSession);
assert(((CCommand *) m_pObj)->m_pCSession->m_pCDataSource);
//
// Check that a command has been set
//
if( !((CCommand *) m_pObj)->IsCommandSet() )
return DB_E_NOCOMMAND;
//
// Open the File and get the column count
//
hr = ((CCommand *) m_pObj)->m_pCSession->m_pCDataSource->OpenFile(
((CCommand *) m_pObj)->GetCommandText(), &pFileio);
if( FAILED(hr) )
return hr;
cCols = pFileio->GetColumnCnt();
SAFE_DELETE(pFileio);
}
else
{
if( m_pObj->GetBaseObjectType() == BOT_ROWSET )
cCols = ((CRowset *) m_pObj)->m_cCols;
else
cCols = ((CRow *) m_pObj)->GetFileObj()->GetColumnCnt();
}
//
// Walk the Column ID structs and determine the ordinal value
//
for (ULONG i=0; i < cColumnIDs; i++)
{
if( m_pObj->GetBaseObjectType() == BOT_ROW &&
IsEqualDBID(&rgColumnIDs[i], &DBROWCOL_DEFAULTSTREAM) )
{
rgColumns[i] = cCols + DEFAULT_STREAM_ORDINAL;
}
else if( (rgColumnIDs[i].eKind != DBKIND_GUID_PROPID) ||
(rgColumnIDs[i].uGuid.guid != GUID_NULL) ||
(rgColumnIDs[i].uName.ulPropid < 1) ||
(rgColumnIDs[i].uName.ulPropid > cCols) )
{
rgColumns[i] = DB_INVALIDCOLUMN;
ulError++;
}
else
rgColumns[i] = rgColumnIDs[i].uName.ulPropid;
}
//
// Return the correct HResult
//
return ulError ? (ulError < cColumnIDs) ?
DB_S_ERRORSOCCURRED : DB_E_ERRORSOCCURRED : S_OK;
}
void FireBug::WriteToFile(CFileIO &fIO)
{
fIO.WriteBinary(&RateofFire,1);
fIO.WriteBinary(&bStartMovement,1);
}
void Serpent::LoadFromFile(CFileIO &fIO)
{
fIO.ReadBinary(&RateofFire,1);
fIO.ReadBinary(&bStartDirection,1);
ReadBufferFromFile(fIO);
}
void CWndInfoNotice::OnInitialUpdate()
{
CWndNeuz::OnInitialUpdate();
// 여기에 코딩하세요
CWndButton* pWndCheck = (CWndButton*)GetDlgItem( WIDC_CHECK1 );
pWndCheck->SetCheck( !g_Option.m_bNotice );
CWndText* pWndText = (CWndText*)GetDlgItem( WIDC_TEXT1 );
#ifdef __YNOTICE_UNI1026
CString strnotice;
strnotice = GetLangFileName( ::GetLanguage(), FILE_NOTICE );
CScript scanner;
if( scanner.Load( "Client\\"+strnotice ) == FALSE )
return;
pWndText->m_string.AddParsingString( scanner.m_pProg );
pWndText->ResetString();
#else //__YNOTICE_UNI1026
CFileStatus fileStatus;
CString strnotice;
strnotice = GetLangFileName( ::GetLanguage(), FILE_NOTICE );
if( CFile::GetStatus( "Client\\"+strnotice, fileStatus ) == TRUE )
{
if( g_Option.m_tNoticeTime != fileStatus.m_mtime.GetTime() )
g_Option.m_tNoticeTime = static_cast< time_t >( fileStatus.m_mtime.GetTime() );
CFileIO file;
strnotice = GetLangFileName( ::GetLanguage(), FILE_NOTICE );
if(::GetLanguage() == LANG_VTN)
{
if( file.Open( "Client\\"+strnotice, "rb" ) )
{
int nLength = file.GetLength();
TCHAR* pChar = new TCHAR[ nLength + 2 ];
file.Read( pChar, nLength );
*(pChar + nLength ) = '\0';
*(pChar + nLength + 1 ) = '\0';
char* lpMultiByte = new char[ nLength + 2 ];
int nResult = WideCharToMultiByteEx( g_codePage, 0,
(LPWSTR)(pChar+2), -1,
lpMultiByte, nLength,
NULL, NULL );
if( nResult > 0 )
{
lpMultiByte[nResult-1] = 0;
pWndText->m_string.AddParsingString( lpMultiByte );
pWndText->ResetString();
}
safe_delete_array(pChar);
safe_delete_array(lpMultiByte);
}
}
else
{
if( file.Open( "Client\\"+strnotice, "rb" ) )
{
int nLength = file.GetLength();
TCHAR* pChar = new TCHAR[ nLength + 1];
file.Read( pChar, nLength );
pChar[ nLength ] = 0;
//pWndText->SetString( pChar );
pWndText->m_string.AddParsingString( pChar );
pWndText->ResetString();
safe_delete( pChar );
}
}
}
#endif //__YNOTICE_UNI1026
// 윈도를 중앙으로 옮기는 부분.
CRect rectRoot = m_pWndRoot->GetLayoutRect();
CRect rectWindow = GetWindowRect();
CPoint point( rectRoot.right - rectWindow.Width(), 110 );
Move( point );
MoveParentCenter();
/////////////////////////////////////////////////////////////////////////////////////////
int nCount = 0;
CScript script;
if( script.Load(MakePath(DIR_THEME, "TexBannerList.inc" )) )
{
int nLang;
nLang = script.GetNumber();
do
{
if( nLang == ::GetLanguage() )
{
script.GetToken();
nCount = atoi( script.token );
script.GetToken();
for( int i=0; i<nCount; i++ )
{
CString addStr = script.token;
m_vecStrBanner.push_back( addStr );
script.GetToken();
}
if( nCount <= 0 )
{
Error( "TexBannerList.inc의 갯수가 0이다" );
return;
}
break;
}
else
script.GetLastFull();
nLang = script.GetNumber();
} while( script.tok != FINISHED );
}
SAFE_DELETE( m_atexPannel );
if( nCount > 0 )
{
m_atexPannel = new IMAGE;
LoadImage( MakePath( DIR_THEME, m_vecStrBanner[xRandom(nCount)] ), m_atexPannel );
AdjustWndBase();
}
/////////////////////////////////////////////////////////////////////////////////////////
}
//===============================================================================================
// FUNCTION: GetFileSize
// PURPOSE: Return the length of the file in bytes.
//
inline LONGLONG CFileDescriptor::GetFileSize()
{
// MEMBERASSERT();
return m_File.GetFileSize();
}
void SuperTurret::LoadFromFile(CFileIO &fIO)
{
fIO.ReadBinary(&bDirection,1);
}
void TriggerSpeedUp::WriteToFile(CFileIO &fIO)
{
fIO.WriteBinary(&iMaxTicks,1);
}
//===============================================================================================
// FUNCTION: GetFileHandle
// PURPOSE: Returns the file handle opened in the object.
//
inline FILEHANDLE CFileDescriptor::GetFileHandle()
{
// MEMBERASSERT();
return m_File.GetFileHandle();
}
//================================================================================================//
void Engine::SaveMap()
{
CFileIO fIO;
char sz[256];
sprintf(sz,"Data/Maps/Stage%i.stg",iStage);
if(!fIO.GetFile(sz,"wb"))
return;
int x,y;
//write block data
for(x=0;x<400;x++)
{
for(y=0;y<15;y++)
{
fIO.WriteBinary(&mTilesLayer1[x][y].ID,1);
fIO.WriteBinary(&mTilesLayer1[x][y].properties,1);
fIO.WriteBinary(&mTilesLayer2[x][y].ID,1);
fIO.WriteBinary(&mTilesLayer2[x][y].properties,1);
fIO.WriteBinary(&mTilesLayer3[x][y].ID,1);
fIO.WriteBinary(&mTilesLayer3[x][y].properties,1);
}
}
//write generators
int n = (int)mGenerators.size();
fIO.WriteBinary(&n,1);
if(n>0)
{
list<Generator>::iterator g;
for(g = mGenerators.begin(); g != mGenerators.end(); g++)
{
(*g).WriteToFile(fIO);
}
}
n = (int)mAnimGenerators.size();
fIO.WriteBinary(&n,1);
if(n>0)
{
list<AnimGenerator>::iterator g;
for(g = mAnimGenerators.begin(); g != mAnimGenerators.end(); g++)
{
(*g).WriteToFile(fIO);
}
}
fIO.ReleaseFile();
}
//===============================================================================================
// FUNCTION: Seek
// PURPOSE: Change the current position of the file pointer.
//
inline BOOL CFileDescriptor::Seek(LONGLONG llOffset, UINT uFlag, LONGLONG *pllNewOffset)
{
// MEMBERASSERT();
return m_File.Seek(llOffset, uFlag, pllNewOffset);
}
