void SetSFXExt(char *SFXName)
{
#ifdef _UNIX
SetExt(SFXName,"sfx");
#endif
#if defined(_WIN_32) || defined(_EMX)
SetExt(SFXName,"exe");
#endif
}
// Get the name of first volume. Return the leftmost digit of volume number.
wchar* VolNameToFirstName(const wchar *VolName,wchar *FirstName,size_t MaxSize,bool NewNumbering)
{
if (FirstName!=VolName)
wcsncpyz(FirstName,VolName,MaxSize);
wchar *VolNumStart=FirstName;
if (NewNumbering)
{
wchar N='1';
// From the rightmost digit of volume number to the left.
for (wchar *ChPtr=GetVolNumPart(FirstName);ChPtr>FirstName;ChPtr--)
if (IsDigit(*ChPtr))
{
*ChPtr=N; // Set the rightmost digit to '1' and others to '0'.
N='0';
}
else
if (N=='0')
{
VolNumStart=ChPtr+1; // Store the position of leftmost digit in volume number.
break;
}
}
else
{
// Old volume numbering scheme. Just set the extension to ".rar".
SetExt(FirstName,L"rar",MaxSize);
VolNumStart=GetExt(FirstName);
}
if (!FileExist(FirstName))
{
// If the first volume, which name we just generated, is not exist,
// check if volume with same name and any other extension is available.
// It can help in case of *.exe or *.sfx first volume.
wchar Mask[NM];
wcsncpyz(Mask,FirstName,ASIZE(Mask));
SetExt(Mask,L"*",ASIZE(Mask));
FindFile Find;
Find.SetMask(Mask);
FindData FD;
while (Find.Next(&FD))
{
Archive Arc;
if (Arc.Open(FD.Name,0) && Arc.IsArchive(true) && Arc.FirstVolume)
{
wcsncpyz(FirstName,FD.Name,MaxSize);
break;
}
}
}
return VolNumStart;
}
void SetSFXExt(wchar *SFXName,size_t MaxSize)
{
if (SFXName==NULL || *SFXName==0)
return;
#ifdef _UNIX
SetExt(SFXName,L"sfx",MaxSize);
#endif
#if defined(_WIN_ALL) || defined(_EMX)
SetExt(SFXName,L"exe",MaxSize);
#endif
}
void SetSFXExt(wchar *SFXName)
{
if (SFXName==NULL || *SFXName==0)
return;
#ifdef _UNIX
SetExt(SFXName,L"sfx");
#endif
#if defined(_WIN_32) || defined(_EMX)
SetExt(SFXName,L"exe");
#endif
}
TMimeTypes::TMimeTypes()
: ContentTypes()
, Ext()
{
SetContentTypes();
SetExt();
}
void CTestWindow::ConstructL(TPoint aPos,TSize aSize,CTWinBase* aParent, CWindowGc& aGc)
{
iWin=RWindow(TheClient->iWs);
User::LeaveIfError(iWin.Construct(*(aParent->WinTreeNode()),ENullWsHandle));
SetExt(aPos,aSize);
Activate();
AssignGC(aGc);
}
char* VolNameToFirstName(const char *VolName,char *FirstName,bool NewNumbering)
{
if (FirstName!=VolName)
strcpy(FirstName,VolName);
char *VolNumStart=FirstName;
if (NewNumbering)
{
int N='1';
for (char *ChPtr=GetVolNumPart(FirstName);ChPtr>FirstName;ChPtr--)
if (isdigit(*ChPtr))
{
*ChPtr=N;
N='0';
}
else
if (N=='0')
{
VolNumStart=ChPtr+1;
break;
}
}
else
{
SetExt(FirstName,"rar");
VolNumStart=GetExt(FirstName);
}
if (!FileExist(FirstName))
{
char Mask[NM];
strcpy(Mask,FirstName);
SetExt(Mask,"*");
FindFile Find;
Find.SetMask(Mask);
struct FindData FD;
while (Find.Next(&FD))
{
Archive Arc;
if (Arc.Open(FD.Name,FD.NameW) && Arc.IsArchive(true) && !Arc.NotFirstVolume)
{
strcpy(FirstName,FD.Name);
break;
}
}
}
return(VolNumStart);
}
// ==============================================================
int schito(void) // Считывание или запись <namezad>.o
{
int sig=5; // Number digits after commar
char tmp[256];SetExt(namezad,tmp,"o");
fstream input=fstream(tmp,ios::in);
if (input)
{input>>tmp>>prr>>tmp>>chk>>tmp>>delt>>tmp>>sho>>tmp>>shz
>>tmp>>vazmax>>tmp>>vazmin>>tmp>>obzro>>tmp>>obzv>>tmp>>mkt;
input.close();}
else { // Принудительное задание
void OnWhois(Whois::Context& whois) override
{
// If the extban is disabled we don't expose users location.
if (!extban)
return;
std::string* cc = ext.get(whois.GetTarget());
if (!cc)
cc = SetExt(whois.GetTarget());
whois.SendLine(RPL_WHOISCOUNTRY, *cc, "is located in this country");
}
ModResult OnCheckBan(User* user, Channel*, const std::string& mask) override
{
if (extban && (mask.length() > 2) && (mask[0] == 'G') && (mask[1] == ':'))
{
std::string* cc = ext.get(user);
if (!cc)
cc = SetExt(user);
if (InspIRCd::Match(*cc, mask.substr(2)))
return MOD_RES_DENY;
}
return MOD_RES_PASSTHRU;
}
JBlotPiece::JBlotPiece()
{
m_HomePos = Vec2::null;
m_MovePos = Vec2::null;
m_bAtHome = false;
m_pBlot = NULL;
m_Scale = 1.2f;
m_bSelected = false;
m_bRipple = false;
m_bMoving = false;
SetFocusable( true );
SetExt( Frame( 0.0f, 0.0f, 140.0f, 130.0f ) );
} // JBlotPiece::JBlotPiece
ModResult OnSetConnectClass(LocalUser* user, ConnectClass* myclass)
{
std::string* cc = ext.get(user);
if (!cc)
SetExt(user);
std::string geoip = myclass->config->getString("geoip");
if (geoip.empty())
return MOD_RES_PASSTHRU;
irc::commasepstream list(geoip);
std::string country;
while (list.GetToken(country))
if (country == *cc)
return MOD_RES_PASSTHRU;
return MOD_RES_DENY;
}
void init()
{
gi = GeoIP_new(GEOIP_STANDARD);
if (gi == NULL)
throw ModuleException("Unable to initialize geoip, are you missing GeoIP.dat?");
ServerInstance->Modules->AddService(ext);
Implementation eventlist[] = { I_OnSetConnectClass, I_OnStats };
ServerInstance->Modules->Attach(eventlist, this, sizeof(eventlist)/sizeof(Implementation));
for (LocalUserList::const_iterator i = ServerInstance->Users->local_users.begin(); i != ServerInstance->Users->local_users.end(); ++i)
{
LocalUser* user = *i;
if ((user->registered == REG_ALL) && (!ext.get(user)))
{
SetExt(user);
}
}
}
void init() override
{
ipv4db = GeoIP_open_type(GEOIP_COUNTRY_EDITION, GEOIP_STANDARD);
if (!ipv4db)
throw ModuleException("Unable to load the IPv4 GeoIP database. Are you missing GeoIP.dat?");
ipv6db = GeoIP_open_type(GEOIP_COUNTRY_EDITION_V6, GEOIP_STANDARD);
if (!ipv6db)
throw ModuleException("Unable to load the IPv6 GeoIP database. Are you missing GeoIPv6.dat?");
const UserManager::LocalList& list = ServerInstance->Users.GetLocalUsers();
for (UserManager::LocalList::const_iterator i = list.begin(); i != list.end(); ++i)
{
LocalUser* user = *i;
if ((user->registered == REG_ALL) && (!ext.get(user)))
{
SetExt(user);
}
}
}
void JSlidePiece::Render()
{
m_Pos.y = m_pSlideGame->m_TopLine + m_Speed*(JAnimServer::s_pInstance->GetCurTime() - m_StartTime);
if (IsVisible())
{
DWORD color = GetFgColor();
if (IsHovered()) color = GetHoverFgColor();
Frame ext = GetExt();
ext.x = m_Pos.x;
ext.y = m_Pos.y;
SetExt( ext );
ext.w = g_pDrawServer->GetFrameW( GetSkinPackID(), GetSkinFrame() );
ext.h = g_pDrawServer->GetFrameH( GetSkinPackID(), GetSkinFrame() );
g_pDrawServer->DrawSprite( ext, GetSkinPackID(), GetSkinFrame(), color );
g_pDrawServer->Flush();
}
} // JSlidePiece::Render
void ShowTemp(fstream &in)
{
double Dmax,Dmin,Emax,Emin;
double R,E,P,T,S;
char data[256],res[256];
if (InputPar(in,Dmax,Dmin,Emax,Emin,data))
{
SetExt(data,res,"res");
fstream inp(data,ios::in);fstream out(res,ios::out);
out<<" Dencity Pressure Temperature Energy Sound\n";
while (!seek_eof(inp))
{inp>>R>>E;
P=MatterAdiabat->Pressure(R,E);
//cout<<" P \n";
T=MatterAdiabat->Temperature(R,E);
//cout<<" T \n";
S=MatterAdiabat->Sound(R,E);
//cout<<" S \n";
out<<FM<<R<<FMT<<P<<FMT<<T<<FMT<<E<<FMT<<S<<"\n";
}
inp.close();out.close();
}
};
void JBlotPiece::Render()
{
DWORD color = GetFgColor();
float scale;
if (m_bSelected) scale = m_Scale; else scale = 1.0f;
//Moving the piece to m_MovePos
if (m_bMoving)
{
Frame ext = GetExt();
float t = JAnimServer::s_pInstance->GetCurTime() - m_StartMoveTime;
if (t >= 1.0f)
{
t = 1.0f;
m_bMoving = false;
}
else if (t <= 0.0f)
{
t = 0.0f;
}
Vec2 cur_pos( ext.x , ext.y );
Vec2 pos = cur_pos + t * (m_MovePos - cur_pos);
ext.x = pos.x;
ext.y = pos.y;
SetExt( ext );
}
if (IsHovered()||m_bSelected)
{
color = GetHoverFgColor();
}
Frame ext = GetLocalExt();
Vec2 pos( ext.x, ext.y );
float dist = pos.dist( m_HomePos );
float c_SnapBias = 10.0f;
if (dist < c_SnapBias)
{
m_bAtHome = true;
}
else
{
m_bAtHome = false;
}
ext = GetExt();
ext.w = scale*g_pDrawServer->GetFrameW( GetSkinPackID(), GetSkinFrame() );
ext.h = scale*g_pDrawServer->GetFrameH( GetSkinPackID(), GetSkinFrame() );
if (m_bRipple)
{
//Start Rippling
s_pThis = this;
g_pDrawServer->Flush();
g_pDrawServer->SetVertexCB( RippleCallback );
g_pDrawServer->DrawSprite( ext, GetSkinPackID(), GetSkinFrame(), color );
g_pDrawServer->Flush();
g_pDrawServer->SetVertexCB( NULL );
s_pThis = NULL;
//Stop Rippling
} else
{
//Simple drawing
g_pDrawServer->DrawSprite( ext, GetSkinPackID(), GetSkinFrame(), color );
g_pDrawServer->Flush();
}
JAnmContext& ctx = JAnimation::PushContext();
ctx.m_Pos.x = ext.x;
ctx.m_Pos.y = ext.y;
} // JBlotPiece::Render
bool CmdExtract::ExtractCurrentFile(CommandData *Cmd,Archive &Arc,size_t HeaderSize,bool &Repeat)
{
char Command=*Cmd->Command;
if (HeaderSize==0)
if (DataIO.UnpVolume)
{
#ifdef NOVOLUME
return(false);
#else
if (!MergeArchive(Arc,&DataIO,false,Command))
{
ErrHandler.SetErrorCode(WARNING);
return(false);
}
SignatureFound=false;
#endif
}
else
return(false);
int HeadType=Arc.GetHeaderType();
if (HeadType!=FILE_HEAD)
{
if (HeadType==AV_HEAD || HeadType==SIGN_HEAD)
SignatureFound=true;
#if !defined(SFX_MODULE) && !defined(_WIN_CE)
if (HeadType==SUB_HEAD && PrevExtracted)
SetExtraInfo(Cmd,Arc,DestFileName,*DestFileNameW ? DestFileNameW:NULL);
#endif
if (HeadType==NEWSUB_HEAD)
{
if (Arc.SubHead.CmpName(SUBHEAD_TYPE_AV))
SignatureFound=true;
#if !defined(NOSUBBLOCKS) && !defined(_WIN_CE)
if (PrevExtracted)
SetExtraInfoNew(Cmd,Arc,DestFileName,*DestFileNameW ? DestFileNameW:NULL);
#endif
}
if (HeadType==ENDARC_HEAD)
if (Arc.EndArcHead.Flags & EARC_NEXT_VOLUME)
{
#ifndef NOVOLUME
if (!MergeArchive(Arc,&DataIO,false,Command))
{
ErrHandler.SetErrorCode(WARNING);
return(false);
}
SignatureFound=false;
#endif
Arc.Seek(Arc.CurBlockPos,SEEK_SET);
return(true);
}
else
return(false);
Arc.SeekToNext();
return(true);
}
PrevExtracted=false;
if (SignatureFound ||
!Cmd->Recurse && MatchedArgs>=Cmd->FileArgs->ItemsCount() &&
AllMatchesExact)
return(false);
char ArcFileName[NM];
IntToExt(Arc.NewLhd.FileName,Arc.NewLhd.FileName);
strcpy(ArcFileName,Arc.NewLhd.FileName);
wchar ArcFileNameW[NM];
*ArcFileNameW=0;
int MatchType=MATCH_WILDSUBPATH;
bool EqualNames=false;
int MatchNumber=Cmd->IsProcessFile(Arc.NewLhd,&EqualNames,MatchType);
bool ExactMatch=MatchNumber!=0;
#if !defined(SFX_MODULE) && !defined(_WIN_CE)
if (Cmd->ExclPath==EXCL_BASEPATH)
{
*Cmd->ArcPath=0;
if (ExactMatch)
{
Cmd->FileArgs->Rewind();
if (Cmd->FileArgs->GetString(Cmd->ArcPath,NULL,sizeof(Cmd->ArcPath),MatchNumber-1))
*PointToName(Cmd->ArcPath)=0;
}
}
#endif
if (ExactMatch && !EqualNames)
AllMatchesExact=false;
#ifdef UNICODE_SUPPORTED
bool WideName=(Arc.NewLhd.Flags & LHD_UNICODE) && UnicodeEnabled();
#else
bool WideName=false;
#endif
#ifdef _APPLE
if (WideName)
{
WideToUtf(Arc.NewLhd.FileNameW,ArcFileName,sizeof(ArcFileName));
WideName=false;
}
#endif
wchar *DestNameW=WideName ? DestFileNameW:NULL;
#ifdef UNICODE_SUPPORTED
if (WideName)
{
ConvertPath(Arc.NewLhd.FileNameW,ArcFileNameW);
char Name[NM];
if (WideToChar(ArcFileNameW,Name) && IsNameUsable(Name))
strcpy(ArcFileName,Name);
}
#endif
ConvertPath(ArcFileName,ArcFileName);
if (Arc.IsArcLabel())
return(true);
if (Arc.NewLhd.Flags & LHD_VERSION)
{
if (Cmd->VersionControl!=1 && !EqualNames)
{
if (Cmd->VersionControl==0)
ExactMatch=false;
int Version=ParseVersionFileName(ArcFileName,ArcFileNameW,false);
if (Cmd->VersionControl-1==Version)
ParseVersionFileName(ArcFileName,ArcFileNameW,true);
else
ExactMatch=false;
}
}
else
if (!Arc.IsArcDir() && Cmd->VersionControl>1)
ExactMatch=false;
Arc.ConvertAttributes();
#ifndef SFX_MODULE
if ((Arc.NewLhd.Flags & (LHD_SPLIT_BEFORE/*|LHD_SOLID*/)) && FirstFile)
{
char CurVolName[NM];
strcpy(CurVolName,ArcName);
VolNameToFirstName(ArcName,ArcName,(Arc.NewMhd.Flags & MHD_NEWNUMBERING)!=0);
if (stricomp(ArcName,CurVolName)!=0 && FileExist(ArcName))
{
*ArcNameW=0;
Repeat=true;
return(false);
}
#if !defined(RARDLL) && !defined(_WIN_CE)
if (!ReconstructDone)
{
ReconstructDone=true;
RecVolumes RecVol;
if (RecVol.Restore(Cmd,Arc.FileName,Arc.FileNameW,true))
{
Repeat=true;
return(false);
}
}
#endif
strcpy(ArcName,CurVolName);
}
#endif
DataIO.UnpVolume=(Arc.NewLhd.Flags & LHD_SPLIT_AFTER)!=0;
DataIO.NextVolumeMissing=false;
Arc.Seek(Arc.NextBlockPos-Arc.NewLhd.FullPackSize,SEEK_SET);
bool TestMode=false;
bool ExtrFile=false;
bool SkipSolid=false;
#ifndef SFX_MODULE
if (FirstFile && (ExactMatch || Arc.Solid) && (Arc.NewLhd.Flags & (LHD_SPLIT_BEFORE/*|LHD_SOLID*/))!=0)
{
if (ExactMatch)
{
Log(Arc.FileName,St(MUnpCannotMerge),ArcFileName);
#ifdef RARDLL
Cmd->DllError=ERAR_BAD_DATA;
#endif
ErrHandler.SetErrorCode(OPEN_ERROR);
}
ExactMatch=false;
}
FirstFile=false;
#endif
if (ExactMatch || (SkipSolid=Arc.Solid)!=0)
{
if ((Arc.NewLhd.Flags & LHD_PASSWORD)!=0)
#ifndef RARDLL
if (*Password==0)
#endif
{
#ifdef RARDLL
if (*Cmd->Password==0)
if (Cmd->Callback==NULL ||
Cmd->Callback(UCM_NEEDPASSWORD,Cmd->UserData,(LPARAM)Cmd->Password,sizeof(Cmd->Password))==-1)
return(false);
strcpy(Password,Cmd->Password);
#else
if (!GetPassword(PASSWORD_FILE,ArcFileName,Password,sizeof(Password)))
{
PasswordCancelled=true;
return(false);
}
#endif
}
#if !defined(GUI) && !defined(SILENT)
else
if (!PasswordAll && (!Arc.Solid || Arc.NewLhd.UnpVer>=20 && (Arc.NewLhd.Flags & LHD_SOLID)==0))
{
eprintf(St(MUseCurPsw),ArcFileName);
switch(Cmd->AllYes ? 1:Ask(St(MYesNoAll)))
{
case -1:
ErrHandler.Exit(USER_BREAK);
case 2:
if (!GetPassword(PASSWORD_FILE,ArcFileName,Password,sizeof(Password)))
{
return(false);
}
break;
case 3:
PasswordAll=true;
break;
}
}
#endif
#ifndef SFX_MODULE
if (*Cmd->ExtrPath==0 && *Cmd->ExtrPathW!=0)
WideToChar(Cmd->ExtrPathW,DestFileName);
else
#endif
strcpy(DestFileName,Cmd->ExtrPath);
#ifndef SFX_MODULE
if (Cmd->AppendArcNameToPath)
{
strcat(DestFileName,PointToName(Arc.FirstVolumeName));
SetExt(DestFileName,NULL);
AddEndSlash(DestFileName);
}
#endif
char *ExtrName=ArcFileName;
bool EmptyName=false;
#ifndef SFX_MODULE
size_t Length=strlen(Cmd->ArcPath);
if (Length>1 && IsPathDiv(Cmd->ArcPath[Length-1]) &&
strlen(ArcFileName)==Length-1)
Length--;
if (Length>0 && strnicomp(Cmd->ArcPath,ArcFileName,Length)==0)
{
ExtrName+=Length;
while (*ExtrName==CPATHDIVIDER)
ExtrName++;
if (*ExtrName==0)
EmptyName=true;
}
#endif
bool AbsPaths=Cmd->ExclPath==EXCL_ABSPATH && Command=='X' && IsDriveDiv(':');
if (AbsPaths)
*DestFileName=0;
if (Command=='E' || Cmd->ExclPath==EXCL_SKIPWHOLEPATH)
strcat(DestFileName,PointToName(ExtrName));
else
strcat(DestFileName,ExtrName);
char DiskLetter=etoupper(DestFileName[0]);
if (AbsPaths && DestFileName[1]=='_' && IsPathDiv(DestFileName[2]) &&
DiskLetter>='A' && DiskLetter<='Z')
DestFileName[1]=':';
#ifndef SFX_MODULE
if (!WideName && *Cmd->ExtrPathW!=0)
{
DestNameW=DestFileNameW;
WideName=true;
CharToWide(ArcFileName,ArcFileNameW);
}
#endif
if (WideName)
{
if (*Cmd->ExtrPathW!=0)
strcpyw(DestFileNameW,Cmd->ExtrPathW);
else
CharToWide(Cmd->ExtrPath,DestFileNameW);
#ifndef SFX_MODULE
if (Cmd->AppendArcNameToPath)
{
wchar FileNameW[NM];
if (*Arc.FirstVolumeNameW!=0)
strcpyw(FileNameW,Arc.FirstVolumeNameW);
else
CharToWide(Arc.FirstVolumeName,FileNameW);
strcatw(DestFileNameW,PointToName(FileNameW));
SetExt(DestFileNameW,NULL);
AddEndSlash(DestFileNameW);
}
#endif
wchar *ExtrNameW=ArcFileNameW;
#ifndef SFX_MODULE
if (Length>0)
{
wchar ArcPathW[NM];
GetWideName(Cmd->ArcPath,Cmd->ArcPathW,ArcPathW);
Length=strlenw(ArcPathW);
}
ExtrNameW+=Length;
while (*ExtrNameW==CPATHDIVIDER)
ExtrNameW++;
#endif
if (AbsPaths)
*DestFileNameW=0;
if (Command=='E' || Cmd->ExclPath==EXCL_SKIPWHOLEPATH)
strcatw(DestFileNameW,PointToName(ExtrNameW));
else
strcatw(DestFileNameW,ExtrNameW);
if (AbsPaths && DestFileNameW[1]=='_' && IsPathDiv(DestFileNameW[2]))
DestFileNameW[1]=':';
}
else
*DestFileNameW=0;
ExtrFile=!SkipSolid && !EmptyName && (Arc.NewLhd.Flags & LHD_SPLIT_BEFORE)==0;
if ((Cmd->FreshFiles || Cmd->UpdateFiles) && (Command=='E' || Command=='X'))
{
struct FindData FD;
if (FindFile::FastFind(DestFileName,DestNameW,&FD))
{
if (FD.mtime >= Arc.NewLhd.mtime)
{
// If directory already exists and its modification time is newer
// than start of extraction, it is likely it was created
// when creating a path to one of already extracted items.
// In such case we'll better update its time even if archived
// directory is older.
if (!FD.IsDir || FD.mtime<StartTime)
ExtrFile=false;
}
}
else
if (Cmd->FreshFiles)
ExtrFile=false;
}
// Skip encrypted file if no password is specified.
if ((Arc.NewLhd.Flags & LHD_PASSWORD)!=0 && *Password==0)
{
ErrHandler.SetErrorCode(WARNING);
#ifdef RARDLL
Cmd->DllError=ERAR_MISSING_PASSWORD;
#endif
ExtrFile=false;
}
#ifdef RARDLL
if (*Cmd->DllDestName)
{
strncpyz(DestFileName,Cmd->DllDestName,ASIZE(DestFileName));
*DestFileNameW=0;
if (Cmd->DllOpMode!=RAR_EXTRACT)
ExtrFile=false;
}
if (*Cmd->DllDestNameW)
{
strncpyzw(DestFileNameW,Cmd->DllDestNameW,ASIZE(DestFileNameW));
DestNameW=DestFileNameW;
if (Cmd->DllOpMode!=RAR_EXTRACT)
ExtrFile=false;
}
#endif
#ifdef SFX_MODULE
if ((Arc.NewLhd.UnpVer!=UNP_VER && Arc.NewLhd.UnpVer!=29) &&
Arc.NewLhd.Method!=0x30)
#else
if (Arc.NewLhd.UnpVer<13 || Arc.NewLhd.UnpVer>UNP_VER)
#endif
{
#ifndef SILENT
Log(Arc.FileName,St(MUnknownMeth),ArcFileName);
#ifndef SFX_MODULE
Log(Arc.FileName,St(MVerRequired),Arc.NewLhd.UnpVer/10,Arc.NewLhd.UnpVer%10);
#endif
#endif
ExtrFile=false;
ErrHandler.SetErrorCode(WARNING);
#ifdef RARDLL
Cmd->DllError=ERAR_UNKNOWN_FORMAT;
#endif
}
File CurFile;
if (!IsLink(Arc.NewLhd.FileAttr))
if (Arc.IsArcDir())
{
if (!ExtrFile || Command=='P' || Command=='E' || Cmd->ExclPath==EXCL_SKIPWHOLEPATH)
return(true);
if (SkipSolid)
{
#ifndef GUI
mprintf(St(MExtrSkipFile),ArcFileName);
#endif
return(true);
}
TotalFileCount++;
if (Cmd->Test)
{
#ifndef GUI
mprintf(St(MExtrTestFile),ArcFileName);
mprintf(" %s",St(MOk));
#endif
return(true);
}
MKDIR_CODE MDCode=MakeDir(DestFileName,DestNameW,!Cmd->IgnoreGeneralAttr,Arc.NewLhd.FileAttr);
bool DirExist=false;
if (MDCode!=MKDIR_SUCCESS)
{
DirExist=FileExist(DestFileName,DestNameW);
if (DirExist && !IsDir(GetFileAttr(DestFileName,DestNameW)))
{
bool UserReject;
FileCreate(Cmd,NULL,DestFileName,DestNameW,Cmd->Overwrite,&UserReject,Arc.NewLhd.FullUnpSize,Arc.NewLhd.FileTime);
DirExist=false;
}
CreatePath(DestFileName,DestNameW,true);
MDCode=MakeDir(DestFileName,DestNameW,!Cmd->IgnoreGeneralAttr,Arc.NewLhd.FileAttr);
}
if (MDCode==MKDIR_SUCCESS)
{
#ifndef GUI
mprintf(St(MCreatDir),DestFileName);
mprintf(" %s",St(MOk));
#endif
PrevExtracted=true;
}
else
if (DirExist)
{
if (!Cmd->IgnoreGeneralAttr)
SetFileAttr(DestFileName,DestNameW,Arc.NewLhd.FileAttr);
PrevExtracted=true;
}
else
{
Log(Arc.FileName,St(MExtrErrMkDir),DestFileName);
ErrHandler.SysErrMsg();
#ifdef RARDLL
Cmd->DllError=ERAR_ECREATE;
#endif
ErrHandler.SetErrorCode(CREATE_ERROR);
}
if (PrevExtracted)
{
#if defined(_WIN_32) && !defined(_WIN_CE) && !defined(SFX_MODULE)
if (Cmd->SetCompressedAttr &&
(Arc.NewLhd.FileAttr & FILE_ATTRIBUTE_COMPRESSED)!=0 && WinNT())
SetFileCompression(DestFileName,DestNameW,true);
#endif
SetDirTime(DestFileName,DestNameW,
Cmd->xmtime==EXTTIME_NONE ? NULL:&Arc.NewLhd.mtime,
Cmd->xctime==EXTTIME_NONE ? NULL:&Arc.NewLhd.ctime,
Cmd->xatime==EXTTIME_NONE ? NULL:&Arc.NewLhd.atime);
}
return(true);
}
else
{
if (Cmd->Test && ExtrFile)
TestMode=true;
#if !defined(GUI) && !defined(SFX_MODULE)
if (Command=='P' && ExtrFile)
CurFile.SetHandleType(FILE_HANDLESTD);
#endif
if ((Command=='E' || Command=='X') && ExtrFile && !Cmd->Test)
{
bool UserReject;
if (!FileCreate(Cmd,&CurFile,DestFileName,DestNameW,Cmd->Overwrite,&UserReject,Arc.NewLhd.FullUnpSize,Arc.NewLhd.FileTime))
{
ExtrFile=false;
if (!UserReject)
{
ErrHandler.CreateErrorMsg(Arc.FileName,DestFileName);
ErrHandler.SetErrorCode(CREATE_ERROR);
#ifdef RARDLL
Cmd->DllError=ERAR_ECREATE;
#endif
if (!IsNameUsable(DestFileName))
{
Log(Arc.FileName,St(MCorrectingName));
char OrigName[sizeof(DestFileName)];
strncpyz(OrigName,DestFileName,ASIZE(OrigName));
MakeNameUsable(DestFileName,true);
CreatePath(DestFileName,NULL,true);
if (FileCreate(Cmd,&CurFile,DestFileName,NULL,Cmd->Overwrite,&UserReject,Arc.NewLhd.FullUnpSize,Arc.NewLhd.FileTime))
{
#ifndef SFX_MODULE
Log(Arc.FileName,St(MRenaming),OrigName,DestFileName);
#endif
ExtrFile=true;
}
else
ErrHandler.CreateErrorMsg(Arc.FileName,DestFileName);
}
}
}
}
}
if (!ExtrFile && Arc.Solid)
{
SkipSolid=true;
TestMode=true;
ExtrFile=true;
}
if (ExtrFile)
{
if (!SkipSolid)
{
if (!TestMode && Command!='P' && CurFile.IsDevice())
{
Log(Arc.FileName,St(MInvalidName),DestFileName);
ErrHandler.WriteError(Arc.FileName,DestFileName);
}
TotalFileCount++;
}
FileCount++;
#ifndef GUI
if (Command!='I')
if (SkipSolid)
mprintf(St(MExtrSkipFile),ArcFileName);
else
switch(Cmd->Test ? 'T':Command)
{
case 'T':
mprintf(St(MExtrTestFile),ArcFileName);
break;
#ifndef SFX_MODULE
case 'P':
mprintf(St(MExtrPrinting),ArcFileName);
break;
#endif
case 'X':
case 'E':
mprintf(St(MExtrFile),DestFileName);
break;
}
if (!Cmd->DisablePercentage)
mprintf(" ");
#endif
DataIO.CurUnpRead=0;
DataIO.CurUnpWrite=0;
DataIO.UnpFileCRC=Arc.OldFormat ? 0 : 0xffffffff;
DataIO.PackedCRC=0xffffffff;
DataIO.SetEncryption(
(Arc.NewLhd.Flags & LHD_PASSWORD) ? Arc.NewLhd.UnpVer:0,Password,
(Arc.NewLhd.Flags & LHD_SALT) ? Arc.NewLhd.Salt:NULL,false,
Arc.NewLhd.UnpVer>=36);
DataIO.SetPackedSizeToRead(Arc.NewLhd.FullPackSize);
DataIO.SetFiles(&Arc,&CurFile);
DataIO.SetTestMode(TestMode);
DataIO.SetSkipUnpCRC(SkipSolid);
#ifndef _WIN_CE
if (!TestMode && !Arc.BrokenFileHeader &&
(Arc.NewLhd.FullPackSize<<11)>Arc.NewLhd.FullUnpSize &&
(Arc.NewLhd.FullUnpSize<100000000 || Arc.FileLength()>Arc.NewLhd.FullPackSize))
CurFile.Prealloc(Arc.NewLhd.FullUnpSize);
#endif
CurFile.SetAllowDelete(!Cmd->KeepBroken);
bool LinkCreateMode=!Cmd->Test && !SkipSolid;
if (ExtractLink(DataIO,Arc,DestFileName,DataIO.UnpFileCRC,LinkCreateMode))
PrevExtracted=LinkCreateMode;
else
if ((Arc.NewLhd.Flags & LHD_SPLIT_BEFORE)==0)
if (Arc.NewLhd.Method==0x30)
UnstoreFile(DataIO,Arc.NewLhd.FullUnpSize);
else
{
Unp->SetDestSize(Arc.NewLhd.FullUnpSize);
#ifndef SFX_MODULE
if (Arc.NewLhd.UnpVer<=15)
Unp->DoUnpack(15,FileCount>1 && Arc.Solid);
else
#endif
Unp->DoUnpack(Arc.NewLhd.UnpVer,(Arc.NewLhd.Flags & LHD_SOLID)!=0);
}
if (Arc.IsOpened())
Arc.SeekToNext();
bool BrokenFile=false;
if (!SkipSolid)
{
if (Arc.OldFormat && UINT32(DataIO.UnpFileCRC)==UINT32(Arc.NewLhd.FileCRC) ||
!Arc.OldFormat && UINT32(DataIO.UnpFileCRC)==UINT32(Arc.NewLhd.FileCRC^0xffffffff))
{
#ifndef GUI
if (Command!='P' && Command!='I')
mprintf("%s%s ",Cmd->DisablePercentage ? " ":"\b\b\b\b\b ",St(MOk));
#endif
}
else
{
char *BadArcName=/*(Arc.NewLhd.Flags & LHD_SPLIT_BEFORE) ? NULL:*/Arc.FileName;
if (Arc.NewLhd.Flags & LHD_PASSWORD)
{
Log(BadArcName,St(MEncrBadCRC),ArcFileName);
}
else
{
Log(BadArcName,St(MCRCFailed),ArcFileName);
}
BrokenFile=true;
ErrHandler.SetErrorCode(CRC_ERROR);
#ifdef RARDLL
Cmd->DllError=ERAR_BAD_DATA;
#endif
Alarm();
}
}
#ifndef GUI
else
mprintf("\b\b\b\b\b ");
#endif
if (!TestMode && (Command=='X' || Command=='E') &&
!IsLink(Arc.NewLhd.FileAttr))
{
#if defined(_WIN_32) || defined(_EMX)
if (Cmd->ClearArc)
Arc.NewLhd.FileAttr&=~FA_ARCH;
/*
else
Arc.NewLhd.FileAttr|=FA_ARCH; //set archive bit for unpacked files (file is not backed up)
*/
#endif
if (!BrokenFile || Cmd->KeepBroken)
{
if (BrokenFile)
CurFile.Truncate();
CurFile.SetOpenFileTime(
Cmd->xmtime==EXTTIME_NONE ? NULL:&Arc.NewLhd.mtime,
Cmd->xctime==EXTTIME_NONE ? NULL:&Arc.NewLhd.ctime,
Cmd->xatime==EXTTIME_NONE ? NULL:&Arc.NewLhd.atime);
CurFile.Close();
#if defined(_WIN_32) && !defined(_WIN_CE) && !defined(SFX_MODULE)
if (Cmd->SetCompressedAttr &&
(Arc.NewLhd.FileAttr & FILE_ATTRIBUTE_COMPRESSED)!=0 && WinNT())
SetFileCompression(CurFile.FileName,CurFile.FileNameW,true);
#endif
CurFile.SetCloseFileTime(
Cmd->xmtime==EXTTIME_NONE ? NULL:&Arc.NewLhd.mtime,
Cmd->xatime==EXTTIME_NONE ? NULL:&Arc.NewLhd.atime);
if (!Cmd->IgnoreGeneralAttr)
SetFileAttr(CurFile.FileName,CurFile.FileNameW,Arc.NewLhd.FileAttr);
PrevExtracted=true;
}
}
}
}
if (ExactMatch)
MatchedArgs++;
if (DataIO.NextVolumeMissing || !Arc.IsOpened())
return(false);
if (!ExtrFile)
if (!Arc.Solid)
Arc.SeekToNext();
else
if (!SkipSolid)
return(false);
return(true);
}
void main(int argc, char *argv[])
{
// -------------------------------------------------------
// Ввод начальных данных
// -------------------------------------------------------
// if (strcmp(argv[2], "dialog")==0) // Вход из программы "диалог"
strcpy(namezad, argv[1]);
kadr_im(); // Прямой вход
i=argc;
i=schitn(); // Считывание начальной постановки
if (i!=0) {cout<<" Нет начальной постановки ! ";exit(1);}
i=schito(); // Задание или просмотр параметров счета
if (i!=0) {cout<<" Не могу обратиться к файлу <.о> ! ";exit (1);}
printf("\nНачало счета задачи %s\n\n",namezad);
razresh = atof(prr);
kur = atof(chk);
delta = atof(delt);
ststp = atoi(sho);
stzap = atoi(shz);
maxvisc = atof(vazmax);
minvisc = atof(vazmin);
markt = atoi(mkt);
ncr = (int)(dlina*razresh);
if (ncr>MNCR) {
cout<<" Количество ячеек расчетного поля больше допустимого !! ";
exit(1);}
part = 2*ncr;
// Константы обезразмеривания
lbez = 1/razresh; // Длина ячейки (мм)
robez= atof(obzro); // Плотность (г/см**3)
vbez = atof(obzv); // Скорость (км/с)
ebez = vbez*vbez; // Энергия (км/с)**2
tbez = lbez/vbez; // Время (мкс)
pbez = robez*vbez*vbez; // Давление (Гпа)
eps = 1e-10; // Обрезание производных
pkr = -1.0/pbez; // Ограничение снизу по давлению
krdr = 0.01; // Критерий дробления частицы
// -------------------------------------------------------
// Задание параметров частиц
// -------------------------------------------------------
for (i=0; i<=part; i++) {
m[i] = 0;
nb[i] = 0;
r[i] = 0.0;
v[i] = 0.0;
ro[i] = 0.0;
e[i] = 0.0;
l[i] = 0.0;
p[i] = 0.0; } // Конец очистки параметров частиц
for (np=0,k=0; k<ksl; k++) { // Цикл по слоям
if (nus[k]==1) index=1; // Ид.газ
if (nus[k]==2) { index=3; // Тэт
Curs[k][0]/=robez;
Curs[k][1]/=pbez;}
if (nus[k]==3) { index=3; // D-u
Curs[k][0]/=robez;
Curs[k][1]/=vbez;}
uro=Curs[k][index]/robez; // Начальная плотность
ue0=Curs[k][index+1]/ebez; // Начальная энергия
kchsl=(sr2[k]-sr1[k])*razresh; // Количество частиц в теле
cout<<" kchsl "<<kchsl<<" sr1[k] "<<sr1[k]<<" sr2[k] "<<sr2[k]<<" razresh "<<razresh;
for (j=0,i=np+1; i<=np+kchsl; j++,i++) { // Задание параметров частиц
m[i] = mrk[k]-1; // Маркеры: 0-первое тело, 1-второе... !!!
nb[i] = nus[k];
r[i] = (sr1[k]*razresh+j+0.5);
v[i] = sv[k]/vbez;
ro[i] = uro;
e[i] = ue0+v[i]*v[i]/2.0;
l[i] = 0.5;
p[i] = 0.0; } // Конец цикла задания параметров частиц
np+=kchsl; // Общее число частиц
} // Конец цикла по слоям
// =======================================================
// Начало расчета шага по времени
// =======================================================
begcalc:
dt = 0.033*nstp; // Увеличение dt до нормального за 30 шагов
cout<<" SumSk "<<sumsk;
w1 = kur/sumsk;
if (dt>w1) dt=w1;
if (dt*msk>delta) dt = delta/msk;
if (kur>10.0) dt = kur/1000.0/tbez;
sumsk = -975;
msk = 0.0;
kvisc = maxvisc;
cout<<" D_T "<<dt<<" W1 "<<w1<<" msk "<<msk<<" kur "<<kur<<" np "<<np<<"\n";
// -------------------------------------------------------
// Расчет дивергенции для вязкости
// -------------------------------------------------------
// Очистка сеточных массивов
for (i=0; i<=ncr; i++) {
c1[i] = 0;
c2[i] = 0.0;
c3[i] = 0.0;
c4[i] = 0.0; } // Конец цикла очистки сеточных массивов
// Цикл по частицам
for ( i=1; i<=np; i++) {
j = (int)(r[i]);
// c1 - маркеры
// с2 - сумма v*ro
// c3 - сумма ro
// c4 - итоговая скорость
w1 = ro[i]; // Плотность
w4 = v[i]*w1; // Плотность импульса
// В плоском случае раздаем массы
if (rad == 0) {
w1 *= 2*l[i];
w4 *= 2*l[i]; }
c1[j] = c1[j] | m[i];
c1[j+1] = c1[j+1] | m[i]; // Mаркировка ???
c2[j] += w4; c3[j] += w1;
c2[j+1] += w4; c3[j+1] += w1;
} // Конец цикла по частицам
// -------------------------------------------------------
// Находим значения скорости
// -------------------------------------------------------
for (j=0; j<=ncr; j++)
{if (c3[j] != 0.0) c4[j] = c2[j]/c3[j];}
// Закрытые границы - v=0
if (zgr1 == 1) c4[0] = 0.0;
if (zgr2 == 1) c4[ncr] = 0.0;
// Контактные границы ??
// Свободные границы ??
// -------------------------------------------------------
// Расчет силового этапа
// -------------------------------------------------------
// Очистка сеточных массивов
cout<<" Force ";
for (i=0; i<=ncr; i++) {
c2[i] = 0.0;
c3[i] = 0.0;
c5[i] = 0.0; } // Конец цикла очистки сеточных массивов
// Цикл по частицам
for ( i=1; i<=np; i++) {
j = (int)(r[i]);
es = e[i] - v[i]*v[i]/2.0; // Внутренняя энергия
if (es<0.0) es = 0.0;
ros = ro[i]; // Плотность
w3 = eos(m[i], &nb[i], ros, es, &cs);
//cout<<" eos "<<w3<<" ros "<<ros<<" es "<<es;
vr = c4[j+1] - c4[j]; // Производная скорости
w1 = fabs(vr); // Обрезание производной
if (w1<eps) vr=0.0;
w7 = -kvisc*vr*ro[i]*cs; // Искусственная вязкость
w9 = fabs(v[i]);
w5 = cs + (w9); // Макс. скорость сигнала
if (sumsk<w5) sumsk = w5;
if (msk<w9) msk = w9;
w3 += (w7); // Давление + вязкость
w10= 1/ro[i]; // Удельный объем частицы
if (w3<pkr) w3 = pkr; // Ограничение отриц. давл.
p[i] = w3; // Давление - в массив
// c2 - сумма давлений
// с3 - сумма удельных объемов
// c5 - итоговое давление */
c2[j] += (w3*w10); c3[j] += (w10);
c2[j+1] += (w3*w10); c3[j+1] += (w10);
} // Конец цикла по частицам
// -------------------------------------------------------
// Находим значения давления
// -------------------------------------------------------
for (j=0; j<=ncr; j++)
{if (c3[j] != 0) c5[j] = c2[j]/c3[j];}
// Давление на св. гр. = 0
for (j=1; j<=ncr-1; j++)
if (c3[j] == 0) {c5[j-1] = 0; c5[j+1] = 0;}
// -------------------------------------------------------
// Расчет промежуточных скоростей
// -------------------------------------------------------
// Очистка сеточных массивов
for (i=0; i<=ncr; i++) {
c2[i] = 0.0;
c3[i] = 0.0;
c4[i] = 0.0; } // Конец цикла очистки сеточных массивов
// Цикл по частицам
for ( i=1; i<=np; i++) {
j = (int)(r[i]);
// с2 - сумма v*ro
// c3 - сумма ro
// c4 - итоговая скорость */
fr = c5[j+1] - c5[j]; // Производная давления
w1 = fabs(fr); // Обрезание производной
if (w1<eps) fr=0.0;
w9 = v[i] - fr*dt/ro[i]; // Новая скорость
w1 = ro[i]; // Плотность
w8 = (w9+v[i])/2.0; // Полусумма ст. и нов. скор.
w4 = w8*w1; // Плотность импульса
v[i] = w9; // Сохранили скорость
// В плоском случае раздаем массы
if (rad == 0) {
w1 *= (2*l[i]);
w4 *= (2*l[i]); }
c2[j] += w4; c3[j] += w1;
c2[j+1] += w4; c3[j+1] += w1;
} // Конец цикла по частицам
// -------------------------------------------------------
// Находим значения сеточных скоростей
// -------------------------------------------------------
for (j=0; j<=ncr; j++)
{if (c3[j] != 0) c4[j] = c2[j]/c3[j];}
// Закрытые границы - v=0
if (zgr1 == 1) c4[0] = 0.0;
if (zgr2 == 1) c4[ncr] = 0.0;
// -------------------------------------------------------
// Расчет новых параметов частиц
// -------------------------------------------------------
// Цикл по частицам
for ( i=1; i<=np; i++) {
j = (int)(r[i]);
vr = c4[j+1] - c4[j]; // Производная скорости
w1 = fabs(vr); // Обрезание производной
if (w1<eps) vr=0.0;
w9 = c5[j+1] * c4[j+1];
w10 = c5[j] * c4[j];
pvr = w9 - w10; // Производная pv для энергии
w1 = fabs(pvr); // Обрезание производной
if (w1<eps) pvr=0.0;
// Дивергенция pv
if (rad==1) pvr += (w9+w10)/r[i]/2.0;
w6 = (c4[j+1]+c4[j])/2.0; // Скорость перемещения част.
e[i] -= (pvr*dt/ro[i]); // Новая полная энергия
// Старый объем
w9 = l[i];
if (rad==1) w9 *= r[i];
l[i] *= (1+vr*dt); // Новый размер частицы
rr = r[i]+(w6*dt); // Новая координата
// Отношение стар. об. к нов.
w9 /= l[i]; if (rad==1) w9 /= rr;
ro[i] *= w9; // Новая плотность
r[i] = rr; // Занесение координаты
// -------------------------------------------------------
// Взаимодействие с границами поля
// -------------------------------------------------------
if (j==0) { // Граница R = 0
w2 = rr-l[i]; // Нижняя граница частицы
i1or=(w2<-krdr) ? 1 : 0;
if (i1or) { // Перехлест !
if (zgr1==1) { // Действия при закрытой границе
v[i] = 0.0; // Частица останавливается
} // Конец закрытой границы R = 0
} // Конец перехлеста
} // Конец границы R = 0
if ((j+1)==ncr) { // Граница R = ncr
w2 = rr+l[i]; // Верхняя граница частицы
if ((w2-ncr)>krdr) { // Перехлест !
if (zgr1==1) { // Действия при закрытой границе
v[i] = 0.0; // Частица останавливается
} // Конец закрытой границы R = ncr
} // Конец перехлеста
} // Конец границы R = ncr
} // Конец цикла по частицам
// -------------------------------------------------------
// Этап дробления частиц
// -------------------------------------------------------
ii = part; // Дно массивов частиц
kolp = 0; // Счетчик числа новых частиц
// Цикл по частицам
for ( i=np; i>=1; i--) { // Начиная с последней к началу
j = (int)(r[i]);
w1 = r[i] - l[i]; // R нижняя
w2 = r[i] + l[i]; // R верхняя
// Есть ли дробление вверх
w4 = w2 -(j+1); // Часть в верхней ячейке
if (w4>krdr) { // Дробление вверх - перепись и правка
m[ii]=m[i]; nb[ii]=nb[i]; v[ii]=v[i];
ro[ii]=ro[i]; e[ii]=e[i];
l[ii]=w4/2.0; r[ii]=w2-l[ii];
w2 = j+1; // Верхний радиус коренной
ii--; kolp++;} // Конец дробления вверх
// Есть ли дробление вниз
w4 = j - w1;
drob = w4>krdr ? 1 : 0;
// Перепись коренной частицы
m[ii]=m[i]; nb[ii]=nb[i]; v[ii]=v[i];
ro[ii]=ro[i]; e[ii]=e[i];
w5 = drob==1 ? j : w1;
l[ii]=(w2-w5)/2.0; r[ii]=w2-l[ii];
ii--; kolp++; // Конец правки коренной
if (drob==1) {// Дробление вниз - перепись и правка
m[ii]=m[i]; nb[ii]=nb[i]; v[ii]=v[i];
ro[ii]=ro[i]; e[ii]=e[i];
l[ii]=(j-w1)/2.0; r[ii]=j-l[ii];
ii--; kolp++;} // Конец дробления вниз
} // Конец цикла по частицам
cout<<" Order ";
// -------------------------------------------------------
// Здесь может быть цикл по упорядочиванию частиц ???
// -------------------------------------------------------
// -------------------------------------------------------
// Этап объединения частиц
// -------------------------------------------------------
k = 1; // Начало объединенных частиц
i = ii+1; // Начало раздробленнных ч.
// Цикл по частицам
loopp:
if (i>part) goto endloopp;
// Переписываем очередную
m[k]=m[i]; nb[k]=nb[i]; v[k]=v[i];
ro[k]=ro[i]; e[k]=e[i]; l[k]=l[i]; r[k]=r[i];
j = (int)(r[i]); // Левый узел
i1 = m[i]; // Маркер
sled:i++;
j1 = (int)(r[i]);
i2 = m[i];
if ((j==j1) && (i1==i2)) { // Объединение
// Массы частиц
w3 = 2*ro[k]*l[k]; w4 = 2*ro[i]*l[i];
if (rad==1) {w3*=(2*PI*r[k]); w4*=(2*PI*r[i]);}
w5 = w3 + w4; // Суммарная масса
// Параметры объединения
r[k] = (r[k]+r[i]-l[k]+l[i])/2.0;
ro[k] = w5/(w3/ro[k]+w4/ro[i]);
v[k] = (w3*v[k]+w4*v[i])/w5;
e[k] = (w3*e[k]+w4*e[i])/w5;
l[k] += l[i];
goto sled; } // Конец объединения
k++;
goto loopp;
endloopp: np = k-1;
// Очистка оставшейся части массивов
for (i=k; i<=part; i++) {
m[i] = 0;
nb[i] = 0;
r[i] = 0.0;
v[i] = 0.0;
ro[i] = 0.0;
e[i] = 0.0;
l[i] = 0.0;
p[i] = 0.0; } // Конец очистки параметров частиц
t += dt; nstp++; izap++;
cout<<" Compare to write? nstp "<<nstp<<" izap "<<izap;
if (nstp==1) { // Открываем файл для записи таблиц
{char tmp[256];SetExt(namezad,tmp,"t");}//ii = open(tmp, O_CREAT,S_IWRITE);
ii=OP_F(namezad, ".t", 1);
if (ii<0) {
cout<<"Нельзя открыть файл <.t> на запись ! "<<ii<<"\n";exit(1);}}
if ((nstp==1)||(izap==stzap)) { // Запись результатов на диск
if (izap==stzap) {izap=0; nzap++;}
// -------------------------------------------------------
// Массивы для высвечивания
// -------------------------------------------------------
// Очистка сеточных массивов
for (i=0; i<=ncr; i++) {
c1[i] = 0;
c2[i] = 0.0;
c3[i] = 0.0;
c4[i] = 0.0;
c5[i] = 0.0;
} // Конец цикла очистки сеточных массивов
massa=0.0000001;
impulse=1.0000001;
energy=1.0000001;
// Цикл по частицам
for ( i=1; i<=np; i++) {
j = (int)(r[i]);
//c1 - вес
//с2 - плотность
//c3 - давление
//с4 - скорость
//c5 - внутренняя энергия
c1[j]++; c1[j+1]++;
c2[j] += ro[i]; c2[j+1] += ro[i];
c3[j] += p[i]; c3[j+1] += p[i];
c4[j] += v[i]; c4[j+1] += v[i];
c5[j] += e[i]-v[i]*v[i]/2.0;
c5[j+1] += e[i]-v[i]*v[i]/2.0;
// Сохранение
q = (rad==0) ? 2 : 4*PI*r[i];
i1or=(markt==0) ? 1 : 0;
i2or=(markt==m[i]) ? 1 : 0;
if (i1or || i2or) {
massa += (q*l[i]*ro[i]);
impulse += (massa*v[i]);
energy += (massa*e[i]);
} // Подсчета сохранения
} // Конец цикла по частицам
// -------------------------------------------------------
// Находим значения параметров
// -------------------------------------------------------
for (j=0; j<=ncr; j++) {
if (c1[j] != 0) {
c2[j] =robez*c2[j]/c1[j];
c3[j] = pbez*c3[j]/c1[j];
c4[j] = vbez*c4[j]/c1[j];
c5[j] = ebez*c5[j]/c1[j];
}}
// Закрытые границы - v=0
if (zgr1 == 1) c4[0] = 0.0;
if (zgr2 == 1) c4[ncr] = 0.0;
// Свободные границы-p=0
for (j=1; j<ncr; j++) {
if (c1[j] == 0) {
c3[j-1] = 0.0; c3[j+1] = 0.0; }
} // Конец цикла поиска свободных границ
w1=t*tbez;
size=sizeof(nzap); fwrite(&nzap, size, 1, stream);
fwrite(&nstp, size, 1, stream);
fwrite(&ncr, size, 1, stream);
fwrite(&markt, size, 1, stream);
ii=ncr+1;
size=sizeof(t); fwrite(&w1, size, 1, stream);
fwrite(&dlina, size, 1, stream);
fwrite(&massa, size, 1, stream);
fwrite(&impulse, size, 1, stream);
fwrite(&energy, size, 1, stream);
fwrite(&c2, size, ii, stream);
fwrite(&c3, size, ii, stream);
fwrite(&c4, size, ii, stream);
fwrite(&c5, size, ii, stream);
printf(" Запись %d Step = %d t(mks) = %f dt(mks) = %f\n",nzap,nstp,t*tbez,dt*tbez);
//pause();
} // Конец записи результатов на диск
// -------------------------------------------------------
// Шаг по времени завершен
// -------------------------------------------------------
if ((i=kbhit())!=0) {
printf("\n Пауза...\n Задача *%s* Step = %d t(mks) = %f dt(mks) = %f\n",
namezad,nstp,t*tbez,dt*tbez);
ii=pause(); if (ii==1) {
fclose(stream);exit(0);}} // КОНЕЦ РАБОТЫ
if (nstp==ststp) { fclose(stream); exit(0);} // KОНЕЦ РАБОТЫ
cout<<" After write ? goto BegCalc \n";
goto begcalc;
} // Конец MAIN - программы ==================================
void OnSetUserIP(LocalUser* user) override
{
// If user has sent NICK/USER, re-set the ExtItem as this is likely CGI:IRC changing the IP
if (user->registered == REG_NICKUSER)
SetExt(user);
}
//***********************************************************************************************
// Uses Fast Object Load if FTL file exists
//-----------------------------------------------------------------------------------------------
// VERIFIED (Cyril 2001/10/15)
//***********************************************************************************************
EERIE_3DOBJ * ARX_FTL_Load(const char * file)
{
// Creates FTL file name
char filename[256];
sprintf(filename, "Game\\%s", file);
SetExt(filename, ".FTL");
// Checks for FTL file existence
if(!PAK_FileExist(filename)) {
LogError<<"ARX_FTL_Load: not found in PAK" << filename;
return NULL;
}
// Our file exist we can use it
unsigned char * dat;
long pos = 0;
size_t allocsize;
ARX_FTL_PRIMARY_HEADER * afph;
ARX_FTL_SECONDARY_HEADER * afsh;
ARX_FTL_PROGRESSIVE_DATA_HEADER * afpdh;
ARX_FTL_CLOTHES_DATA_HEADER * afcdh;
ARX_FTL_COLLISION_SPHERES_DATA_HEADER * afcsdh;
ARX_FTL_3D_DATA_HEADER * af3Ddh;
char * compressedData = NULL;
size_t compressedSize = 0;
long NOrelease = 1;
long NoCheck = 0;
compressedData = MCache_Pop(filename, &compressedSize);
if (!compressedData)
{
compressedData = (char *)PAK_FileLoadMalloc(filename, &compressedSize);
NOrelease = MCache_Push(filename, compressedData, compressedSize) ? 1 : 0;
}
else NoCheck = 1;
if(!compressedData) {
printf("ARX_FTL_Load: error loading from PAK\n");
return NULL;
}
long DontCheck = 0;
DontCheck = 1;
dat = (unsigned char *)STD_Explode(compressedData, compressedSize, &allocsize);//pos,&cpr_pos);
// TODO size ignored
if(!dat) {
printf("ARX_FTL_Load: error decompressing\n");
return NULL;
}
if (!NOrelease) free(compressedData);
// Pointer to Primary Header
afph = (ARX_FTL_PRIMARY_HEADER *)dat;
pos += sizeof(ARX_FTL_PRIMARY_HEADER);
// Verify FTL file Signature
if ((afph->ident[0] != 'F') && (afph->ident[1] != 'T') && (afph->ident[2] != 'L'))
{
printf("ARX_FTL_Load: wrong magic number\n");
free(dat);
return NULL;
}
// Verify FTL file version
if (afph->version != CURRENT_FTL_VERSION)
{
printf("ARX_FTL_Load: wrong version: %f, expected %f\n", afph->version, CURRENT_FTL_VERSION);
free(dat);
return NULL;
}
// Verify Checksum
if ((!NOCHECKSUM || NoCheck) && !DontCheck)
{
char check[512];
HERMES_CreateFileCheck(file, check, 512, CURRENT_FTL_VERSION);
char * pouet = (char *)(dat + pos);
for (long i = 0; i < 512; i++)
if (check[i] != pouet[i])
{
printf("ARX_FTL_Load: checksum error\n");
free(dat);
return NULL;
}
}
// Increases offset by checksum size
pos += 512;
// Pointer to Secondary Header
afsh = (ARX_FTL_SECONDARY_HEADER *)(dat + pos);
pos += sizeof(ARX_FTL_SECONDARY_HEADER);
EERIE_3DOBJ * obj = NULL;
// Check For & Load 3D Data
if (afsh->offset_3Ddata != -1)
{
//todo free
obj = (EERIE_3DOBJ *)malloc(sizeof(EERIE_3DOBJ));
memset(obj, 0, sizeof(EERIE_3DOBJ));
af3Ddh = (ARX_FTL_3D_DATA_HEADER *)(dat + afsh->offset_3Ddata);
pos = afsh->offset_3Ddata;
pos += sizeof(ARX_FTL_3D_DATA_HEADER);
obj->nbvertex = af3Ddh->nb_vertex;
obj->nbfaces = af3Ddh->nb_faces;
obj->nbmaps = af3Ddh->nb_maps;
obj->nbgroups = af3Ddh->nb_groups;
obj->nbaction = af3Ddh->nb_action;
obj->nbselections = af3Ddh->nb_selections;
obj->origin = af3Ddh->origin;
strcpy(obj->file, af3Ddh->name);
// Alloc'n'Copy vertices
if (obj->nbvertex > 0)
{
//todo free
obj->vertexlist = (EERIE_VERTEX *)malloc(sizeof(EERIE_VERTEX) * obj->nbvertex);
obj->vertexlist3 = (EERIE_VERTEX *)malloc(sizeof(EERIE_VERTEX) * obj->nbvertex);
for (long ii = 0; ii < obj->nbvertex; ii++)
{
memcpy(&obj->vertexlist[ii], dat + pos, sizeof(EERIE_OLD_VERTEX));
memcpy(&obj->vertexlist3[ii], dat + pos, sizeof(EERIE_OLD_VERTEX));
pos += sizeof(EERIE_OLD_VERTEX);
}
obj->point0.x = obj->vertexlist[obj->origin].v.x;
obj->point0.y = obj->vertexlist[obj->origin].v.y;
obj->point0.z = obj->vertexlist[obj->origin].v.z;
for (long i = 0; i < obj->nbvertex; i++)
{
obj->vertexlist[i].vert.color = 0xFF000000;
obj->vertexlist3[i].vert.color = 0xFF000000;
}
}
// Alloc'n'Copy faces
if (obj->nbfaces > 0)
{
//todo free
obj->facelist = (EERIE_FACE *)malloc(sizeof(EERIE_FACE) * obj->nbfaces);
for (long ii = 0; ii < af3Ddh->nb_faces; ii++)
{
EERIE_FACE_FTL * eff = (EERIE_FACE_FTL *)(dat + pos);
obj->facelist[ii].facetype = eff->facetype;
obj->facelist[ii].texid = eff->texid;
obj->facelist[ii].transval = eff->transval;
obj->facelist[ii].temp = eff->temp;
memcpy(&obj->facelist[ii].norm, &eff->norm, sizeof(EERIE_3D));
for (long kk = 0; kk < IOPOLYVERT; kk++)
{
memcpy(&obj->facelist[ii].nrmls[kk], &eff->nrmls[kk], sizeof(EERIE_3D));
obj->facelist[ii].vid[kk] = eff->vid[kk];
obj->facelist[ii].u[kk] = eff->u[kk];
obj->facelist[ii].v[kk] = eff->v[kk];
obj->facelist[ii].ou[kk] = eff->ou[kk];
obj->facelist[ii].ov[kk] = eff->ov[kk];
}
pos += sizeof(EERIE_FACE_FTL);
}
}
// Alloc'n'Copy textures
if (af3Ddh->nb_maps > 0)
{
char ficc[256];
char ficc2[256];
char ficc3[256];
//todo free
obj->texturecontainer = (TextureContainer **)malloc(sizeof(TextureContainer *) * af3Ddh->nb_maps);
for (long i = 0; i < af3Ddh->nb_maps; i++)
{
memcpy(ficc2, dat + pos, 256);
strcpy(ficc3, ficc2);
File_Standardize(ficc3, ficc);
obj->texturecontainer[i] = D3DTextr_CreateTextureFromFile(ficc, 0, 0, EERIETEXTUREFLAG_LOADSCENE_RELEASE);
if (GDevice && obj->texturecontainer[i] && !obj->texturecontainer[i]->m_pddsSurface)
obj->texturecontainer[i]->Restore(GDevice);
MakeUserFlag(obj->texturecontainer[i]);
pos += 256;
}
}
// Alloc'n'Copy groups
if (obj->nbgroups > 0)
{
//todo free
obj->grouplist = (EERIE_GROUPLIST *)malloc(sizeof(EERIE_GROUPLIST) * obj->nbgroups);
memcpy(obj->grouplist, dat + pos, sizeof(EERIE_GROUPLIST) * obj->nbgroups);
pos += sizeof(EERIE_GROUPLIST) * obj->nbgroups;
for (long i = 0; i < obj->nbgroups; i++)
if (obj->grouplist[i].nb_index > 0)
{
//TO DO: FREE+++++++++++++++++++++++
obj->grouplist[i].indexes = (long *)malloc(sizeof(long) * obj->grouplist[i].nb_index);
memcpy(obj->grouplist[i].indexes, dat + pos, sizeof(long)*obj->grouplist[i].nb_index);
pos += sizeof(long) * obj->grouplist[i].nb_index;
}
}
// Alloc'n'Copy action points
if (obj->nbaction > 0)
{
//todo free
obj->actionlist = (EERIE_ACTIONLIST *)malloc(sizeof(EERIE_ACTIONLIST) * obj->nbaction);
memcpy(obj->actionlist, dat + pos, sizeof(EERIE_ACTIONLIST)*obj->nbaction);
pos += sizeof(EERIE_ACTIONLIST) * obj->nbaction;
}
// Alloc'n'Copy selections
if (obj->nbselections > 0)
{
//todo free++
obj->selections = (EERIE_SELECTIONS *)malloc(sizeof(EERIE_SELECTIONS) * obj->nbselections);
memcpy(obj->selections, dat + pos, sizeof(EERIE_SELECTIONS)*obj->nbselections);
pos += sizeof(EERIE_SELECTIONS) * obj->nbselections;
for (long i = 0; i < af3Ddh->nb_selections; i++)
{
//todo free+++
obj->selections[i].selected = (long *)malloc(sizeof(long) * obj->selections[i].nb_selected);
memcpy(obj->selections[i].selected, dat + pos, sizeof(long)*obj->selections[i].nb_selected);
pos += sizeof(long) * obj->selections[i].nb_selected;
}
}
obj->pbox = NULL;
}
if (!obj)
{
printf("ARX_FTL_Load: error loading data\n");
free(dat);
return NULL;
}
// Alloc'n'Copy Collision Spheres Data
if (afsh->offset_collision_spheres != -1)
{
afcsdh = (ARX_FTL_COLLISION_SPHERES_DATA_HEADER *)(dat + afsh->offset_collision_spheres);
pos = afsh->offset_collision_spheres;
pos += sizeof(ARX_FTL_COLLISION_SPHERES_DATA_HEADER);
obj->sdata = (COLLISION_SPHERES_DATA *)malloc(sizeof(COLLISION_SPHERES_DATA));
obj->sdata->nb_spheres = afcsdh->nb_spheres;
obj->sdata->spheres = (COLLISION_SPHERE *)malloc(sizeof(COLLISION_SPHERE) * obj->sdata->nb_spheres);
memcpy(obj->sdata->spheres, dat + pos, sizeof(COLLISION_SPHERE)*obj->sdata->nb_spheres);
pos += sizeof(COLLISION_SPHERE) * obj->sdata->nb_spheres;
}
// Alloc'n'Copy Progressive DATA
if (afsh->offset_progressive_data != -1)
{
afpdh = (ARX_FTL_PROGRESSIVE_DATA_HEADER *)(dat + afsh->offset_progressive_data);
pos = afsh->offset_progressive_data;
pos += sizeof(ARX_FTL_PROGRESSIVE_DATA_HEADER);
pos += sizeof(PROGRESSIVE_DATA) * afpdh->nb_vertex;
}
// Alloc'n'Copy Clothes DATA
if (afsh->offset_clothes_data != -1)
{
obj->cdata = (CLOTHES_DATA *)malloc(sizeof(CLOTHES_DATA));
memset(obj->cdata, 0, sizeof(CLOTHES_DATA));
afcdh = (ARX_FTL_CLOTHES_DATA_HEADER *)(dat + afsh->offset_clothes_data);
obj->cdata->nb_cvert = (short)afcdh->nb_cvert;
obj->cdata->nb_springs = (short)afcdh->nb_springs;
pos = afsh->offset_clothes_data;
pos += sizeof(ARX_FTL_CLOTHES_DATA_HEADER);
// now load cvert
obj->cdata->cvert = (CLOTHESVERTEX *)malloc(sizeof(CLOTHESVERTEX) * obj->cdata->nb_cvert);
obj->cdata->backup = (CLOTHESVERTEX *)malloc(sizeof(CLOTHESVERTEX) * obj->cdata->nb_cvert);
memcpy(obj->cdata->cvert, dat + pos, sizeof(CLOTHESVERTEX)*obj->cdata->nb_cvert);
memcpy(obj->cdata->backup, dat + pos, sizeof(CLOTHESVERTEX)*obj->cdata->nb_cvert);
pos += sizeof(CLOTHESVERTEX) * obj->cdata->nb_cvert;
// now load springs
obj->cdata->springs = (EERIE_SPRINGS *)malloc(sizeof(EERIE_SPRINGS) * obj->cdata->nb_springs);
memcpy(obj->cdata->springs, dat + pos, sizeof(EERIE_SPRINGS)*obj->cdata->nb_springs);
pos += sizeof(EERIE_SPRINGS) * obj->cdata->nb_springs;
}
free(dat);
if (BH_MODE)
EERIE_OBJECT_MakeBH(obj);
EERIE_OBJECT_CenterObjectCoordinates(obj);
EERIE_CreateCedricData(obj);
EERIEOBJECT_CreatePFaces(obj);
// Now we can release our cool FTL file
EERIE_Object_Precompute_Fast_Access(obj);
LogInfo<<"loaded "<< file;
return obj;
}
void EERIE_MESH_TWEAK_Do(INTERACTIVE_OBJ * io, long tw, char * _path)
{
if (!ALLOW_MESH_TWEAKING) return;
char file2[256];
char filet[256];
char path[256];
File_Standardize(_path, path);
strcpy(filet, "GAME\\");
strcat(filet, path);
SetExt(filet, ".FTL");
File_Standardize(filet, file2);
if ((!PAK_FileExist(file2)) && (!PAK_FileExist(path))) return;
if (tw == TWEAK_ERROR) return;
if (io == NULL) return;
if (io->obj == NULL) return;
EERIE_MESH_ReleaseTransPolys(io->obj);
if ((path == NULL) && (tw == TWEAK_REMOVE))
{
if (io->tweaky)
{
ReleaseEERIE3DObj(io->obj);
io->obj = io->tweaky;
EERIE_Object_Precompute_Fast_Access(io->obj);
io->tweaky = NULL;
}
return;
}
EERIE_3DOBJ * tobj = NULL;
EERIE_3DOBJ * result = NULL;
EERIE_3DOBJ * result2 = NULL;
if ((PAK_FileExist(file2)) || (PAK_FileExist(path)))
{
const char DIR_TEXTURES[] = "Graph\\Obj3D\\Textures\\";
if (io->ioflags & IO_NPC)
tobj = TheoToEerie_Fast(DIR_TEXTURES, path, TTE_NPC);
else
tobj = TheoToEerie_Fast(DIR_TEXTURES, path, 0);
if (!tobj) return;
switch (tw)
{
case TWEAK_ALL:
if (io->tweaky == NULL) io->tweaky = io->obj;
else ReleaseEERIE3DObj(io->obj);
long i;
TextureContainer * tc;
tc = NULL;
for (i = 0; i < tobj->nbfaces; i++)
{
if ((tobj->facelist[i].texid >= 0)
&& (tobj->texturecontainer[tobj->facelist[i].texid]))
{
tc = tobj->texturecontainer[tobj->facelist[i].texid];
if (!tc->m_pddsSurface)
tc->Restore(GDevice);
}
}
io->obj = tobj;
return;
break;
case TWEAK_UPPER:
result2 = CreateIntermediaryMesh(io->obj, tobj, TWEAK_HEAD);
result = CreateIntermediaryMesh(result2, tobj, TWEAK_TORSO);
ReleaseEERIE3DObj(result2);
break;
case TWEAK_LOWER:
result2 = CreateIntermediaryMesh(io->obj, tobj, TWEAK_TORSO);
result = CreateIntermediaryMesh(result2, tobj, TWEAK_LEGS);
ReleaseEERIE3DObj(result2);
break;
case TWEAK_UP_LO:
result = CreateIntermediaryMesh(tobj, io->obj, TWEAK_TORSO);
break;
default:
result = CreateIntermediaryMesh(io->obj, tobj, tw);
break;
}
if (result == NULL)
{
ReleaseEERIE3DObj(tobj);
return;
}
result->pdata = NULL;
result->cdata = NULL;
if (io->tweaky == NULL) io->tweaky = io->obj;
else if (io->tweaky != io->obj)
ReleaseEERIE3DObj(io->obj);
io->obj = result;
EERIE_Object_Precompute_Fast_Access(io->obj);
}
EERIE_CreateCedricData(io->obj);
if (io)
{
io->lastanimtime = 0;
io->nb_lastanimvertex = 0;
}
ReleaseEERIE3DObj(tobj);
}
//***********************************************************************************************
// Saves an FTL File
// Must pass the original name of the theo file
//-----------------------------------------------------------------------------------------------
// VERIFIED (Cyril 2001/10/15)
//***********************************************************************************************
bool ARX_FTL_Save(const char * file, EERIE_3DOBJ * obj)
{
// Need an object to be saved !
if (obj == NULL) return false;
// Generate File name/path and create it
char path[256];
char gamefic[256];
sprintf(gamefic, "Game\\%s", file);
SetExt(gamefic, ".FTL");
strcpy(path, gamefic);
RemoveName(path);
if (!CreateFullPath(path)) return NULL;
// create some usefull vars
ARX_FTL_PRIMARY_HEADER * afph;
ARX_FTL_SECONDARY_HEADER * afsh;
ARX_FTL_CLOTHES_DATA_HEADER * afcdh;
ARX_FTL_3D_DATA_HEADER * af3Ddh;
ARX_FTL_COLLISION_SPHERES_DATA_HEADER * afcsdh;
unsigned char * dat = NULL;
long pos = 0;
long allocsize = 8000000; // need to compute it more precisely
// Compute allocsize...
allocsize = sizeof(ARX_FTL_PRIMARY_HEADER)
+ 512 //checksum
+ sizeof(ARX_FTL_SECONDARY_HEADER)
+ sizeof(ARX_FTL_3D_DATA_HEADER)
+ sizeof(EERIE_OLD_VERTEX) * obj->nbvertex
+ sizeof(EERIE_FACE_FTL) * obj->nbfaces
+ obj->nbmaps * 256 // texturecontainernames
+ sizeof(EERIE_ACTIONLIST) * obj->nbaction
+ 128000; // just in case...
if (obj->nbgroups > 0)
{
allocsize += sizeof(EERIE_GROUPLIST) * obj->nbgroups;
for (long i = 0; i < obj->nbgroups; i++)
{
if (obj->grouplist[i].nb_index > 0)
{
allocsize += sizeof(long) * obj->grouplist[i].nb_index;
}
}
}
if (obj->nbselections > 0)
{
allocsize += sizeof(EERIE_SELECTIONS) * obj->nbselections;
for (long i = 0; i < obj->nbselections; i++)
{
allocsize += sizeof(long) * obj->selections[i].nb_selected;
}
}
if (obj->sdata && obj->sdata->nb_spheres) // Collision Spheres Data
{
allocsize += sizeof(ARX_FTL_COLLISION_SPHERES_DATA_HEADER);
allocsize += sizeof(COLLISION_SPHERE) * obj->sdata->nb_spheres;
}
if (obj->cdata) // Clothes DATA
{
allocsize += sizeof(ARX_FTL_CLOTHES_DATA_HEADER);
allocsize += sizeof(CLOTHESVERTEX) * obj->cdata->nb_cvert;
allocsize += sizeof(EERIE_SPRINGS) * obj->cdata->nb_springs;
}
// Finished computing allocsize Now allocate it...
dat = (unsigned char *)malloc(allocsize);
if (!dat)
HERMES_Memory_Emergency_Out();
memset(dat, 0, allocsize);
// Primary Header
afph = (ARX_FTL_PRIMARY_HEADER *)dat;
pos += sizeof(ARX_FTL_PRIMARY_HEADER);
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
afph->ident[0] = 'F';
afph->ident[1] = 'T';
afph->ident[2] = 'L';
afph->version = CURRENT_FTL_VERSION;
// Identification
char check[512];
HERMES_CreateFileCheck(file, check, 512, CURRENT_FTL_VERSION);
memcpy(dat + pos, check, 512);
pos += 512;
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
// Secondary Header
afsh = (ARX_FTL_SECONDARY_HEADER *)(dat + pos);
pos += sizeof(ARX_FTL_SECONDARY_HEADER);
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
// 3D Data
afsh->offset_3Ddata = pos; //-1;
af3Ddh = (ARX_FTL_3D_DATA_HEADER *)(dat + afsh->offset_3Ddata);
pos += sizeof(ARX_FTL_3D_DATA_HEADER);
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
af3Ddh->nb_vertex = obj->nbvertex;
af3Ddh->nb_faces = obj->nbfaces;
af3Ddh->nb_maps = obj->nbmaps;
af3Ddh->nb_groups = obj->nbgroups;
af3Ddh->nb_action = obj->nbaction;
af3Ddh->nb_selections = obj->nbselections;
af3Ddh->origin = obj->origin;
// vertexes
if (af3Ddh->nb_vertex > 0)
{
for (long ii = 0; ii < af3Ddh->nb_vertex; ii++)
{
memcpy(dat + pos, &obj->vertexlist[ii], sizeof(EERIE_OLD_VERTEX));
pos += sizeof(EERIE_OLD_VERTEX);
}
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
}
// faces
if (af3Ddh->nb_faces > 0)
{
for (long ii = 0; ii < af3Ddh->nb_faces; ii++)
{
EERIE_FACE_FTL * eff = (EERIE_FACE_FTL *)(dat + pos);
eff->facetype = obj->facelist[ii].facetype;
eff->texid = obj->facelist[ii].texid;
eff->transval = obj->facelist[ii].transval;
eff->temp = obj->facelist[ii].temp;
memcpy(&eff->norm, &obj->facelist[ii].norm, sizeof(EERIE_3D));
for (long kk = 0; kk < IOPOLYVERT; kk++)
{
memcpy(&eff->nrmls[kk], &obj->facelist[ii].nrmls[kk], sizeof(EERIE_3D));
eff->vid[kk] = obj->facelist[ii].vid[kk];
eff->u[kk] = obj->facelist[ii].u[kk];
eff->v[kk] = obj->facelist[ii].v[kk];
eff->ou[kk] = obj->facelist[ii].ou[kk];
eff->ov[kk] = obj->facelist[ii].ov[kk];
eff->rgb[kk] = 0;
}
pos += sizeof(EERIE_FACE_FTL);
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
}
}
// textures
for (long i = 0; i < af3Ddh->nb_maps; i++)
{
char ficc[256];
memset(ficc, 0, 256);
if (obj->texturecontainer[i])
strcpy(ficc, obj->texturecontainer[i]->m_texName);
memcpy(dat + pos, ficc, 256);
pos += 256;
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
}
// groups
if (af3Ddh->nb_groups > 0)
{
memcpy(dat + pos, obj->grouplist, sizeof(EERIE_GROUPLIST)*af3Ddh->nb_groups);
pos += sizeof(EERIE_GROUPLIST) * af3Ddh->nb_groups;
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
for (int i = 0; i < af3Ddh->nb_groups; i++)
{
if (obj->grouplist[i].nb_index > 0)
{
memcpy(dat + pos, obj->grouplist[i].indexes, sizeof(long)*obj->grouplist[i].nb_index);
pos += sizeof(long) * obj->grouplist[i].nb_index;
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
}
}
}
// actionpoints
if (af3Ddh->nb_action > 0)
{
memcpy(dat + pos, obj->actionlist, sizeof(EERIE_ACTIONLIST)*af3Ddh->nb_action);
pos += sizeof(EERIE_ACTIONLIST) * af3Ddh->nb_action;
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
}
// selections
if (af3Ddh->nb_selections > 0)
{
memcpy(dat + pos, obj->selections, sizeof(EERIE_SELECTIONS)*af3Ddh->nb_selections);
pos += sizeof(EERIE_SELECTIONS) * af3Ddh->nb_selections;
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
for (int i = 0; i < af3Ddh->nb_selections; i++)
{
memcpy(dat + pos, obj->selections[i].selected, sizeof(long)*obj->selections[i].nb_selected);
pos += sizeof(long) * obj->selections[i].nb_selected;
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
}
strcpy(af3Ddh->name, obj->file);
}
// Progressive DATA
afsh->offset_progressive_data = -1;
// Collision Spheres Data
if (obj->sdata && obj->sdata->nb_spheres)
{
afsh->offset_collision_spheres = pos; //-1;
afcsdh = (ARX_FTL_COLLISION_SPHERES_DATA_HEADER *)(dat + afsh->offset_collision_spheres);
pos += sizeof(ARX_FTL_COLLISION_SPHERES_DATA_HEADER);
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
afcsdh->nb_spheres = obj->sdata->nb_spheres;
memcpy(dat + pos, obj->sdata->spheres, sizeof(COLLISION_SPHERE)*obj->sdata->nb_spheres);
pos += sizeof(COLLISION_SPHERE) * obj->sdata->nb_spheres;
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
}
else afsh->offset_collision_spheres = -1;
// Clothes DATA
if (obj->cdata == NULL)
{
afsh->offset_clothes_data = -1;
}
else
{
afsh->offset_clothes_data = pos;
afcdh = (ARX_FTL_CLOTHES_DATA_HEADER *)(dat + afsh->offset_clothes_data);
afcdh->nb_cvert = obj->cdata->nb_cvert;
afcdh->nb_springs = obj->cdata->nb_springs;
pos += sizeof(ARX_FTL_CLOTHES_DATA_HEADER);
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
// now save cvert
memcpy(dat + pos, obj->cdata->cvert, sizeof(CLOTHESVERTEX)*obj->cdata->nb_cvert);
pos += sizeof(CLOTHESVERTEX) * obj->cdata->nb_cvert;
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
// now saves springs
memcpy(dat + pos, obj->cdata->springs, sizeof(EERIE_SPRINGS)*obj->cdata->nb_springs);
pos += sizeof(EERIE_SPRINGS) * obj->cdata->nb_springs;
if (pos > allocsize) ShowPopup("Invalid Allocsize in ARX_FTL_Save");
}
afsh->offset_physics_box = -1;
afsh->offset_cylinder = -1;
// Now we can flush our cool FTL file to the hard drive
FileHandle handle;
char _error[512];
if (pos > allocsize)
{
sprintf(_error, "Badly Allocated SaveBuffer...%s", gamefic);
goto error;
}
char * compressed;
compressed = NULL;
long cpr_pos;
cpr_pos = 0;
LogError <<"IMPLODE NOT IMPLEMENTED";
// TODO fix
//compressed = STD_Implode((char *)dat, pos, &cpr_pos);
// Now Saving Whole Buffer
if (!(handle = FileOpenWrite(gamefic)))
{
sprintf(_error, "Unable to Open %s for Write...", gamefic);
goto error;
}
if (FileWrite(handle, compressed, cpr_pos) != cpr_pos)
{
sprintf(_error, "Unable to Write to %s", gamefic);
goto error;
}
FileCloseWrite(handle);
free(compressed);
free(dat);
return true;
error:
;
ShowPopup(_error);
free(dat);
return false;
}
void CmdExtract::ExtrPrepareName(Archive &Arc,const wchar *ArcFileName,wchar *DestName,size_t DestSize)
{
wcsncpyz(DestName,Cmd->ExtrPath,DestSize);
// We need IsPathDiv check here to correctly handle Unix forward slash
// in the end of destination path in Windows: rar x arc dest/
if (*Cmd->ExtrPath!=0 && !IsPathDiv(*PointToLastChar(Cmd->ExtrPath)))
{
// Destination path can be without trailing slash if it come from GUI shell.
AddEndSlash(DestName,DestSize);
}
#ifndef SFX_MODULE
if (Cmd->AppendArcNameToPath)
{
wcsncatz(DestName,PointToName(Arc.FirstVolumeName),DestSize);
SetExt(DestName,NULL,DestSize);
AddEndSlash(DestName,DestSize);
}
#endif
#ifndef SFX_MODULE
size_t ArcPathLength=wcslen(Cmd->ArcPath);
if (ArcPathLength>0)
{
size_t NameLength=wcslen(ArcFileName);
ArcFileName+=Min(ArcPathLength,NameLength);
while (*ArcFileName==CPATHDIVIDER)
ArcFileName++;
if (*ArcFileName==0) // Excessive -ap switch.
{
*DestName=0;
return;
}
}
#endif
wchar Command=Cmd->Command[0];
// Use -ep3 only in systems, where disk letters are exist, not in Unix.
bool AbsPaths=Cmd->ExclPath==EXCL_ABSPATH && Command=='X' && IsDriveDiv(':');
// We do not use any user specified destination paths when extracting
// absolute paths in -ep3 mode.
if (AbsPaths)
*DestName=0;
if (Command=='E' || Cmd->ExclPath==EXCL_SKIPWHOLEPATH)
wcsncatz(DestName,PointToName(ArcFileName),DestSize);
else
wcsncatz(DestName,ArcFileName,DestSize);
wchar DiskLetter=toupperw(DestName[0]);
if (AbsPaths)
{
if (DestName[1]=='_' && IsPathDiv(DestName[2]) &&
DiskLetter>='A' && DiskLetter<='Z')
DestName[1]=':';
else
if (DestName[0]=='_' && DestName[1]=='_')
{
// Convert __server\share to \\server\share.
DestName[0]=CPATHDIVIDER;
DestName[1]=CPATHDIVIDER;
}
}
}
JSlidePiece::JSlidePiece()
{
m_pSlideGame = NULL;
SetFocusable( true );
SetExt( Frame( 0.0f, 0.0f, 140.0f, 130.0f ) );
} // JSlidePiece::JSlidePiece
