// preconditions: computer has no book
void CalcMPCStats(CPlayerComputer* computer, int height) {
FILE* cpFile;
CBitBoard bb;
int nbbs[60], i, iPos;
const int iPosMin=159; // start at this line, useful if stopping and restarting
CQPosition pos;
CCalcParams *cpOld=computer->pcp;
CHeightInfo hi(height, 0, false);
CCalcParamsFixedHeight cp(hi);
computer->pcp=&cp;
computer->cd.fsPrint=0;
// header info
std::cout << 3 << " " << height << " " << kStoneValue << "\n";
// clear computer's and params
//computer->cd.iPruneMidgame=computer->cd.iPruneEndgame=0;
// clear position counts and init
for (i=0; i<60; i++)
nbbs[i]=0;
iPos=0;
// read positions from file; analyze if we should
std::string fn(fnBaseDir);
fn+="captured.pos";
if ((cpFile=fopen(fn.c_str(),"rb"))) {
while (bb.Read(cpFile)) {
pos.Initialize(bb, true);
if (nbbs[bb.NEmpty()]++ < kMaxPositions)
if (iPos++>=iPosMin)
AnalyzePosition(computer, pos);
}
fclose(cpFile);
}
// restore computer's book and params
computer->pcp=cpOld;
}
int main(object me, string arg)
{
string src, dst, *dirs;
seteuid(geteuid(me));
if (!arg || sscanf(arg, "%s %s", src, dst)!=2 ) return
notify_fail("指令格式: cp <原档名> <目标档名> \n");
src = resolve_path(me->query("cwd"), src);
dst = resolve_path(me->query("cwd"), dst);
if( file_size(dst)==-2 ) {
dirs = explode(src, "/");
dst += "/" + dirs[sizeof(dirs)-1];
}
if( cp(src, dst) )
write("Ok.\n");
else
write("你没有足够的读写权利。\n");
return 1;
}
void Foam::ThermoParcel<ParcelType>::writeFields(const Cloud<ParcelType>& c)
{
KinematicParcel<ParcelType>::writeFields(c);
label np = c.size();
IOField<scalar> T(c.fieldIOobject("T", IOobject::NO_READ), np);
IOField<scalar> cp(c.fieldIOobject("cp", IOobject::NO_READ), np);
label i = 0;
forAllConstIter(typename Cloud<ParcelType>, c, iter)
{
const ThermoParcel<ParcelType>& p = iter();
T[i] = p.T_;
cp[i] = p.cp_;
i++;
}
T.write();
cp.write();
}
int main(int argc, char* argv[])
{
argc -= handleOpts(argc, argv);
if (argc < 2){
fprintf(stderr, "Usage: %s [config.ini]\n", argv[0]);
exit(1);
}
optClientno = atoi(argv[optind+1]);
ConfigParser cp(argv[optind]);
cp.Parse();
for (auto& section : cp._sections){
if (section.first.find("Workload") != std::string::npos){
std::string workload = section.first;
Config cfg(&cp, workload);
// SYSTEM-SPECIFIC
std::string system_conf;
if (!optServerPort) system_conf = cfg.get<std::string>("yesql", "");
else system_conf = std::string(optServerPort);
std::string dir = cfg.get<std::string>("logdir", ".");
if (dir.back() != '/')
dir.append("/");
dir.append("client-");
dir.append(std::to_string(optClientno));
dir.append("-");
dir.append(workload);
dir.append(".txt");
SetLog(dir.c_str());
LOG("Starting a YESQL expt.\n");
int nthreads = cfg.get<int>("threads", 1);
do_experiment(nthreads, system_conf.c_str(), &cfg, false);
}
}
return 0;
}
void CCurve::Reverse()
{
std::list<CVertex> new_vertices;
CVertex* prev_v = NULL;
for(std::list<CVertex>::reverse_iterator It = m_vertices.rbegin(); It != m_vertices.rend(); It++)
{
CVertex &v = *It;
int type = 0;
Point cp(0.0, 0.0);
if(prev_v)
{
type = -prev_v->m_type;
cp = prev_v->m_c;
}
CVertex new_v(type, v.m_p, cp);
new_vertices.push_back(new_v);
prev_v = &v;
}
m_vertices = new_vertices;
}
void do_tests() {
string foo, mid, all;
ASSERT(cp("/single/master.c", "/testfile"));
rm("/testfile.zerolength");
write_file("/testfile.zerolength", "");
foo = read_file("/testfile.zerolength");
ASSERT_EQ("", foo);
foo = read_bytes("/testfile");
mid = implode(explode(foo, "\n")[9..18], "\n") + "\n";
all = implode(explode(foo, "\n")[9..<1], "\n") + "\n";
ASSERT(!read_file("/single", 10, 10));
ASSERT(foo == read_file("/testfile"));
ASSERT(foo == read_file("/testfile.crlf"));
ASSERT_EQ(mid, read_file("/testfile", 10, 10));
// if we are asking more lines than in the file, return whole file
ASSERT(all == read_file("/testfile", 10, 0x7fffffff));
ASSERT(!read_file("/does_not_exist"));
ASSERT(!read_file("/testfile", 10000, 1));
}
static bool loadconfig(const char *fn, const char *section)
/* Loads and sets only the general configuration out of the file, named by
* 'fn', using the section 'section' therein. Returns true, if succeeded.
*/
{
CfgParse cp(fn);
if(cp.geterror() == CfgParse::NotFound) // file not found?
return false;
// Define config variables
cp.enum_vars(CONFIG_VARS);
if(!cp.section(section)) // Jump to section, if defined
return false;
do {
switch(cp.peekvar()) {
case 1: opl.setport(cp.readlong()); break;
case 14: oplforce = cp.readbool(); break;
case 23: mydb.load(cp.readstr()); break;
case 26:
if(!stricmp(cp.readstr(), "name"))
filesel.sortby = FileWnd::SortByName;
else if(!stricmp(cp.readstr(), "extension"))
filesel.sortby = FileWnd::SortByExtension;
break;
case 27:
if(!stricmp(cp.readstr(), "nothing")) onsongend = 0;
else if(!stricmp(cp.readstr(), "rewind")) onsongend = 1;
else if(!stricmp(cp.readstr(), "stop")) onsongend = 2;
break;
}
} while(!cp.geterror());
if(cp.geterror() == CfgParse::Invalid) return false; else return true;
}
vector<int> FormanGradientVector::count_critical_simplexes(){
vector<int> cp(3,0);
for(int i=0; i<mesh->getTopSimplexesNum(); i++){
if(is_face_critical(i))
cp[2]++;
}
for(int i=0; i<mesh->getNumVertex(); i++){
if(is_vertex_critical(i)){
cp[0]++;
}
vector<int> vv = mesh->VV(i);
for(auto v : vv){
if(v < i){
if(is_edge_critical(v,i))
cp[1]++;
}
}
}
return cp;
}
sp_mat Device1D::qCMatFunct(mat phin, mat phip, bool Equilibrum) {
if ( phin.n_elem != sumPoint || ( phip.n_elem != sumPoint ) )
std::cerr << "Error: input wrong phin/phip size!" << std::endl;
sp_mat cp=speye(sumPoint, sumPoint);
if (Equilibrum == true ) {
for ( int i = 0; i < bandGapArray.size(); i++) {
phip(i) = bandGapArray[i] - phin(i);
}
}
int k=0;
for ( int i=0; i < materialList.size(); i++) {
for ( int j=0; j < nyList[i]; j++) {
if (typeList[i] == Semiconductor) {
cp(k + 1, k + 1) = materialList[i].quantumCapa((double)phin(k), (double)phip(k)); //TODO: why here used to be k+1, then "cp(0, 0) = cp(1, 1);"
} else if (typeList[i]==Dielectric) {
};
k++;
};
};
return ( cp );
}
bool rayplane(float nx,float ny,float nz,float xs,float ys,float zs,float xd,float yd,float zd,coordinate p1,coordinate p2,coordinate p3,coordinate p4,float* dist,coordinate* point) {
float a=xd*nx+yd*ny+zd*nz;
if(a==0)
return false;
float t=((p1.x*nx+p1.y*ny+p1.z*nz-nx*xs-ny*ys-nz*zs)/a);
if(t<0)
return false;
float x=xs+t*xd;
float y=ys+t*yd;
float z=zs+t*zd;
coordinate cp(x,y,z);
if(abs(trianglearea(p1,p3,p4)-trianglearea(p1,p4,cp)-trianglearea(p1,p3,cp)-trianglearea(p3,p4,cp))<0.000001 || abs(trianglearea(p1,p2,p3)-trianglearea(p1,p2,cp)-trianglearea(p2,p3,cp)-trianglearea(p1,p3,cp))<0.000001) {
if(dist!=NULL) {
(*dist)=t;
if(point!=NULL) {
point->x=x;
point->y=y;
point->z=z;
}
}
return true;
}
return false;
}
int main()
{
title("Testing Socket Server", '=');
try
{
std::cout << "\n"<<"All files will be saved in ..\\Reciever\\RecievedFiles" << "\n\n";
std::cout << "\n" << "Please check appropriate Folder to check whether file is uploaded." << "\n";
SocketSystem ss;
SocketListener sl(9080, Socket::IP6);
BlockingQueue<std::string> queue1;
Reciever cp(queue1);
sl.start(cp);
std::cout.flush();
std::cin.get();
}
catch (std::exception& ex)
{
std::cout << ex.what();
/*Verbose::show(" Exception caught:", always);
Verbose::show(std::string("\n ") + ex.what() + "\n\n");*/
}
}
bool parallelPlanning(bool output, enum SPACE_TYPE space, std::vector<enum PLANNER_TYPE> &planners, unsigned int links,
unsigned int chains, struct ConstrainedOptions &c_opt, struct AtlasOptions &a_opt, bool bench)
{
// Create a shared pointer to our constraint.
auto constraint = std::make_shared<ParallelConstraint>(links, chains);
ConstrainedProblem cp(space, constraint->createSpace(), constraint);
cp.setConstrainedOptions(c_opt);
cp.setAtlasOptions(a_opt);
cp.css->registerProjection("parallel", constraint->getProjection(cp.css));
Eigen::VectorXd start, goal;
constraint->getStart(start);
constraint->getGoal(goal);
cp.setStartAndGoalStates(start, goal);
cp.ss->setStateValidityChecker(std::bind(&ParallelConstraint::isValid, constraint, std::placeholders::_1));
if (!bench)
return parallelPlanningOnce(cp, planners[0], output);
else
return parallelPlanningBench(cp, planners);
}
// A non-NULL pointer is a sprite mask, a NULL pointer means bbox should be used.
void *get_collision_mask(sprite* spr, unsigned char* input_data, collision_type ct) // It is called for every subimage of every sprite loaded.
{
switch (ct)
{
case ct_precise:
{
const unsigned int w = spr->width, h = spr->height;
unsigned char* colldata = new unsigned char[w*h];
for (unsigned int rowindex = 0; rowindex < h; rowindex++)
{
for(unsigned int colindex = 0; colindex < w; colindex++)
{
colldata[rowindex*w + colindex] = (input_data[4*(rowindex*w + colindex) + 3] != 0) ? 1 : 0; // If alpha != 0 then 1 else 0.
}
}
return colldata;
}
case ct_bbox: return 0;
case ct_ellipse:
{
// Create ellipse inside bbox.
const unsigned int w = spr->width, h = spr->height;
unsigned char* colldata = new unsigned char[w*h](); // Initialize all elements to 0.
const bbox_rect_t bbox = spr->bbox;
const unsigned int a = max(bbox.right-bbox.left, bbox.bottom-bbox.top)/2, // Major radius.
b = min(bbox.right-bbox.left, bbox.bottom-bbox.top)/2; // Minor radius.
const unsigned int xc = (bbox.right+bbox.left)/2, // Center of ellipse.
yc = (bbox.bottom+bbox.top)/2;
const long long a_2 = a*a, b_2 = b*b, a_2b_2 = a*a*b*b;
const int minX = max(bbox.left-2, 0),
minY = max(bbox.top-2, 0),
maxX = min(bbox.right+2, w),
maxY = min(bbox.bottom+2, h);
for (int y = minY; y < maxY; y++)
{
for(int x = minX; x < maxX; x++)
{
const int xcp = x-xc, ycp = y-yc; // Center to point.
const bool is_inside_ellipse = b_2*xcp*xcp + a_2*ycp*ycp <= a_2b_2;
colldata[y*w + x] = (is_inside_ellipse ? 1 : 0); // If point inside ellipse, 1, else 0.
}
}
return colldata;
}
case ct_diamond:
{
// Create diamond inside bbox.
const unsigned int w = spr->width, h = spr->height;
unsigned char* colldata = new unsigned char[w*h](); // Initialize all elements to 0.
const bbox_rect_t bbox = spr->bbox;
// Diamond corners.
const int xl = bbox.left, yl = (bbox.top + bbox.bottom)/2,
xr = bbox.right, yr = (bbox.top + bbox.bottom)/2,
xt = (bbox.left + bbox.right)/2, yt = bbox.top,
xb = (bbox.left + bbox.right)/2, yb = bbox.bottom;
const int xlt = xt-xl, ylt = yt-yl, // Left corner to top corner.
xlb = xb-xl, ylb = yb-yl, // Left corner to bottom corner.
xrt = xt-xr, yrt = yt-yr, // Right corner to top corner.
xrb = xb-xr, yrb = yb-yr; // Right corner to bottom corner.
const int minX = max(bbox.left-2, 0),
minY = max(bbox.top-2, 0),
maxX = min(bbox.right+2, w),
maxY = min(bbox.bottom+2, h);
for (int y = minY; y < maxY; y++)
{
for(int x = minX; x < maxX; x++)
{
const int xlp = x-xl, ylp = y-yl; // Left corner to point.
const int xrp = x-xr, yrp = y-yr; // Right corner to point.
const bool is_inside_diamond = cp(xlt, -ylt, xlp, -ylp) <= 0 && // Use cross-product to determine whether inside or outside diamond.
cp(xlb, -ylb, xlp, -ylp) >= 0 &&
cp(xrt, -yrt, xrp, -yrp) >= 0 &&
cp(xrb, -yrb, xrp, -yrp) <= 0;
colldata[y*w + x] = (is_inside_diamond ? 1 : 0); // If point inside diamond, 1, else 0.
}
}
return colldata;
}
case ct_polygon: return 0;
case ct_circle: //NOTE: Not tested.
{
// Create circle fitting inside bbox.
const unsigned int w = spr->width, h = spr->height;
unsigned char* colldata = new unsigned char[w*h](); // Initialize all elements to 0.
const bbox_rect_t bbox = spr->bbox;
const unsigned int r = min(bbox.right-bbox.left, bbox.bottom-bbox.top)/2; // Radius.
const unsigned int xc = (bbox.right+bbox.left)/2, // Center of circle.
yc = (bbox.bottom+bbox.top)/2;
const int r_2 = r*r;
const int minX = max(bbox.left-2, 0),
minY = max(bbox.top-2, 0),
maxX = min(bbox.right+2, w),
maxY = min(bbox.bottom+2, h);
for (int y = minY; y < maxY; y++)
{
for(int x = minX; x < maxX; x++)
{
const int xcp = x-xc, ycp = y-yc; // Center to point.
const bool is_inside_circle = xcp*xcp + ycp*ycp <= r_2;
colldata[y*w + x] = (is_inside_circle ? 1 : 0); // If point inside circle, 1, else 0.
}
}
return colldata;
}
default: return 0;
};
}
void plotSFspec(int iBr=0, int iBin=0,
int doSave=0,
double transLegendY_user=0.,
int vsEt=1) {
TString fname;
TString label1,label2,label3;
TString sfKindLongStr;
//TString sfKind;
double transLegendX=-0.2;
double transLegendY=-0.4;
TString saveFileTag;
label1="stat.error";
label2="stat.+syst.err.";
label3="stat.+syst.err.+add.syst.err";
if (iBr==0) {
fname="./egammaRECO.root";
sfKindLongStr="sf_RECO_ETBINS6ETABINS5";
saveFileTag="-cmpEgammaRECO";
transLegendX=-0.23;
//transLegendY=-0.2;
}
if (iBr==1) {
fname="./mediumID.root";
sfKindLongStr="sf_mediumID_ETBINS6ETABINS5";
saveFileTag="-cmpEgammaMediumID";
transLegendX=-0.23;
//transLegendY=-0.2;
}
//if (!vsEt) saveFileTag.Append("-vsEta");
if (transLegendY_user!=0.) transLegendY=transLegendY_user;
/*
if (iBr==0) sfKind="ID";
else if (iBr==1) sfKind="RECO";
else if (iBr==2) sfKind="HLT";
else {
std::cout << "iBr error\n";
return;
}
*/
DYTools::TEtBinSet_t etBinSet=DetermineEtBinSet(sfKindLongStr);
DYTools::TEtaBinSet_t etaBinSet=DetermineEtaBinSet(sfKindLongStr);
int nEtBins=DYTools::getNEtBins(etBinSet);
int nEtaBins=DYTools::getNEtaBins(etaBinSet);
std::cout << "sets: "<< EtBinSetName(etBinSet) << "," << EtaBinSetName(etaBinSet) << "\n";
TString effKind =effDataKindString(sfKindLongStr);
TString dataKind=effKind;
TMatrixD *sf=NULL, *sf1ErrLo=NULL, *sf1ErrHi=NULL;
TMatrixD *systRelErr=NULL, sf2ErrLo(nEtBins,nEtaBins), sf2ErrHi(nEtBins,nEtaBins);
TMatrixD *systRelErrTot=NULL, sf3ErrLo(nEtBins,nEtaBins), sf3ErrHi(nEtBins,nEtaBins);
// load the scale factors
if (!loadEGammaEff(fname,"sf",&sf,&sf1ErrLo,&sf1ErrHi)) {
std::cout << "failed to load EGammaSf\n";
return;
}
HERE("load egamma ok");
systRelErr=loadMatrix(fname,"sf_syst_rel_error_egamma",nEtBins,nEtaBins,1);
if (!systRelErr) return;
systRelErrTot=loadMatrix(fname,"sf_syst_rel_error",nEtBins,nEtaBins,1);
if (!systRelErrTot) return;
HERE("add errors");
addInQuadrature(*sf,*sf1ErrLo, *systRelErr, sf2ErrLo);
addInQuadrature(*sf,*sf1ErrHi, *systRelErr, sf2ErrHi);
addInQuadrature(*sf,*sf1ErrLo, *systRelErrTot, sf3ErrLo);
addInQuadrature(*sf,*sf1ErrHi, *systRelErrTot, sf3ErrHi);
HERE("create graphs");
TGraphAsymmErrors* gr1=getAsymGraph(vsEt, etBinSet,etaBinSet,iBin,*sf,*sf1ErrLo,*sf1ErrHi);
gr1->GetXaxis()->SetMoreLogLabels();
gr1->GetXaxis()->SetNoExponent();
gr1->Print("range");
TGraphAsymmErrors* gr2=getAsymGraph(vsEt, etBinSet,etaBinSet,iBin,*sf,sf2ErrLo,sf2ErrHi);
gr2->GetXaxis()->SetMoreLogLabels();
gr2->GetXaxis()->SetNoExponent();
gr2->Print("range");
TGraphAsymmErrors* gr3=getAsymGraph(vsEt, etBinSet,etaBinSet,iBin,*sf,sf3ErrLo,sf3ErrHi);
gr3->GetXaxis()->SetMoreLogLabels();
gr3->GetXaxis()->SetNoExponent();
gr3->Print("range");
double *loc_etBinLimits=DYTools::getEtBinLimits(etBinSet);
double *loc_etaBinLimits=DYTools::getEtaBinLimits(etaBinSet);
int signedEta=DYTools::signedEtaBinning(etaBinSet);
TString binStrForTitle=(vsEt) ? TString(Form(" %5.3lf #leq %s #leq %5.3lf",loc_etaBinLimits[iBin],(signedEta)?"#eta":"abs(#eta)",loc_etaBinLimits[iBin+1])) :
TString(Form(" %2.0lf #leq #it{E}_{T} #leq %2.0lf GeV",loc_etBinLimits[iBin],loc_etBinLimits[iBin+1]));
TString cpTitle=dataKind+ binStrForTitle;
TString xAxisTitle="#it{E}_{T} [GeV]";
if (!vsEt) xAxisTitle=(signedEta) ? "#eta" : "|#eta|";
ComparisonPlot_t cp(ComparisonPlot_t::_ratioPlain,"comp",cpTitle,
xAxisTitle,effKind + TString(" scale factor"),"ratio");
cp.SetRefIdx(-111); // no ratio plot
if (vsEt) cp.SetLogx();
cp.AddLine(10.,1.,500.,1.,kBlack,2);
TCanvas *cx=new TCanvas("cx","cx",600,600);
SetSideSpaces(cx,0.05,0.,0.,0.02);
gr1->GetYaxis()->SetTitleOffset(1.4);
//cp.AddGraph(gr3,label3,"LPE",43); //kRed+3);
cp.AddGraph(gr3,label3,"LPE",kRed); //kRed+3);
cp.AddGraph(gr2,label2,"LPE",38); //kBlue+2);
cp.AddGraph(gr1,label1," PE",kBlack,20); //24
cp.Draw(cx,0,"png",0);
cp.TransLegend(transLegendX, transLegendY);
cp.WidenLegend(0.25,0.);
cx->Update();
// Save file
if (saveFileTag.Length()) {
TString outfname=TString("fig-sf-egamma-") + cpTitle;
outfname.ReplaceAll(" #leq "," ");
outfname.ReplaceAll(" ","_");
outfname.ReplaceAll("(#eta)","Eta");
outfname.ReplaceAll("#eta","eta");
outfname.ReplaceAll(".","_");
outfname.ReplaceAll("#it{E}_{T}","Et");
//fname.Append(".png");
std::cout << "outfname=" << outfname << "\n";
TString locOutDir=TString("plots") + saveFileTag;
if (doSave) {
locOutDir.ReplaceAll("--","");
SaveCanvas(cx,outfname,locOutDir);
}
else {
std::cout << "... canvas not saved, as requested\n";
std::cout << " locOutDir=" << locOutDir << "\n";
}
}
return ;
}
static int mv(const std::string& src, const std::string& dest)
{
cp(src, dest);
return remove(src.c_str());
}
void GDFunctions::call(Function p_func,const Variant **p_args,int p_arg_count,Variant &r_ret,Variant::CallError &r_error) {
r_error.error=Variant::CallError::CALL_OK;
#ifdef DEBUG_ENABLED
#define VALIDATE_ARG_COUNT(m_count) \
if (p_arg_count<m_count) {\
r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;\
r_error.argument=m_count;\
r_ret=Variant();\
return;\
}\
if (p_arg_count>m_count) {\
r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;\
r_error.argument=m_count;\
r_ret=Variant();\
return;\
}
#define VALIDATE_ARG_NUM(m_arg) \
if (!p_args[m_arg]->is_num()) {\
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;\
r_error.argument=m_arg;\
r_error.expected=Variant::REAL;\
r_ret=Variant();\
return;\
}
#else
#define VALIDATE_ARG_COUNT(m_count)
#define VALIDATE_ARG_NUM(m_arg)
#endif
//using a switch, so the compiler generates a jumptable
switch(p_func) {
case MATH_SIN: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::sin((double)*p_args[0]);
} break;
case MATH_COS: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::cos((double)*p_args[0]);
} break;
case MATH_TAN: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::tan((double)*p_args[0]);
} break;
case MATH_SINH: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::sinh((double)*p_args[0]);
} break;
case MATH_COSH: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::cosh((double)*p_args[0]);
} break;
case MATH_TANH: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::tanh((double)*p_args[0]);
} break;
case MATH_ASIN: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::asin((double)*p_args[0]);
} break;
case MATH_ACOS: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::acos((double)*p_args[0]);
} break;
case MATH_ATAN: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::atan((double)*p_args[0]);
} break;
case MATH_ATAN2: {
VALIDATE_ARG_COUNT(2);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
r_ret=Math::atan2((double)*p_args[0],(double)*p_args[1]);
} break;
case MATH_SQRT: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::sqrt((double)*p_args[0]);
} break;
case MATH_FMOD: {
VALIDATE_ARG_COUNT(2);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
r_ret=Math::fmod((double)*p_args[0],(double)*p_args[1]);
} break;
case MATH_FPOSMOD: {
VALIDATE_ARG_COUNT(2);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
r_ret=Math::fposmod((double)*p_args[0],(double)*p_args[1]);
} break;
case MATH_FLOOR: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::floor((double)*p_args[0]);
} break;
case MATH_CEIL: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::ceil((double)*p_args[0]);
} break;
case MATH_ROUND: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::round((double)*p_args[0]);
} break;
case MATH_ABS: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()==Variant::INT) {
int64_t i = *p_args[0];
r_ret=ABS(i);
} else if (p_args[0]->get_type()==Variant::REAL) {
double r = *p_args[0];
r_ret=Math::abs(r);
} else {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::REAL;
r_ret=Variant();
}
} break;
case MATH_SIGN: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()==Variant::INT) {
int64_t i = *p_args[0];
r_ret= i < 0 ? -1 : ( i > 0 ? +1 : 0);
} else if (p_args[0]->get_type()==Variant::REAL) {
real_t r = *p_args[0];
r_ret= r < 0.0 ? -1.0 : ( r > 0.0 ? +1.0 : 0.0);
} else {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::REAL;
r_ret=Variant();
}
} break;
case MATH_POW: {
VALIDATE_ARG_COUNT(2);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
r_ret=Math::pow((double)*p_args[0],(double)*p_args[1]);
} break;
case MATH_LOG: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::log((double)*p_args[0]);
} break;
case MATH_EXP: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::exp((double)*p_args[0]);
} break;
case MATH_ISNAN: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::is_nan((double)*p_args[0]);
} break;
case MATH_ISINF: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::is_inf((double)*p_args[0]);
} break;
case MATH_EASE: {
VALIDATE_ARG_COUNT(2);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
r_ret=Math::ease((double)*p_args[0],(double)*p_args[1]);
} break;
case MATH_DECIMALS: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::step_decimals((double)*p_args[0]);
} break;
case MATH_STEPIFY: {
VALIDATE_ARG_COUNT(2);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
r_ret=Math::stepify((double)*p_args[0],(double)*p_args[1]);
} break;
case MATH_LERP: {
VALIDATE_ARG_COUNT(3);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
r_ret=Math::lerp((double)*p_args[0],(double)*p_args[1],(double)*p_args[2]);
} break;
case MATH_DECTIME: {
VALIDATE_ARG_COUNT(3);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
r_ret=Math::dectime((double)*p_args[0],(double)*p_args[1],(double)*p_args[2]);
} break;
case MATH_RANDOMIZE: {
Math::randomize();
r_ret=Variant();
} break;
case MATH_RAND: {
r_ret=Math::rand();
} break;
case MATH_RANDF: {
r_ret=Math::randf();
} break;
case MATH_RANDOM: {
VALIDATE_ARG_COUNT(2);
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
r_ret=Math::random((double)*p_args[0],(double)*p_args[1]);
} break;
case MATH_SEED: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
uint64_t seed=*p_args[0];
Math::seed(seed);
r_ret=Variant();
} break;
case MATH_RANDSEED: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
uint64_t seed=*p_args[0];
int ret = Math::rand_from_seed(&seed);
Array reta;
reta.push_back(ret);
reta.push_back(seed);
r_ret=reta;
} break;
case MATH_DEG2RAD: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::deg2rad((double)*p_args[0]);
} break;
case MATH_RAD2DEG: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::rad2deg((double)*p_args[0]);
} break;
case MATH_LINEAR2DB: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::linear2db((double)*p_args[0]);
} break;
case MATH_DB2LINEAR: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
r_ret=Math::db2linear((double)*p_args[0]);
} break;
case LOGIC_MAX: {
VALIDATE_ARG_COUNT(2);
if (p_args[0]->get_type()==Variant::INT && p_args[1]->get_type()==Variant::INT) {
int64_t a = *p_args[0];
int64_t b = *p_args[1];
r_ret=MAX(a,b);
} else {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
real_t a = *p_args[0];
real_t b = *p_args[1];
r_ret=MAX(a,b);
}
} break;
case LOGIC_MIN: {
VALIDATE_ARG_COUNT(2);
if (p_args[0]->get_type()==Variant::INT && p_args[1]->get_type()==Variant::INT) {
int64_t a = *p_args[0];
int64_t b = *p_args[1];
r_ret=MIN(a,b);
} else {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
real_t a = *p_args[0];
real_t b = *p_args[1];
r_ret=MIN(a,b);
}
} break;
case LOGIC_CLAMP: {
VALIDATE_ARG_COUNT(3);
if (p_args[0]->get_type()==Variant::INT && p_args[1]->get_type()==Variant::INT && p_args[2]->get_type()==Variant::INT) {
int64_t a = *p_args[0];
int64_t b = *p_args[1];
int64_t c = *p_args[2];
r_ret=CLAMP(a,b,c);
} else {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
real_t a = *p_args[0];
real_t b = *p_args[1];
real_t c = *p_args[2];
r_ret=CLAMP(a,b,c);
}
} break;
case LOGIC_NEAREST_PO2: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
int64_t num = *p_args[0];
r_ret = nearest_power_of_2(num);
} break;
case OBJ_WEAKREF: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()!=Variant::OBJECT) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::OBJECT;
r_ret=Variant();
return;
}
if (p_args[0]->is_ref()) {
REF r = *p_args[0];
if (!r.is_valid()) {
r_ret=Variant();
return;
}
Ref<WeakRef> wref = memnew( WeakRef );
wref->set_ref(r);
r_ret=wref;
} else {
Object *obj = *p_args[0];
if (!obj) {
r_ret=Variant();
return;
}
Ref<WeakRef> wref = memnew( WeakRef );
wref->set_obj(obj);
r_ret=wref;
}
} break;
case FUNC_FUNCREF: {
VALIDATE_ARG_COUNT(2);
if (p_args[0]->get_type()!=Variant::OBJECT) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::OBJECT;
r_ret=Variant();
return;
}
if (p_args[1]->get_type()!=Variant::STRING && p_args[1]->get_type()!=Variant::NODE_PATH) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=1;
r_error.expected=Variant::STRING;
r_ret=Variant();
return;
}
Ref<FuncRef> fr = memnew( FuncRef);
fr->set_instance(*p_args[0]);
fr->set_function(*p_args[1]);
r_ret=fr;
} break;
case TYPE_CONVERT: {
VALIDATE_ARG_COUNT(2);
VALIDATE_ARG_NUM(1);
int type=*p_args[1];
if (type<0 || type>=Variant::VARIANT_MAX) {
r_ret=RTR("Invalid type argument to convert(), use TYPE_* constants.");
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::INT;
return;
} else {
r_ret=Variant::construct(Variant::Type(type),p_args,1,r_error);
}
} break;
case TYPE_OF: {
VALIDATE_ARG_COUNT(1);
r_ret = p_args[0]->get_type();
} break;
case TYPE_EXISTS: {
VALIDATE_ARG_COUNT(1);
r_ret = ClassDB::class_exists(*p_args[0]);
} break;
case TEXT_CHAR: {
VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0);
CharType result[2] = {*p_args[0], 0};
r_ret=String(result);
} break;
case TEXT_STR: {
String str;
for(int i=0;i<p_arg_count;i++) {
String os = p_args[i]->operator String();
if (i==0)
str=os;
else
str+=os;
}
r_ret=str;
} break;
case TEXT_PRINT: {
String str;
for(int i=0;i<p_arg_count;i++) {
str+=p_args[i]->operator String();
}
//str+="\n";
print_line(str);
r_ret=Variant();
} break;
case TEXT_PRINT_TABBED: {
String str;
for(int i=0;i<p_arg_count;i++) {
if (i)
str+="\t";
str+=p_args[i]->operator String();
}
//str+="\n";
print_line(str);
r_ret=Variant();
} break;
case TEXT_PRINT_SPACED: {
String str;
for(int i=0;i<p_arg_count;i++) {
if (i)
str+=" ";
str+=p_args[i]->operator String();
}
//str+="\n";
print_line(str);
r_ret=Variant();
} break;
case TEXT_PRINTERR: {
String str;
for(int i=0;i<p_arg_count;i++) {
str+=p_args[i]->operator String();
}
//str+="\n";
OS::get_singleton()->printerr("%s\n",str.utf8().get_data());
r_ret=Variant();
} break;
case TEXT_PRINTRAW: {
String str;
for(int i=0;i<p_arg_count;i++) {
str+=p_args[i]->operator String();
}
//str+="\n";
OS::get_singleton()->print("%s",str.utf8().get_data());
r_ret=Variant();
} break;
case VAR_TO_STR: {
VALIDATE_ARG_COUNT(1);
String vars;
VariantWriter::write_to_string(*p_args[0],vars);
r_ret=vars;
} break;
case STR_TO_VAR: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()!=Variant::STRING) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::STRING;
r_ret=Variant();
return;
}
VariantParser::StreamString ss;
ss.s=*p_args[0];
String errs;
int line;
Error err = VariantParser::parse(&ss,r_ret,errs,line);
if (err!=OK) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::STRING;
r_ret="Parse error at line "+itos(line)+": "+errs;
return;
}
} break;
case VAR_TO_BYTES: {
VALIDATE_ARG_COUNT(1);
PoolByteArray barr;
int len;
Error err = encode_variant(*p_args[0],NULL,len);
if (err) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::NIL;
r_ret="Unexpected error encoding variable to bytes, likely unserializable type found (Object or RID).";
return;
}
barr.resize(len);
{
PoolByteArray::Write w = barr.write();
encode_variant(*p_args[0],w.ptr(),len);
}
r_ret=barr;
} break;
case BYTES_TO_VAR: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()!=Variant::POOL_BYTE_ARRAY) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::POOL_BYTE_ARRAY;
r_ret=Variant();
return;
}
PoolByteArray varr=*p_args[0];
Variant ret;
{
PoolByteArray::Read r=varr.read();
Error err = decode_variant(ret,r.ptr(),varr.size(),NULL);
if (err!=OK) {
r_ret=RTR("Not enough bytes for decoding bytes, or invalid format.");
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::POOL_BYTE_ARRAY;
return;
}
}
r_ret=ret;
} break;
case GEN_RANGE: {
switch(p_arg_count) {
case 0: {
r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
r_error.argument=1;
r_ret=Variant();
} break;
case 1: {
VALIDATE_ARG_NUM(0);
int count=*p_args[0];
Array arr;
if (count<=0) {
r_ret=arr;
return;
}
Error err = arr.resize(count);
if (err!=OK) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
r_ret=Variant();
return;
}
for(int i=0;i<count;i++) {
arr[i]=i;
}
r_ret=arr;
} break;
case 2: {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
int from=*p_args[0];
int to=*p_args[1];
Array arr;
if (from>=to) {
r_ret=arr;
return;
}
Error err = arr.resize(to-from);
if (err!=OK) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
r_ret=Variant();
return;
}
for(int i=from;i<to;i++)
arr[i-from]=i;
r_ret=arr;
} break;
case 3: {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
int from=*p_args[0];
int to=*p_args[1];
int incr=*p_args[2];
if (incr==0) {
r_ret=RTR("step argument is zero!");
r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
return;
}
Array arr;
if (from>=to && incr>0) {
r_ret=arr;
return;
}
if (from<=to && incr<0) {
r_ret=arr;
return;
}
//calculate how many
int count=0;
if (incr>0) {
count=((to-from-1)/incr)+1;
} else {
count=((from-to-1)/-incr)+1;
}
Error err = arr.resize(count);
if (err!=OK) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
r_ret=Variant();
return;
}
if (incr>0) {
int idx=0;
for(int i=from;i<to;i+=incr) {
arr[idx++]=i;
}
} else {
int idx=0;
for(int i=from;i>to;i+=incr) {
arr[idx++]=i;
}
}
r_ret=arr;
} break;
default: {
r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
r_error.argument=3;
r_ret=Variant();
} break;
}
} break;
case RESOURCE_LOAD: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()!=Variant::STRING) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::STRING;
r_ret=Variant();
} else {
r_ret=ResourceLoader::load(*p_args[0]);
}
} break;
case INST2DICT: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()==Variant::NIL) {
r_ret=Variant();
} else if (p_args[0]->get_type()!=Variant::OBJECT) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_ret=Variant();
} else {
Object *obj = *p_args[0];
if (!obj) {
r_ret=Variant();
} else if (!obj->get_script_instance() || obj->get_script_instance()->get_language()!=GDScriptLanguage::get_singleton()) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::DICTIONARY;
r_ret=RTR("Not a script with an instance");
return;
} else {
GDInstance *ins = static_cast<GDInstance*>(obj->get_script_instance());
Ref<GDScript> base = ins->get_script();
if (base.is_null()) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::DICTIONARY;
r_ret=RTR("Not based on a script");
return;
}
GDScript *p = base.ptr();
Vector<StringName> sname;
while(p->_owner) {
sname.push_back(p->name);
p=p->_owner;
}
sname.invert();
if (!p->path.is_resource_file()) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::DICTIONARY;
r_ret=Variant();
r_ret=RTR("Not based on a resource file");
return;
}
NodePath cp(sname,Vector<StringName>(),false);
Dictionary d;
d["@subpath"]=cp;
d["@path"]=p->path;
p = base.ptr();
while(p) {
for(Set<StringName>::Element *E=p->members.front();E;E=E->next()) {
Variant value;
if (ins->get(E->get(),value)) {
String k = E->get();
if (!d.has(k)) {
d[k]=value;
}
}
}
p=p->_base;
}
r_ret=d;
}
}
} break;
case DICT2INST: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()!=Variant::DICTIONARY) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::DICTIONARY;
r_ret=Variant();
return;
}
Dictionary d = *p_args[0];
if (!d.has("@path")) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::OBJECT;
r_ret=RTR("Invalid instance dictionary format (missing @path)");
return;
}
Ref<Script> scr = ResourceLoader::load(d["@path"]);
if (!scr.is_valid()) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::OBJECT;
r_ret=RTR("Invalid instance dictionary format (can't load script at @path)");
return;
}
Ref<GDScript> gdscr = scr;
if (!gdscr.is_valid()) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::OBJECT;
r_ret=Variant();
r_ret=RTR("Invalid instance dictionary format (invalid script at @path)");
return;
}
NodePath sub;
if (d.has("@subpath")) {
sub=d["@subpath"];
}
for(int i=0;i<sub.get_name_count();i++) {
gdscr = gdscr->subclasses[ sub.get_name(i)];
if (!gdscr.is_valid()) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::OBJECT;
r_ret=Variant();
r_ret=RTR("Invalid instance dictionary (invalid subclasses)");
return;
}
}
r_ret = gdscr->_new(NULL,0,r_error);
GDInstance *ins = static_cast<GDInstance*>(static_cast<Object*>(r_ret)->get_script_instance());
Ref<GDScript> gd_ref = ins->get_script();
for(Map<StringName,GDScript::MemberInfo>::Element *E = gd_ref->member_indices.front(); E; E = E->next()) {
if(d.has(E->key())) {
ins->members[E->get().index] = d[E->key()];
}
}
} break;
case VALIDATE_JSON: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()!=Variant::STRING) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::STRING;
r_ret=Variant();
return;
}
String errs;
int errl;
Error err = JSON::parse(*p_args[0],r_ret,errs,errl);
if (err!=OK) {
r_ret=itos(errl)+":"+errs;
} else {
r_ret="";
}
} break;
case PARSE_JSON: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()!=Variant::STRING) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::STRING;
r_ret=Variant();
return;
}
String errs;
int errl;
Error err = JSON::parse(*p_args[0],r_ret,errs,errl);
if (err!=OK) {
r_ret=Variant();
}
} break;
case TO_JSON: {
VALIDATE_ARG_COUNT(1);
r_ret = JSON::print(*p_args[0]);
} break;
case HASH: {
VALIDATE_ARG_COUNT(1);
r_ret=p_args[0]->hash();
} break;
case COLOR8: {
if (p_arg_count<3) {
r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
r_error.argument=3;
r_ret=Variant();
return;
}
if (p_arg_count>4) {
r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
r_error.argument=4;
r_ret=Variant();
return;
}
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
Color color((float)*p_args[0]/255.0f,(float)*p_args[1]/255.0f,(float)*p_args[2]/255.0f);
if (p_arg_count==4) {
VALIDATE_ARG_NUM(3);
color.a=(float)*p_args[3]/255.0f;
}
r_ret=color;
} break;
case COLORN: {
if (p_arg_count<1) {
r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
r_error.argument=1;
r_ret=Variant();
return;
}
if (p_arg_count>2) {
r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
r_error.argument=2;
r_ret=Variant();
return;
}
if (p_args[0]->get_type()!=Variant::STRING) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_ret=Variant();
} else {
Color color = Color::named(*p_args[0]);
if (p_arg_count==2) {
VALIDATE_ARG_NUM(1);
color.a=*p_args[1];
}
r_ret=color;
}
} break;
case PRINT_STACK: {
ScriptLanguage* script = GDScriptLanguage::get_singleton();
for (int i=0; i < script->debug_get_stack_level_count(); i++) {
print_line("Frame "+itos(i)+" - "+script->debug_get_stack_level_source(i)+":"+itos(script->debug_get_stack_level_line(i))+" in function '"+script->debug_get_stack_level_function(i)+"'");
};
} break;
case INSTANCE_FROM_ID: {
VALIDATE_ARG_COUNT(1);
if (p_args[0]->get_type()!=Variant::INT && p_args[0]->get_type()!=Variant::REAL) {
r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument=0;
r_error.expected=Variant::INT;
r_ret=Variant();
break;
}
uint32_t id=*p_args[0];
r_ret=ObjectDB::get_instance(id);
} break;
case FUNC_MAX: {
ERR_FAIL();
} break;
}
}
int gameswf::tools::process_swf(tu_file* swf_out, tu_file* in, const process_options& options)
{
assert(in && in->get_error() == TU_FILE_NO_ERROR);
assert(swf_out && swf_out->get_error() == TU_FILE_NO_ERROR);
// @@ Copied & adapted from movie_def_impl::read()
// @@ TODO share this wrapper code somehow (also with gameswf_parser)
Uint32 file_start_pos = in->get_position();
Uint32 header = in->read_le32();
Uint32 file_length = in->read_le32();
Uint32 file_end_pos = file_start_pos + file_length;
int version = (header >> 24) & 255;
if ((header & 0x0FFFFFF) != 0x00535746
&& (header & 0x0FFFFFF) != 0x00535743)
{
// ERROR
log_error("gameswf::movie_def_impl::read() -- file does not start with a SWF header!\n");
return 1;
}
bool compressed = (header & 255) == 'C';
IF_VERBOSE_PARSE(log_msg("version = %d, file_length = %d\n", version, file_length));
tu_file* original_in = NULL;
if (compressed)
{
#if TU_CONFIG_LINK_TO_ZLIB == 0
log_error("gameswf can't read zipped SWF data; TU_CONFIG_LINK_TO_ZLIB is 0!\n");
return -1;
#endif
IF_VERBOSE_PARSE(log_msg("file is compressed.\n"));
original_in = in;
// Uncompress the input as we read it.
in = zlib_adapter::make_inflater(original_in);
// Subtract the size of the 8-byte header, since
// it's not included in the compressed
// stream length.
file_end_pos = file_length - 8;
}
lfl_stream str(in);
if (options.m_zip_whole_file)
{
// @@ TODO not implemented yet.
log_error("gameswf::tools::process_swf(): options.m_zip_whole_file is not implemented! Output will not be zipped.\n");
}
//
// Start the output file
//
int output_file_start_pos = swf_out->get_position();
swf_out->write_le32(0x06535746); // Flash 6 header, uncompressed
// File length (need to overwrite later with the actual value.
int output_file_length_pos = swf_out->get_position();
swf_out->write_le32(0);
float frame_rate = 30.f;
int frame_count = 0;
{
copy_helper cp(in, swf_out); // copies everything that's read in this scope.
rect dummy_frame_size;
dummy_frame_size.read(&str);
frame_rate = str.read_u16() / 256.0f;
frame_count = str.read_u16();
str.align();
bool success = cp.do_copy();
if (!success)
{
// Error!
log_error("gameswf::tools::process_swf() -- unable to copy header data!\n");
return 1;
}
}
// m_playlist.resize(m_frame_count);
// IF_VERBOSE_PARSE(m_frame_size.print());
IF_VERBOSE_PARSE(log_msg("frame rate = %f, frames = %d\n", frame_rate, frame_count));
while ((Uint32) str.get_position() < file_end_pos)
{
copy_helper cp(in, swf_out);
int tag_type = str.open_tag();
if (options.m_remove_image_data
&& tag_type == 8)
{
// Don't need no stinkin jpeg tables.
str.close_tag();
}
else if (options.m_remove_image_data
&& (tag_type == 6
|| tag_type == 20
|| tag_type == 21
|| tag_type == 35
|| tag_type == 36))
{
// Some type of bitmap character tag; replace it with a minimal stand-in.
Uint16 cid = str.read_u16();
str.close_tag();
// Insert substitute tag.
write_placeholder_bitmap(swf_out, cid);
}
else
{
// Leave this tag as-is.
str.close_tag();
str.align();
// Copy into output.
bool success = cp.do_copy();
if (!success)
{
// Error!
log_error("gameswf::tools::process_swf() -- error copying tag!\n");
return 1;
}
}
if (tag_type == 0)
{
if ((unsigned int) str.get_position() != file_end_pos)
{
// Safety break, so we don't read past the end of the
// movie.
log_msg("warning: process_swf() hit stream-end tag, but not at the "
"end of the file yet; stopping for safety\n");
break;
}
}
}
if (original_in)
{
// Done with the zlib_adapter.
delete in;
}
// Go back and write the file size.
int current_pos = swf_out->get_position();
swf_out->set_position(output_file_length_pos);
swf_out->write_le32(current_pos - output_file_start_pos);
swf_out->set_position(current_pos);
return 0; // OK
}
void Log::Open(bool plain){
char buffer[1000];
if( Lmagic != 95768){
Lmagic = 95768;
First = true;
}
if(plain == true){ // Textfile Logging
plaintext = true;
// char c[400];
time_t now1;
time(&now1);
struct tm *now2;
now2 = localtime(&now1);
string filename = G->info->datapath + slash + "Logs" + slash;
// DDD MMM DD HH:MM:SS YYYY_X - NTAI.log
filename += to_string(now2->tm_mon+1)+"-" +to_string(now2->tm_mday) + "-" +to_string(now2->tm_year + 1900) +"-" +to_string(now2->tm_hour) +"_" +to_string(now2->tm_min) +"["+to_string(G->Cached->team)+"]XE9.79.log";
//sprintf(c, "%2.2d-%2.2d-%4.4d %2.2d%2.2d [%d]XE9.79.log",
// now2->tm_mon+1, now2->tm_mday, now2->tm_year + 1900, now2->tm_hour,
// now2->tm_min, G->Cached->team);
//filename += c;
strcpy(buffer, filename.c_str());
G->cb->GetValue(AIVAL_LOCATE_FILE_W, buffer);
logFile.open(buffer);
if(logFile.is_open() == false){
logFile.close();
logFile.open(buffer);
if(logFile.is_open() == false){
iprint(string("Error!!! ") + filename + string(" refused to open!"));
verbose = true;
return;
}
}
header(" :: NTAI XE9.79 Log File \n :: Programmed and maintained by AF/T.Nowell \n :: Copyright (C) 2004-7 Tom Nowell/AF \n");
logFile << " :: Game started: " << now2->tm_mday << "." << now2->tm_mon << "." << 1900 + now2->tm_year << " " << now2->tm_hour << ":" << now2->tm_min << ":" << now2->tm_sec << endl << endl << flush;
TdfParser cp(G);
cp.LoadFile("modinfo.tdf");
logFile << " :: " << cp.SGetValueMSG("MOD\\Name") << endl << flush;
logFile << " :: " << cp.SGetValueMSG("MOD\\Description") << endl << flush;
if(First == true) logFile << " :: First instance of NTAI" << endl;
startupscript = new TdfParser(G);
startupscript->LoadFile("script.txt");
vector<string> names;
for(int n=0; n<MAX_TEAMS; n++){
string s = startupscript->SGetValueDef("", string("GAME\\PLAYER") + to_string(n) + "\\name");
if(s != string("")){
names.push_back(s + " : player :: " + to_string(n));
PlayerNames[n] = s;
} else{
PlayerNames[n] = "spring_engine";
}
logFile << " :: " << PlayerNames[n] << endl;
}
logFile << " :: AI DLL's in game" << endl << flush;
vector<string> AInames;
for(int n=0; n<MAX_TEAMS; n++){
string s = startupscript->SGetValueDef("", string("GAME\\TEAM") + to_string(n) + "\\AIDLL");
if(s != string("")){
AInames.push_back(s + " : AI :: " + to_string(n));
logFile << " :: "<<s << " : AI :: " << to_string(n) << endl << flush;
}
}
logFile << endl << flush;
}else{ // HTML logging
char c[400];
time_t now1;
time(&now1);
struct tm *now2;
now2 = localtime(&now1);
string filename = G->info->tdfpath;
filename += slash;
filename += "Logs";
filename += slash;
// DDD MMM DD HH:MM:SS YYYY_X - NTAI.htm
sprintf(c, "%2.2d-%2.2d-%4.4d %2.2d%2.2d [%d] - NTAIXE9.79.htm",
now2->tm_mon+1, now2->tm_mday, now2->tm_year + 1900, now2->tm_hour,
now2->tm_min, G->Cached->team);
filename += c;
strcpy(buffer, filename.c_str());
G->cb->GetValue(AIVAL_LOCATE_FILE_W, buffer);
logFile.open(buffer);
plaintext = false;
string mu ="</table><style type='text/css'>\n<!--\nbody,td,th {\n font-family: sans-serif;\n color: #111111;\nfont-size: 12px;\n\n}\nbody {\n background-color: #FFFFFF;\n\n}\n.c {color: #FF2222}\n.e {color: #FFCC11}\n-->\n</style>\n";
mu+= "<b><br><br>NTAI XE Log File <br>\n<span class='c'>Programmed and maintained by AF Copyright (C) 2006 AF<br>\nReleased under the GPL 2.0 Liscence </p></span></b><br> \n<table width='98%'border='0' cellpadding='0' cellspacing='0' bordercolor='#999999'>\n";
header(mu);
time_t tval;
char buf[128];
tval = time(NULL);
tm* now = localtime(&tval);
strftime(buf, sizeof(buf), "<b><p>Game started: <span class='c'> %B %d %Y %I:%M %p.</p></span></b>", now);
print(buf);
TdfParser cp(G);
cp.LoadFile("modinfo.tdf");
logFile << " :: " << cp.SGetValueMSG("MOD\\Name") << endl << flush;
if(First == true) logFile << " :: First instance of NTAI" << endl << flush;
}
}
Handle(Geom_BSplineCurve) CFunctionToBspline::CFunctionToBsplineImpl::Curve()
{
bool interpolate = true;
std::vector<ChebSegment> segments = approxSegment(_umin, _umax, 1);
int N = _degree + 1;
math_Matrix Mt = monimial_to_bezier(N)*cheb_to_monomial(N);
// get estimated error and create bspline segments
std::vector<Handle(Geom_BSplineCurve)> curves;
double errTotal = 0.;
std::vector<ChebSegment>::iterator it = segments.begin();
for (; it != segments.end(); ++it) {
// get control points
ChebSegment& seg = *it;
math_Vector cpx = Mt*seg.cx;
math_Vector cpy = Mt*seg.cy;
math_Vector cpz = Mt*seg.cz;
TColgp_Array1OfPnt cp(1,cpx.Length());
for (int i = 1; i <= cpx.Length(); ++i) {
gp_Pnt p(cpx(i-1), cpy(i-1), cpz(i-1));
cp.SetValue(i, p);
}
if (interpolate) {
gp_Pnt pstart(_xfunc.value(seg.umin), _yfunc.value(seg.umin), _zfunc.value(seg.umin));
gp_Pnt pstop (_xfunc.value(seg.umax), _yfunc.value(seg.umax), _zfunc.value(seg.umax));
cp.SetValue(1, pstart);
cp.SetValue(cpx.Length(), pstop);
}
// create knots and multiplicity vector
TColStd_Array1OfReal knots(1,2);
knots.SetValue(1, seg.umin);
knots.SetValue(2, seg.umax);
TColStd_Array1OfInteger mults(1,2);
mults.SetValue(1, _degree+1);
mults.SetValue(2, _degree+1);
Handle(Geom_BSplineCurve) curve = new Geom_BSplineCurve(cp, knots, mults, _degree);
curves.push_back(curve);
if (seg.error > errTotal) {
errTotal = seg.error;
}
}
_err = errTotal;
// concatenate c1 the bspline curves
Handle(Geom_BSplineCurve) result = concatC1(curves);
#ifdef DEBUG
LOG(INFO) << "Result of BSpline approximation of function:";
LOG(INFO) << " approximation error = " << errTotal;
LOG(INFO) << " number of control points = " << result->NbPoles();
LOG(INFO) << " number of segments = " << curves.size();
#endif
return result;
}
void CaveV7::carveRoute(v3f vec, float f, bool randomize_xz, bool is_ravine) {
MapNode airnode(CONTENT_AIR);
MapNode waternode(c_water_source);
MapNode lavanode(c_lava_source);
MapNode liquidnode = ps->range(0, 4) ? lavanode : waternode;
v3s16 startp(orp.X, orp.Y, orp.Z);
startp += of;
v3f fp = orp + vec * f;
fp.X += 0.1 * ps->range(-10, 10);
fp.Z += 0.1 * ps->range(-10, 10);
v3s16 cp(fp.X, fp.Y, fp.Z);
s16 d0 = -rs/2;
s16 d1 = d0 + rs;
if (randomize_xz) {
d0 += ps->range(-1, 1);
d1 += ps->range(-1, 1);
}
bool flat_cave_floor = !large_cave && ps->range(0, 2) == 2;
for (s16 z0 = d0; z0 <= d1; z0++) {
s16 si = rs / 2 - MYMAX(0, abs(z0) - rs / 7 - 1);
for (s16 x0 = -si - ps->range(0,1); x0 <= si - 1 + ps->range(0,1); x0++) {
s16 maxabsxz = MYMAX(abs(x0), abs(z0));
s16 si2 = is_ravine ? MYMIN(ps->range(25, 26), ar.Y) :
rs / 2 - MYMAX(0, maxabsxz - rs / 7 - 1);
for (s16 y0 = -si2; y0 <= si2; y0++) {
// Make better floors in small caves
if(flat_cave_floor && y0 <= -rs/2 && rs<=7)
continue;
if (large_cave_is_flat) {
// Make large caves not so tall
if (rs > 7 && abs(y0) >= rs / 3)
continue;
}
v3s16 p(cp.X + x0, cp.Y + y0, cp.Z + z0);
p += of;
if (vm->m_area.contains(p) == false)
continue;
u32 i = vm->m_area.index(p);
// Don't replace air or water or lava
content_t c = vm->m_data[i].getContent();
if (c == CONTENT_AIR || c == c_water_source || c == c_lava_source)
continue;
if (large_cave) {
int full_ymin = node_min.Y - MAP_BLOCKSIZE;
int full_ymax = node_max.Y + MAP_BLOCKSIZE;
if (flooded && full_ymin < water_level && full_ymax > water_level)
vm->m_data[i] = (p.Y <= water_level) ? waternode : airnode;
else if (flooded && full_ymax < water_level)
vm->m_data[i] = (p.Y < startp.Y - 4) ? liquidnode : airnode;
else
vm->m_data[i] = airnode;
} else {
vm->m_data[i] = airnode;
vm->m_flags[i] |= VMANIP_FLAG_CAVE;
}
}
}
}
}
void cq::cd(by) { cf->cd(cp(cs.co())); }
void visit_impl(Node_iri const& node) {
const Ns_id nsid = cp(node.ns_id());
last_inserted_id_ = dest_.insert_node_iri(nsid, node.fragment());
}
void CaveV6::carveRoute(v3f vec, float f, bool randomize_xz, bool tunnel_above_ground)
{
MapNode airnode(CONTENT_AIR);
MapNode waternode(c_water_source);
MapNode lavanode(c_lava_source);
v3s16 startp(orp.X, orp.Y, orp.Z);
startp += of;
v3f fp = orp + vec * f;
fp.X += 0.1 * ps->range(-10, 10);
fp.Z += 0.1 * ps->range(-10, 10);
v3s16 cp(fp.X, fp.Y, fp.Z);
s16 d0 = -rs/2;
s16 d1 = d0 + rs;
if (randomize_xz) {
d0 += ps->range(-1, 1);
d1 += ps->range(-1, 1);
}
for (s16 z0 = d0; z0 <= d1; z0++) {
s16 si = rs / 2 - MYMAX(0, abs(z0) - rs / 7 - 1);
for (s16 x0 = -si - ps->range(0,1); x0 <= si - 1 + ps->range(0,1); x0++) {
if (tunnel_above_ground)
continue;
s16 maxabsxz = MYMAX(abs(x0), abs(z0));
s16 si2 = rs / 2 - MYMAX(0, maxabsxz - rs / 7 - 1);
for (s16 y0 = -si2; y0 <= si2; y0++) {
if (large_cave_is_flat) {
// Make large caves not so tall
if (rs > 7 && abs(y0) >= rs / 3)
continue;
}
v3s16 p(cp.X + x0, cp.Y + y0, cp.Z + z0);
p += of;
if (vm->m_area.contains(p) == false)
continue;
u32 i = vm->m_area.index(p);
content_t c = vm->m_data[i].getContent();
if (!ndef->get(c).is_ground_content)
continue;
if (large_cave) {
int full_ymin = node_min.Y - MAP_BLOCKSIZE;
int full_ymax = node_max.Y + MAP_BLOCKSIZE;
if (flooded && full_ymin < water_level &&
full_ymax > water_level) {
vm->m_data[i] = (p.Y <= water_level) ?
waternode : airnode;
} else if (flooded && full_ymax < water_level) {
vm->m_data[i] = (p.Y < startp.Y - 2) ?
lavanode : airnode;
} else {
vm->m_data[i] = airnode;
}
} else {
if (c == CONTENT_IGNORE || c == CONTENT_AIR)
continue;
vm->m_data[i] = airnode;
vm->m_flags[i] |= VMANIP_FLAG_CAVE;
}
}
}
}
}
void CGuiControlBar::DrawGripper(CDC* pDC,CRect* rc)
{
CRect gripper = rc;
gripper.top =3;
gripper.left+=4;
gripper.right-=IsVert()?6:4;
gripper.bottom =gripper.top +nGapGripper-3;
//si la ventana esta activa pintamos el caption o el area del titulo de color azul
if (IsFloating())
m_bActive=TRUE;
/* Modified By SunZhenyu 2003/6/21, Add the following line*/
m_bActive = FALSE;
if(!m_bActive)
{
CPen cp(PS_SOLID,1,::GetSysColor(COLOR_BTNSHADOW));
CPen* cpold=pDC->SelectObject(&cp);
//linea superior
pDC->MoveTo(gripper.left+1,gripper.top);
pDC->LineTo(gripper.right,gripper.top);
//linea izquierda
pDC->MoveTo(gripper.left,gripper.top+1);
pDC->LineTo(gripper.left,gripper.bottom);
//linea inferior
pDC->MoveTo(gripper.left+1,gripper.bottom);
pDC->LineTo(gripper.right,gripper.bottom);
//linea derecha
pDC->MoveTo(gripper.right,gripper.top+1);
pDC->LineTo(gripper.right,gripper.bottom);
pDC->SelectObject(cpold);
}
else
{
CBrush cb;
cb.CreateSolidBrush(::GetSysColor(COLOR_ACTIVECAPTION));//GuiDrawLayer::GetRGBCaptionXP());
pDC->FillRect(gripper,&cb);
}
gripper.DeflateRect(1, 1);
CString m_caption;
GetWindowText(m_caption);
CFont m_cfont;
// Modified Bu SunZhenyu
if( !m_cfont.CreateStockObject( DEFAULT_GUI_FONT ) )
m_cfont.CreateStockObject( ANSI_VAR_FONT );
// m_cfont.CreateFont(-11,0,0,0,400,0,0,0,0,1,2,1,34,"Verdana");
CFont* m_fontOld=pDC->SelectObject(&m_cfont);
int nMode = pDC->SetBkMode(TRANSPARENT);
CSize SizeCad=pDC->GetTextExtent(m_caption);
CRect rCText=gripper;
rCText.top=6;
rCText.bottom =rCText.top+14;
int cont=SizeCad.cx;
while(cont > 1 && gripper.Width() > 0)
{
CSize coor=pDC->GetTextExtent(m_caption,m_caption.GetLength());
if(coor.cx > gripper.Width()-10)
{
m_caption=m_caption.Left(m_caption.GetLength()-1);
}
else
break;
cont--;
}
if (gripper.Width() > 0 )
if (!m_bActive)
pDC->TextOut(rCText.left+3,rCText.top,m_caption);
else
{
pDC->SetTextColor(RGB(255,255,255));
pDC->TextOut(rCText.left+3,rCText.top,m_caption);
}
//CRect gripper;
//------------------------------------------------
GetWindowRect( gripper );
ScreenToClient( gripper );
gripper.OffsetRect( -gripper.left, -gripper.top );
gripper.left=gripper.right-20;
gripper.right-=7;
gripper.top+=6;
gripper.bottom=gripper.top+13;
m_rcCloseBtn=gripper;
//m_rcCloseBtn.left-=4;
//ClientToScreen(m_rcCloseBtn);
if(!m_bActive)
m_CloseBtn.Paint(pDC,m_stateBtn,gripper,::GetSysColor(COLOR_BTNFACE));
else
m_CloseBtn.Paint(pDC,m_stateBtn,gripper,::GetSysColor(COLOR_ACTIVECAPTION));
//------------------------------------------------
pDC->SetBkMode(nMode);
pDC->SelectObject(m_fontOld);
}
void CavesV6::carveRoute(v3f vec, float f, bool randomize_xz,
bool tunnel_above_ground)
{
MapNode airnode(CONTENT_AIR);
MapNode waternode(c_water_source);
MapNode lavanode(c_lava_source);
MapNode n_ice(c_ice);
bool flooded = ps->range(1, 2) == 2;
v3s16 startp(orp.X, orp.Y, orp.Z);
startp += of;
v3f fp = orp + vec * f;
fp.X += 0.1f * ps->range(-10, 10);
fp.Z += 0.1f * ps->range(-10, 10);
v3s16 cp(fp.X, fp.Y, fp.Z);
s16 d0 = -rs / 2;
s16 d1 = d0 + rs;
if (randomize_xz) {
d0 += ps->range(-1, 1);
d1 += ps->range(-1, 1);
}
for (s16 z0 = d0; z0 <= d1; z0++) {
s16 si = rs / 2 - MYMAX(0, abs(z0) - rs / 7 - 1);
for (s16 x0 = -si - ps->range(0,1); x0 <= si - 1 + ps->range(0,1); x0++) {
if (tunnel_above_ground)
continue;
s16 maxabsxz = MYMAX(abs(x0), abs(z0));
s16 si2 = rs / 2 - MYMAX(0, maxabsxz - rs / 7 - 1);
//fmtodomerge: s16 heat = mg->m_emerge->env->m_use_weather ? mg->m_emerge->env->getServerMap().updateBlockHeat(mg->m_emerge->env, v3POS(cp.X + x0, cp.Y + -si2, cp.Z + z0), nullptr, &mg->heat_cache) : 0;
s16 heat = 10;
for (s16 y0 = -si2; y0 <= si2; y0++) {
if (large_cave_is_flat) {
// Make large caves not so tall
if (rs > 7 && abs(y0) >= rs / 3)
continue;
}
v3s16 p(cp.X + x0, cp.Y + y0, cp.Z + z0);
p += of;
if (vm->m_area.contains(p) == false)
continue;
u32 i = vm->m_area.index(p);
content_t c = vm->m_data[i].getContent();
if (!c || c == CONTENT_AIR || !ndef->get(c).is_ground_content)
continue;
if (large_cave) {
int full_ymin = node_min.Y - MAP_BLOCKSIZE;
int full_ymax = node_max.Y + MAP_BLOCKSIZE;
bool protect_huge = vm->m_flags[i] & VOXELFLAG_CHECKED2;
if (flooded && full_ymin < water_level && full_ymax > water_level) {
if (!protect_huge) {
MapNode n_water_or_ice = (heat < 0 && (p.Y > water_level + heat/4 || p.Y > startp.Y - 2 + heat/4)) ? n_ice : waternode;
vm->m_data[i] = (p.Y <= water_level) ? n_water_or_ice : airnode;
}
} else if (flooded && full_ymax < water_level) {
if (!protect_huge)
vm->m_data[i] = (p.Y < startp.Y - 2) ? lavanode : airnode;
} else {
vm->m_data[i] = airnode;
}
} else {
/*
if (c == CONTENT_IGNORE || c == CONTENT_AIR)
continue;
*/
vm->m_data[i] = airnode;
vm->m_flags[i] |= VMANIP_FLAG_CAVE;
}
}
}
}
}
int32 OS_cp (const char *src, const char *dest)
{
int i;
int status;
char src_path[OS_MAX_LOCAL_PATH_LEN];
char dest_path[OS_MAX_LOCAL_PATH_LEN];
/*
** Check to see if the path pointers are NULL
*/
if (src == NULL || dest == NULL)
{
return OS_FS_ERR_INVALID_POINTER;
}
/*
** Check to see if the paths are too long
*/
if (strlen(src) >= OS_MAX_PATH_LEN)
{
return OS_FS_ERR_PATH_TOO_LONG;
}
if (strlen(dest) >= OS_MAX_PATH_LEN)
{
return OS_FS_ERR_PATH_TOO_LONG;
}
/*
** check if the names of the files are too long
*/
if (OS_check_name_length(src) != OS_FS_SUCCESS)
{
return OS_FS_ERR_NAME_TOO_LONG;
}
if (OS_check_name_length(dest) != OS_FS_SUCCESS)
{
return OS_FS_ERR_NAME_TOO_LONG;
}
/*
** Translate the path
*/
if ( OS_TranslatePath(src, (char *)src_path) != OS_FS_SUCCESS )
{
return OS_FS_ERR_PATH_INVALID;
}
/*
** Translate the path
*/
if ( OS_TranslatePath(dest, (char *)dest_path) != OS_FS_SUCCESS )
{
return OS_FS_ERR_PATH_INVALID;
}
/*
** Make sure the destintation file is not open by the OSAL before doing the copy
** This may be caught by the host OS open call but it does not hurt to
** be consistent
*/
for ( i =0; i < OS_MAX_NUM_OPEN_FILES; i++)
{
if ((OS_FDTable[i].IsValid == TRUE) &&
(strcmp(OS_FDTable[i].Path, dest) == 0))
{
return OS_FS_ERROR;
}
}
status = cp(src_path, dest_path);
if (status != ERROR)
{
return OS_FS_SUCCESS;
}
else
{
return OS_FS_ERROR;
}
}/*end OS_cp */
void CaveV5::carveRoute(v3f vec, float f, bool randomize_xz)
{
MapNode airnode(CONTENT_AIR);
MapNode waternode(c_water_source);
MapNode lavanode(c_lava_source);
MapNode n_ice(c_ice);
v3s16 startp(orp.X, orp.Y, orp.Z);
startp += of;
float nval = NoisePerlin3D(np_caveliquids, startp.X,
startp.Y, startp.Z, mg->seed);
//MapNode liquidnode = nval < 0.40 ? lavanode : waternode;
v3f fp = orp + vec * f;
fp.X += 0.1 * ps->range(-10, 10);
fp.Z += 0.1 * ps->range(-10, 10);
v3s16 cp(fp.X, fp.Y, fp.Z);
s16 d0 = -rs/2;
s16 d1 = d0 + rs;
if (randomize_xz) {
d0 += ps->range(-1, 1);
d1 += ps->range(-1, 1);
}
for (s16 z0 = d0; z0 <= d1; z0++) {
s16 si = rs / 2 - MYMAX(0, abs(z0) - rs / 7 - 1);
for (s16 x0 = -si - ps->range(0,1); x0 <= si - 1 + ps->range(0,1); x0++) {
s16 maxabsxz = MYMAX(abs(x0), abs(z0));
s16 si2 = rs / 2 - MYMAX(0, maxabsxz - rs / 7 - 1);
for (s16 y0 = -si2; y0 <= si2; y0++) {
if (large_cave_is_flat) {
// Make large caves not so tall
if (rs > 7 && abs(y0) >= rs / 3)
continue;
}
v3s16 p(cp.X + x0, cp.Y + y0, cp.Z + z0);
p += of;
if (vm->m_area.contains(p) == false)
continue;
u32 i = vm->m_area.index(p);
content_t c = vm->m_data[i].getContent();
if (!ndef->get(c).is_ground_content)
continue;
s16 heat = mg->m_emerge->env->m_use_weather ? mg->m_emerge->env->getServerMap().updateBlockHeat(mg->m_emerge->env, p, nullptr, &mg->heat_cache) : 0;
MapNode n_water_or_ice = (heat < 0 && (p.Y > water_level + heat/4 || p.Y > startp.Y - 2 + heat/4)) ? n_ice : waternode;
MapNode liquidnode = nval < 0.40 ? lavanode : n_water_or_ice;
int full_ymin = node_min.Y - MAP_BLOCKSIZE;
int full_ymax = node_max.Y + MAP_BLOCKSIZE;
if (flooded && full_ymin < water_level &&
full_ymax > water_level)
vm->m_data[i] = (p.Y <= water_level) ?
n_water_or_ice : airnode;
else if (flooded && full_ymax < water_level)
vm->m_data[i] = (p.Y < startp.Y - 4) ?
liquidnode : airnode;
else
vm->m_data[i] = airnode;
}
}
}
}
void plPhysicsSoundMgr::AddContact(plPhysical* phys1, plPhysical* phys2, const hsPoint3& hitPoint, const hsVector3& hitNormal)
{
CollidePair cp(phys1->GetKey(), phys2->GetKey(), hitPoint, hitNormal);
fCurCollisions.insert(cp);
}
void CaveFractal::carveRoute(v3f vec, float f, bool randomize_xz)
{
MapNode airnode(CONTENT_AIR);
MapNode waternode(c_water_source);
MapNode lavanode(c_lava_source);
v3s16 startp(orp.X, orp.Y, orp.Z);
startp += of;
float nval = NoisePerlin3D(np_caveliquids, startp.X,
startp.Y, startp.Z, mg->seed);
MapNode liquidnode = (nval < 0.40 && node_max.Y < MGFRACTAL_LAVA_DEPTH) ?
lavanode : waternode;
v3f fp = orp + vec * f;
fp.X += 0.1 * ps->range(-10, 10);
fp.Z += 0.1 * ps->range(-10, 10);
v3s16 cp(fp.X, fp.Y, fp.Z);
s16 d0 = -rs/2;
s16 d1 = d0 + rs;
if (randomize_xz) {
d0 += ps->range(-1, 1);
d1 += ps->range(-1, 1);
}
for (s16 z0 = d0; z0 <= d1; z0++) {
s16 si = rs / 2 - MYMAX(0, abs(z0) - rs / 7 - 1);
for (s16 x0 = -si - ps->range(0,1); x0 <= si - 1 + ps->range(0,1); x0++) {
s16 maxabsxz = MYMAX(abs(x0), abs(z0));
s16 si2 = rs / 2 - MYMAX(0, maxabsxz - rs / 7 - 1);
for (s16 y0 = -si2; y0 <= si2; y0++) {
if (large_cave_is_flat) {
// Make large caves not so tall
if (rs > 7 && abs(y0) >= rs / 3)
continue;
}
v3s16 p(cp.X + x0, cp.Y + y0, cp.Z + z0);
p += of;
if (vm->m_area.contains(p) == false)
continue;
u32 i = vm->m_area.index(p);
content_t c = vm->m_data[i].getContent();
if (!ndef->get(c).is_ground_content)
continue;
int full_ymin = node_min.Y - MAP_BLOCKSIZE;
int full_ymax = node_max.Y + MAP_BLOCKSIZE;
if (flooded && full_ymin < water_level &&
full_ymax > water_level)
vm->m_data[i] = (p.Y <= water_level) ?
waternode : airnode;
else if (flooded && full_ymax < water_level)
vm->m_data[i] = (p.Y < startp.Y - 4) ?
liquidnode : airnode;
else
vm->m_data[i] = airnode;
}
}
}
}
// Copy, recursively if necessary, the source to the destination
bool Foam::cp(const fileName& src, const fileName& dest)
{
// Make sure source exists.
if (!exists(src))
{
return false;
}
fileName destFile(dest);
// Check type of source file.
if (src.type() == fileName::FILE)
{
// If dest is a directory, create the destination file name.
if (destFile.type() == fileName::DIRECTORY)
{
destFile = destFile/src.name();
}
// Make sure the destination directory exists.
if (!isDir(destFile.path()) && !mkDir(destFile.path()))
{
return false;
}
// Open and check streams.
std::ifstream srcStream(src.c_str());
if (!srcStream)
{
return false;
}
std::ofstream destStream(destFile.c_str());
if (!destStream)
{
return false;
}
// Copy character data.
char ch;
while (srcStream.get(ch))
{
destStream.put(ch);
}
// Final check.
if (!srcStream.eof() || !destStream)
{
return false;
}
}
else if (src.type() == fileName::DIRECTORY)
{
// If dest is a directory, create the destination file name.
if (destFile.type() == fileName::DIRECTORY)
{
destFile = destFile/src.component(src.components().size() -1);
}
// Make sure the destination directory exists.
if (!isDir(destFile) && !mkDir(destFile))
{
return false;
}
// Copy files
fileNameList contents = readDir(src, fileName::FILE, false);
forAll(contents, i)
{
if (POSIX::debug)
{
Info<< "Copying : " << src/contents[i]
<< " to " << destFile/contents[i] << endl;
}
// File to file.
cp(src/contents[i], destFile/contents[i]);
}
// Copy sub directories.
fileNameList subdirs = readDir(src, fileName::DIRECTORY);
forAll(subdirs, i)
{
if (POSIX::debug)
{
Info<< "Copying : " << src/subdirs[i]
<< " to " << destFile << endl;
}
// Dir to Dir.
cp(src/subdirs[i], destFile);
}
}
return true;
}
