// 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; }