00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #include <libfuture.h>
00027
00028 namespace db {
00029
00034 Account::Account(Database *db)
00035 {
00036 database = db;
00037 new_object = 1;
00038 clear();
00039 }
00040
00041
00042 Account::Account(Database *db,const std::string& sql)
00043 {
00044 database = db;
00045 new_object = 1;
00046 spawn(sql);
00047 }
00048
00049
00050 Account::Account(Database *db,Query *qd,int offset)
00051 {
00052 database = db;
00053 new_object = 0;
00054 spawn(qd, offset);
00055 }
00056
00057
00058 Account::Account(Database& db,long i_num):database(&db),new_object(1)
00059 {
00060 Query q(*database);
00061 std::string sql = "select * from account where ";
00062 {
00063 char slask[100];
00064 sprintf(slask,"num='%ld'",i_num);
00065 sql += slask;
00066 }
00067 spawn(sql);
00068 }
00069
00070
00071 Account::Account(Database& db,const std::string& i_name):database(&db),new_object(1)
00072 {
00073 Query q(*database);
00074 std::string sql = "select * from account where ";
00075 sql += "name='" + q.GetDatabase().safestr(i_name) + "'";
00076 spawn(sql);
00077 }
00078
00079
00080 Account::~Account()
00081 {
00082 }
00083
00084
00085 void Account::select(const std::string& sql)
00086 {
00087 spawn(sql);
00088 }
00089
00090
00091 unsigned long long int Account::insert()
00092 {
00093 Query q(*database);
00094 std::string sql;
00095
00096 sql = "insert into account(name,passwd,display_name,wizard,email,area,chunk,chunkx,chunky,facing,wizview,race)";
00097 sql += " values('" + q.GetDatabase().safestr(this -> name) + "'";
00098 sql += ", '" + q.GetDatabase().safestr(this -> passwd) + "'";
00099 sql += ", '" + q.GetDatabase().safestr(this -> display_name) + "'";
00100 {
00101 char slask[100];
00102 sprintf(slask,", %d",this -> wizard);
00103 sql += slask;
00104 }
00105 sql += ", '" + q.GetDatabase().safestr(this -> email) + "'";
00106 {
00107 char slask[100];
00108 sprintf(slask,", %ld",this -> area);
00109 sql += slask;
00110 }
00111 {
00112 char slask[100];
00113 sprintf(slask,", %ld",this -> chunk);
00114 sql += slask;
00115 }
00116 {
00117 char slask[100];
00118 sprintf(slask,", %ld",this -> chunkx);
00119 sql += slask;
00120 }
00121 {
00122 char slask[100];
00123 sprintf(slask,", %ld",this -> chunky);
00124 sql += slask;
00125 }
00126 {
00127 char slask[100];
00128 sprintf(slask,", %ld",this -> facing);
00129 sql += slask;
00130 }
00131 {
00132 char slask[100];
00133 sprintf(slask,", %ld",this -> wizview);
00134 sql += slask;
00135 }
00136 {
00137 char slask[100];
00138 sprintf(slask,", %ld",this -> race);
00139 sql += slask;
00140 }
00141 sql += ")";
00142 q.execute(sql);
00143 new_object = 0;
00144 unsigned long long int inserted_id = q.insert_id();
00145 num = inserted_id;
00146 return inserted_id;
00147 }
00148
00149
00150 void Account::update()
00151 {
00152 update(this -> num);
00153 }
00154
00155
00156 void Account::update(long i_num)
00157 {
00158 Query q(*database);
00159 std::string sql;
00160 sql += "update account set name='" + q.GetDatabase().safestr(this -> name) + "'";
00161 sql += ", passwd='" + q.GetDatabase().safestr(this -> passwd) + "'";
00162 sql += ", display_name='" + q.GetDatabase().safestr(this -> display_name) + "'";
00163 {
00164 char slask[200];
00165 sprintf(slask,", wizard=%d",this -> wizard);
00166 sql += slask;
00167 }
00168 sql += ", email='" + q.GetDatabase().safestr(this -> email) + "'";
00169 {
00170 char slask[200];
00171 sprintf(slask,", area=%ld",this -> area);
00172 sql += slask;
00173 }
00174 {
00175 char slask[200];
00176 sprintf(slask,", chunk=%ld",this -> chunk);
00177 sql += slask;
00178 }
00179 {
00180 char slask[200];
00181 sprintf(slask,", chunkx=%ld",this -> chunkx);
00182 sql += slask;
00183 }
00184 {
00185 char slask[200];
00186 sprintf(slask,", chunky=%ld",this -> chunky);
00187 sql += slask;
00188 }
00189 {
00190 char slask[200];
00191 sprintf(slask,", facing=%ld",this -> facing);
00192 sql += slask;
00193 }
00194 {
00195 char slask[200];
00196 sprintf(slask,", wizview=%ld",this -> wizview);
00197 sql += slask;
00198 }
00199 {
00200 char slask[200];
00201 sprintf(slask,", race=%ld",this -> race);
00202 sql += slask;
00203 }
00204 {
00205 char slask[200];
00206 sprintf(slask," where num='%ld'",i_num);
00207 sql += slask;
00208 }
00209 q.execute(sql);
00210 }
00211
00212
00213 void Account::save()
00214 {
00215 if (new_object)
00216 insert();
00217 else
00218 update();
00219 }
00220
00221
00222 void Account::erase()
00223 {
00224 if (!new_object)
00225 {
00226 std::string sql = "delete from account where";
00227 Query q(*database);
00228 {
00229 char slask[200];
00230 sprintf(slask," num='%ld'",this -> num);
00231 sql += slask;
00232 }
00233 q.execute(sql);
00234 }
00235 }
00236
00237
00238 std::string Account::xml()
00239 {
00240 Query q(*database);
00241 std::string dest;
00242 char slask[200];
00243 dest = "<ACCOUNT>";
00244 sprintf(slask,"<NUM>%ld</NUM>",this -> num);
00245 dest += slask;
00246 dest += "<NAME>" + q.GetDatabase().xmlsafestr(this -> name) + "</NAME>";
00247 dest += "<PASSWD>" + q.GetDatabase().xmlsafestr(this -> passwd) + "</PASSWD>";
00248 dest += "<DISPLAY_NAME>" + q.GetDatabase().xmlsafestr(this -> display_name) + "</DISPLAY_NAME>";
00249 sprintf(slask,"<WIZARD>%d</WIZARD>",this -> wizard);
00250 dest += slask;
00251 dest += "<EMAIL>" + q.GetDatabase().xmlsafestr(this -> email) + "</EMAIL>";
00252 sprintf(slask,"<AREA>%ld</AREA>",this -> area);
00253 dest += slask;
00254 sprintf(slask,"<CHUNK>%ld</CHUNK>",this -> chunk);
00255 dest += slask;
00256 sprintf(slask,"<CHUNKX>%ld</CHUNKX>",this -> chunkx);
00257 dest += slask;
00258 sprintf(slask,"<CHUNKY>%ld</CHUNKY>",this -> chunky);
00259 dest += slask;
00260 sprintf(slask,"<FACING>%ld</FACING>",this -> facing);
00261 dest += slask;
00262 sprintf(slask,"<WIZVIEW>%ld</WIZVIEW>",this -> wizview);
00263 dest += slask;
00264 sprintf(slask,"<RACE>%ld</RACE>",this -> race);
00265 dest += slask;
00266 dest += "</ACCOUNT>";
00267 return dest;
00268 }
00269
00270
00271 std::string Account::xml(const std::string& tag,const std::string& xvalx)
00272 {
00273 Query q(*database);
00274 std::string dest;
00275 char slask[200];
00276 dest = "<ACCOUNT " + tag + "=\"" + xvalx + "\">";
00277 sprintf(slask,"<NUM>%ld</NUM>",this -> num);
00278 dest += slask;
00279 dest += "<NAME>" + q.GetDatabase().xmlsafestr(this -> name) + "</NAME>";
00280 dest += "<PASSWD>" + q.GetDatabase().xmlsafestr(this -> passwd) + "</PASSWD>";
00281 dest += "<DISPLAY_NAME>" + q.GetDatabase().xmlsafestr(this -> display_name) + "</DISPLAY_NAME>";
00282 sprintf(slask,"<WIZARD>%d</WIZARD>",this -> wizard);
00283 dest += slask;
00284 dest += "<EMAIL>" + q.GetDatabase().xmlsafestr(this -> email) + "</EMAIL>";
00285 sprintf(slask,"<AREA>%ld</AREA>",this -> area);
00286 dest += slask;
00287 sprintf(slask,"<CHUNK>%ld</CHUNK>",this -> chunk);
00288 dest += slask;
00289 sprintf(slask,"<CHUNKX>%ld</CHUNKX>",this -> chunkx);
00290 dest += slask;
00291 sprintf(slask,"<CHUNKY>%ld</CHUNKY>",this -> chunky);
00292 dest += slask;
00293 sprintf(slask,"<FACING>%ld</FACING>",this -> facing);
00294 dest += slask;
00295 sprintf(slask,"<WIZVIEW>%ld</WIZVIEW>",this -> wizview);
00296 dest += slask;
00297 sprintf(slask,"<RACE>%ld</RACE>",this -> race);
00298 dest += slask;
00299 dest += "</ACCOUNT>";
00300 return dest;
00301 }
00302
00303
00304 size_t Account::num_cols()
00305 {
00306 return 13;
00307 }
00308
00309
00310 void Account::clear()
00311 {
00312 this -> num = 0;
00313 this -> name = "";
00314 this -> passwd = "";
00315 this -> display_name = "";
00316 this -> wizard = 0;
00317 this -> email = "";
00318 this -> area = 0;
00319 this -> chunk = 0;
00320 this -> chunkx = 0;
00321 this -> chunky = 0;
00322 this -> facing = 0;
00323 this -> wizview = 0;
00324 this -> race = 0;
00325 }
00326
00327
00328 void Account::spawn(const std::string& sql)
00329 {
00330 Query q(*database);
00331 std::string temp;
00332
00333 clear();
00334
00335 if (!strncasecmp(sql.c_str(),"select * ",9))
00336 {
00337 temp = "select num,name,passwd,display_name,wizard,email,area,chunk,chunkx,chunky,facing,wizview,race " + sql.substr(9);
00338 } else
00339 temp = sql;
00340 q.get_result(temp);
00341 if (q.fetch_row())
00342 {
00343 this -> num = q.getval(0);
00344 this -> name = q.getstr(1);
00345 this -> passwd = q.getstr(2);
00346 this -> display_name = q.getstr(3);
00347 this -> wizard = q.getval(4);
00348 this -> email = q.getstr(5);
00349 this -> area = q.getval(6);
00350 this -> chunk = q.getval(7);
00351 this -> chunkx = q.getval(8);
00352 this -> chunky = q.getval(9);
00353 this -> facing = q.getval(10);
00354 this -> wizview = q.getval(11);
00355 this -> race = q.getval(12);
00356 new_object = 0;
00357 } else
00358 clear();
00359 q.free_result();
00360 }
00361
00362
00363 void Account::spawn(Query *qd,int offset)
00364 {
00365 clear();
00366
00367 this -> num = qd -> getval(0 + offset);
00368 this -> name = qd -> getstr(1 + offset);
00369 this -> passwd = qd -> getstr(2 + offset);
00370 this -> display_name = qd -> getstr(3 + offset);
00371 this -> wizard = qd -> getval(4 + offset);
00372 this -> email = qd -> getstr(5 + offset);
00373 this -> area = qd -> getval(6 + offset);
00374 this -> chunk = qd -> getval(7 + offset);
00375 this -> chunkx = qd -> getval(8 + offset);
00376 this -> chunky = qd -> getval(9 + offset);
00377 this -> facing = qd -> getval(10 + offset);
00378 this -> wizview = qd -> getval(11 + offset);
00379 this -> race = qd -> getval(12 + offset);
00380 }
00381
00382
00383
00384
00385 }
00386 namespace db {
00387
00392 Eventcount::Eventcount(Database *db)
00393 {
00394 database = db;
00395 new_object = 1;
00396 clear();
00397 }
00398
00399
00400 Eventcount::Eventcount(Database *db,const std::string& sql)
00401 {
00402 database = db;
00403 new_object = 1;
00404 spawn(sql);
00405 }
00406
00407
00408 Eventcount::Eventcount(Database *db,Query *qd,int offset)
00409 {
00410 database = db;
00411 new_object = 0;
00412 spawn(qd, offset);
00413 }
00414
00415
00416 Eventcount::Eventcount(Database& db,long i_num):database(&db),new_object(1)
00417 {
00418 Query q(*database);
00419 std::string sql = "select * from eventcount where ";
00420 {
00421 char slask[100];
00422 sprintf(slask,"num='%ld'",i_num);
00423 sql += slask;
00424 }
00425 spawn(sql);
00426 }
00427
00428
00429 Eventcount::Eventcount(Database& db,const std::string& i_event_name):database(&db),new_object(1)
00430 {
00431 Query q(*database);
00432 std::string sql = "select * from eventcount where ";
00433 sql += "event_name='" + q.GetDatabase().safestr(i_event_name) + "'";
00434 spawn(sql);
00435 }
00436
00437
00438 Eventcount::~Eventcount()
00439 {
00440 }
00441
00442
00443 void Eventcount::select(const std::string& sql)
00444 {
00445 spawn(sql);
00446 }
00447
00448
00449 unsigned long long int Eventcount::insert()
00450 {
00451 Query q(*database);
00452 std::string sql;
00453
00454 sql = "insert into eventcount(event_name,count)";
00455 sql += " values('" + q.GetDatabase().safestr(this -> event_name) + "'";
00456 {
00457 char slask[100];
00458 sprintf(slask,", %ld",this -> count);
00459 sql += slask;
00460 }
00461 sql += ")";
00462 q.execute(sql);
00463 new_object = 0;
00464 unsigned long long int inserted_id = q.insert_id();
00465 num = inserted_id;
00466 return inserted_id;
00467 }
00468
00469
00470 void Eventcount::update()
00471 {
00472 update(this -> num);
00473 }
00474
00475
00476 void Eventcount::update(long i_num)
00477 {
00478 Query q(*database);
00479 std::string sql;
00480 sql += "update eventcount set event_name='" + q.GetDatabase().safestr(this -> event_name) + "'";
00481 {
00482 char slask[200];
00483 sprintf(slask,", count=%ld",this -> count);
00484 sql += slask;
00485 }
00486 {
00487 char slask[200];
00488 sprintf(slask," where num='%ld'",i_num);
00489 sql += slask;
00490 }
00491 q.execute(sql);
00492 }
00493
00494
00495 void Eventcount::save()
00496 {
00497 if (new_object)
00498 insert();
00499 else
00500 update();
00501 }
00502
00503
00504 void Eventcount::erase()
00505 {
00506 if (!new_object)
00507 {
00508 std::string sql = "delete from eventcount where";
00509 Query q(*database);
00510 {
00511 char slask[200];
00512 sprintf(slask," num='%ld'",this -> num);
00513 sql += slask;
00514 }
00515 q.execute(sql);
00516 }
00517 }
00518
00519
00520 std::string Eventcount::xml()
00521 {
00522 Query q(*database);
00523 std::string dest;
00524 char slask[200];
00525 dest = "<EVENTCOUNT>";
00526 sprintf(slask,"<NUM>%ld</NUM>",this -> num);
00527 dest += slask;
00528 dest += "<EVENT_NAME>" + q.GetDatabase().xmlsafestr(this -> event_name) + "</EVENT_NAME>";
00529 sprintf(slask,"<COUNT>%ld</COUNT>",this -> count);
00530 dest += slask;
00531 dest += "</EVENTCOUNT>";
00532 return dest;
00533 }
00534
00535
00536 std::string Eventcount::xml(const std::string& tag,const std::string& xvalx)
00537 {
00538 Query q(*database);
00539 std::string dest;
00540 char slask[200];
00541 dest = "<EVENTCOUNT " + tag + "=\"" + xvalx + "\">";
00542 sprintf(slask,"<NUM>%ld</NUM>",this -> num);
00543 dest += slask;
00544 dest += "<EVENT_NAME>" + q.GetDatabase().xmlsafestr(this -> event_name) + "</EVENT_NAME>";
00545 sprintf(slask,"<COUNT>%ld</COUNT>",this -> count);
00546 dest += slask;
00547 dest += "</EVENTCOUNT>";
00548 return dest;
00549 }
00550
00551
00552 size_t Eventcount::num_cols()
00553 {
00554 return 3;
00555 }
00556
00557
00558 void Eventcount::clear()
00559 {
00560 this -> num = 0;
00561 this -> event_name = "";
00562 this -> count = 0;
00563 }
00564
00565
00566 void Eventcount::spawn(const std::string& sql)
00567 {
00568 Query q(*database);
00569 std::string temp;
00570
00571 clear();
00572
00573 if (!strncasecmp(sql.c_str(),"select * ",9))
00574 {
00575 temp = "select num,event_name,count " + sql.substr(9);
00576 } else
00577 temp = sql;
00578 q.get_result(temp);
00579 if (q.fetch_row())
00580 {
00581 this -> num = q.getval(0);
00582 this -> event_name = q.getstr(1);
00583 this -> count = q.getval(2);
00584 new_object = 0;
00585 } else
00586 clear();
00587 q.free_result();
00588 }
00589
00590
00591 void Eventcount::spawn(Query *qd,int offset)
00592 {
00593 clear();
00594
00595 this -> num = qd -> getval(0 + offset);
00596 this -> event_name = qd -> getstr(1 + offset);
00597 this -> count = qd -> getval(2 + offset);
00598 }
00599
00600
00601
00602
00603 }
00604 namespace db {
00605
00610 Area::Area(Database *db)
00611 {
00612 database = db;
00613 new_object = 1;
00614 clear();
00615 }
00616
00617
00618 Area::Area(Database *db,const std::string& sql)
00619 {
00620 database = db;
00621 new_object = 1;
00622 spawn(sql);
00623 }
00624
00625
00626 Area::Area(Database *db,Query *qd,int offset)
00627 {
00628 database = db;
00629 new_object = 0;
00630 spawn(qd, offset);
00631 }
00632
00633
00634 Area::Area(Database& db,long i_num):database(&db),new_object(1)
00635 {
00636 Query q(*database);
00637 std::string sql = "select * from area where ";
00638 {
00639 char slask[100];
00640 sprintf(slask,"num='%ld'",i_num);
00641 sql += slask;
00642 }
00643 spawn(sql);
00644 }
00645
00646
00647 Area::Area(Database& db,const std::string& i_name):database(&db),new_object(1)
00648 {
00649 Query q(*database);
00650 std::string sql = "select * from area where ";
00651 sql += "name='" + q.GetDatabase().safestr(i_name) + "'";
00652 spawn(sql);
00653 }
00654
00655
00656 Area::~Area()
00657 {
00658 }
00659
00660
00661 void Area::select(const std::string& sql)
00662 {
00663 spawn(sql);
00664 }
00665
00666
00667 unsigned long long int Area::insert()
00668 {
00669 Query q(*database);
00670 std::string sql;
00671
00672 sql = "insert into area(name,width,height)";
00673 sql += " values('" + q.GetDatabase().safestr(this -> name) + "'";
00674 {
00675 char slask[100];
00676 sprintf(slask,", %ld",this -> width);
00677 sql += slask;
00678 }
00679 {
00680 char slask[100];
00681 sprintf(slask,", %ld",this -> height);
00682 sql += slask;
00683 }
00684 sql += ")";
00685 q.execute(sql);
00686 new_object = 0;
00687 unsigned long long int inserted_id = q.insert_id();
00688 num = inserted_id;
00689 return inserted_id;
00690 }
00691
00692
00693 void Area::update()
00694 {
00695 update(this -> num);
00696 }
00697
00698
00699 void Area::update(long i_num)
00700 {
00701 Query q(*database);
00702 std::string sql;
00703 sql += "update area set name='" + q.GetDatabase().safestr(this -> name) + "'";
00704 {
00705 char slask[200];
00706 sprintf(slask,", width=%ld",this -> width);
00707 sql += slask;
00708 }
00709 {
00710 char slask[200];
00711 sprintf(slask,", height=%ld",this -> height);
00712 sql += slask;
00713 }
00714 {
00715 char slask[200];
00716 sprintf(slask," where num='%ld'",i_num);
00717 sql += slask;
00718 }
00719 q.execute(sql);
00720 }
00721
00722
00723 void Area::save()
00724 {
00725 if (new_object)
00726 insert();
00727 else
00728 update();
00729 }
00730
00731
00732 void Area::erase()
00733 {
00734 if (!new_object)
00735 {
00736 std::string sql = "delete from area where";
00737 Query q(*database);
00738 {
00739 char slask[200];
00740 sprintf(slask," num='%ld'",this -> num);
00741 sql += slask;
00742 }
00743 q.execute(sql);
00744 }
00745 }
00746
00747
00748 std::string Area::xml()
00749 {
00750 Query q(*database);
00751 std::string dest;
00752 char slask[200];
00753 dest = "<AREA>";
00754 sprintf(slask,"<NUM>%ld</NUM>",this -> num);
00755 dest += slask;
00756 dest += "<NAME>" + q.GetDatabase().xmlsafestr(this -> name) + "</NAME>";
00757 sprintf(slask,"<WIDTH>%ld</WIDTH>",this -> width);
00758 dest += slask;
00759 sprintf(slask,"<HEIGHT>%ld</HEIGHT>",this -> height);
00760 dest += slask;
00761 dest += "</AREA>";
00762 return dest;
00763 }
00764
00765
00766 std::string Area::xml(const std::string& tag,const std::string& xvalx)
00767 {
00768 Query q(*database);
00769 std::string dest;
00770 char slask[200];
00771 dest = "<AREA " + tag + "=\"" + xvalx + "\">";
00772 sprintf(slask,"<NUM>%ld</NUM>",this -> num);
00773 dest += slask;
00774 dest += "<NAME>" + q.GetDatabase().xmlsafestr(this -> name) + "</NAME>";
00775 sprintf(slask,"<WIDTH>%ld</WIDTH>",this -> width);
00776 dest += slask;
00777 sprintf(slask,"<HEIGHT>%ld</HEIGHT>",this -> height);
00778 dest += slask;
00779 dest += "</AREA>";
00780 return dest;
00781 }
00782
00783
00784 size_t Area::num_cols()
00785 {
00786 return 4;
00787 }
00788
00789
00790 void Area::clear()
00791 {
00792 this -> num = 0;
00793 this -> name = "";
00794 this -> width = 0;
00795 this -> height = 0;
00796 }
00797
00798
00799 void Area::spawn(const std::string& sql)
00800 {
00801 Query q(*database);
00802 std::string temp;
00803
00804 clear();
00805
00806 if (!strncasecmp(sql.c_str(),"select * ",9))
00807 {
00808 temp = "select num,name,width,height " + sql.substr(9);
00809 } else
00810 temp = sql;
00811 q.get_result(temp);
00812 if (q.fetch_row())
00813 {
00814 this -> num = q.getval(0);
00815 this -> name = q.getstr(1);
00816 this -> width = q.getval(2);
00817 this -> height = q.getval(3);
00818 new_object = 0;
00819 } else
00820 clear();
00821 q.free_result();
00822 }
00823
00824
00825 void Area::spawn(Query *qd,int offset)
00826 {
00827 clear();
00828
00829 this -> num = qd -> getval(0 + offset);
00830 this -> name = qd -> getstr(1 + offset);
00831 this -> width = qd -> getval(2 + offset);
00832 this -> height = qd -> getval(3 + offset);
00833 }
00834
00835
00836
00837
00838 }
00839 namespace db {
00840
00845 Chunk::Chunk(Database *db)
00846 {
00847 database = db;
00848 new_object = 1;
00849 clear();
00850 }
00851
00852
00853 Chunk::Chunk(Database *db,const std::string& sql)
00854 {
00855 database = db;
00856 new_object = 1;
00857 spawn(sql);
00858 }
00859
00860
00861 Chunk::Chunk(Database *db,Query *qd,int offset)
00862 {
00863 database = db;
00864 new_object = 0;
00865 spawn(qd, offset);
00866 }
00867
00868
00869 Chunk::Chunk(Database& db,long i_num):database(&db),new_object(1)
00870 {
00871 Query q(*database);
00872 std::string sql = "select * from chunk where ";
00873 {
00874 char slask[100];
00875 sprintf(slask,"num='%ld'",i_num);
00876 sql += slask;
00877 }
00878 spawn(sql);
00879 }
00880
00881
00882 Chunk::Chunk(Database& db,long i_area,long i_x,long i_y,long i_z):database(&db),new_object(1)
00883 {
00884 Query q(*database);
00885 std::string sql = "select * from chunk where ";
00886 {
00887 char slask[100];
00888 sprintf(slask,"area='%ld'",i_area);
00889 sql += slask;
00890 }
00891 {
00892 char slask[100];
00893 sprintf(slask," and x='%ld'",i_x);
00894 sql += slask;
00895 }
00896 {
00897 char slask[100];
00898 sprintf(slask," and y='%ld'",i_y);
00899 sql += slask;
00900 }
00901 {
00902 char slask[100];
00903 sprintf(slask," and z='%ld'",i_z);
00904 sql += slask;
00905 }
00906 spawn(sql);
00907 }
00908
00909
00910 Chunk::~Chunk()
00911 {
00912 }
00913
00914
00915 void Chunk::select(const std::string& sql)
00916 {
00917 spawn(sql);
00918 }
00919
00920
00921 unsigned long long int Chunk::insert()
00922 {
00923 Query q(*database);
00924 std::string sql;
00925
00926 sql = "insert into chunk(area,terrain,x,y,z,created_by,created_date)";
00927 {
00928 char slask[100];
00929 sprintf(slask," values(%ld",this -> area);
00930 sql += slask;
00931 }
00932 sql += ", '" + q.GetDatabase().safestr(this -> terrain) + "'";
00933 {
00934 char slask[100];
00935 sprintf(slask,", %ld",this -> x);
00936 sql += slask;
00937 }
00938 {
00939 char slask[100];
00940 sprintf(slask,", %ld",this -> y);
00941 sql += slask;
00942 }
00943 {
00944 char slask[100];
00945 sprintf(slask,", %ld",this -> z);
00946 sql += slask;
00947 }
00948 {
00949 char slask[100];
00950 sprintf(slask,", %ld",this -> created_by);
00951 sql += slask;
00952 }
00953 sql += ", '" + q.GetDatabase().safestr(this -> created_date) + "'";
00954 sql += ")";
00955 q.execute(sql);
00956 new_object = 0;
00957 unsigned long long int inserted_id = q.insert_id();
00958 num = inserted_id;
00959 return inserted_id;
00960 }
00961
00962
00963 void Chunk::update()
00964 {
00965 update(this -> num);
00966 }
00967
00968
00969 void Chunk::update(long i_num)
00970 {
00971 Query q(*database);
00972 std::string sql;
00973 {
00974 char slask[200];
00975 sprintf(slask,"update chunk set area=%ld",this -> area);
00976 sql += slask;
00977 }
00978 sql += ", terrain='" + q.GetDatabase().safestr(this -> terrain) + "'";
00979 {
00980 char slask[200];
00981 sprintf(slask,", x=%ld",this -> x);
00982 sql += slask;
00983 }
00984 {
00985 char slask[200];
00986 sprintf(slask,", y=%ld",this -> y);
00987 sql += slask;
00988 }
00989 {
00990 char slask[200];
00991 sprintf(slask,", z=%ld",this -> z);
00992 sql += slask;
00993 }
00994 {
00995 char slask[200];
00996 sprintf(slask,", created_by=%ld",this -> created_by);
00997 sql += slask;
00998 }
00999 sql += ", created_date='" + q.GetDatabase().safestr(this -> created_date) + "'";
01000 {
01001 char slask[200];
01002 sprintf(slask," where num='%ld'",i_num);
01003 sql += slask;
01004 }
01005 q.execute(sql);
01006 }
01007
01008
01009 void Chunk::save()
01010 {
01011 if (new_object)
01012 insert();
01013 else
01014 update();
01015 }
01016
01017
01018 void Chunk::erase()
01019 {
01020 if (!new_object)
01021 {
01022 std::string sql = "delete from chunk where";
01023 Query q(*database);
01024 {
01025 char slask[200];
01026 sprintf(slask," num='%ld'",this -> num);
01027 sql += slask;
01028 }
01029 q.execute(sql);
01030 }
01031 }
01032
01033
01034 std::string Chunk::xml()
01035 {
01036 Query q(*database);
01037 std::string dest;
01038 char slask[200];
01039 dest = "<CHUNK>";
01040 sprintf(slask,"<NUM>%ld</NUM>",this -> num);
01041 dest += slask;
01042 sprintf(slask,"<AREA>%ld</AREA>",this -> area);
01043 dest += slask;
01044 dest += "<TERRAIN>" + q.GetDatabase().xmlsafestr(this -> terrain) + "</TERRAIN>";
01045 sprintf(slask,"<X>%ld</X>",this -> x);
01046 dest += slask;
01047 sprintf(slask,"<Y>%ld</Y>",this -> y);
01048 dest += slask;
01049 sprintf(slask,"<Z>%ld</Z>",this -> z);
01050 dest += slask;
01051 sprintf(slask,"<CREATED_BY>%ld</CREATED_BY>",this -> created_by);
01052 dest += slask;
01053 dest += "<CREATED_DATE>" + q.GetDatabase().xmlsafestr(this -> created_date) + "</CREATED_DATE>";
01054 dest += "</CHUNK>";
01055 return dest;
01056 }
01057
01058
01059 std::string Chunk::xml(const std::string& tag,const std::string& xvalx)
01060 {
01061 Query q(*database);
01062 std::string dest;
01063 char slask[200];
01064 dest = "<CHUNK " + tag + "=\"" + xvalx + "\">";
01065 sprintf(slask,"<NUM>%ld</NUM>",this -> num);
01066 dest += slask;
01067 sprintf(slask,"<AREA>%ld</AREA>",this -> area);
01068 dest += slask;
01069 dest += "<TERRAIN>" + q.GetDatabase().xmlsafestr(this -> terrain) + "</TERRAIN>";
01070 sprintf(slask,"<X>%ld</X>",this -> x);
01071 dest += slask;
01072 sprintf(slask,"<Y>%ld</Y>",this -> y);
01073 dest += slask;
01074 sprintf(slask,"<Z>%ld</Z>",this -> z);
01075 dest += slask;
01076 sprintf(slask,"<CREATED_BY>%ld</CREATED_BY>",this -> created_by);
01077 dest += slask;
01078 dest += "<CREATED_DATE>" + q.GetDatabase().xmlsafestr(this -> created_date) + "</CREATED_DATE>";
01079 dest += "</CHUNK>";
01080 return dest;
01081 }
01082
01083
01084 size_t Chunk::num_cols()
01085 {
01086 return 8;
01087 }
01088
01089
01090 void Chunk::clear()
01091 {
01092 this -> num = 0;
01093 this -> area = 0;
01094 this -> terrain = "";
01095 this -> x = 0;
01096 this -> y = 0;
01097 this -> z = 0;
01098 this -> created_by = 0;
01099 this -> created_date = "";
01100 }
01101
01102
01103 void Chunk::spawn(const std::string& sql)
01104 {
01105 Query q(*database);
01106 std::string temp;
01107
01108 clear();
01109
01110 if (!strncasecmp(sql.c_str(),"select * ",9))
01111 {
01112 temp = "select num,area,terrain,x,y,z,created_by,created_date " + sql.substr(9);
01113 } else
01114 temp = sql;
01115 q.get_result(temp);
01116 if (q.fetch_row())
01117 {
01118 this -> num = q.getval(0);
01119 this -> area = q.getval(1);
01120 this -> terrain = q.getstr(2);
01121 this -> x = q.getval(3);
01122 this -> y = q.getval(4);
01123 this -> z = q.getval(5);
01124 this -> created_by = q.getval(6);
01125 this -> created_date = q.getstr(7);
01126 new_object = 0;
01127 } else
01128 clear();
01129 q.free_result();
01130 }
01131
01132
01133 void Chunk::spawn(Query *qd,int offset)
01134 {
01135 clear();
01136
01137 this -> num = qd -> getval(0 + offset);
01138 this -> area = qd -> getval(1 + offset);
01139 this -> terrain = qd -> getstr(2 + offset);
01140 this -> x = qd -> getval(3 + offset);
01141 this -> y = qd -> getval(4 + offset);
01142 this -> z = qd -> getval(5 + offset);
01143 this -> created_by = qd -> getval(6 + offset);
01144 this -> created_date = qd -> getstr(7 + offset);
01145 }
01146
01147
01148
01149
01150 }
01151 namespace db {
01152
01157 Chunkinfo::Chunkinfo(Database *db)
01158 {
01159 database = db;
01160 new_object = 1;
01161 clear();
01162 }
01163
01164
01165 Chunkinfo::Chunkinfo(Database *db,const std::string& sql)
01166 {
01167 database = db;
01168 new_object = 1;
01169 spawn(sql);
01170 }
01171
01172
01173 Chunkinfo::Chunkinfo(Database *db,Query *qd,int offset)
01174 {
01175 database = db;
01176 new_object = 0;
01177 spawn(qd, offset);
01178 }
01179
01180
01181 Chunkinfo::Chunkinfo(Database& db,long i_num):database(&db),new_object(1)
01182 {
01183 Query q(*database);
01184 std::string sql = "select * from chunkinfo where ";
01185 {
01186 char slask[100];
01187 sprintf(slask,"num='%ld'",i_num);
01188 sql += slask;
01189 }
01190 spawn(sql);
01191 }
01192
01193
01194 Chunkinfo::Chunkinfo(Database& db,long i_chunk,long i_type,long i_x,long i_y):database(&db),new_object(1)
01195 {
01196 Query q(*database);
01197 std::string sql = "select * from chunkinfo where ";
01198 {
01199 char slask[100];
01200 sprintf(slask,"chunk='%ld'",i_chunk);
01201 sql += slask;
01202 }
01203 {
01204 char slask[100];
01205 sprintf(slask," and type='%ld'",i_type);
01206 sql += slask;
01207 }
01208 {
01209 char slask[100];
01210 sprintf(slask," and x='%ld'",i_x);
01211 sql += slask;
01212 }
01213 {
01214 char slask[100];
01215 sprintf(slask," and y='%ld'",i_y);
01216 sql += slask;
01217 }
01218 spawn(sql);
01219 }
01220
01221
01222 Chunkinfo::~Chunkinfo()
01223 {
01224 }
01225
01226
01227 void Chunkinfo::select(const std::string& sql)
01228 {
01229 spawn(sql);
01230 }
01231
01232
01233 unsigned long long int Chunkinfo::insert()
01234 {
01235 Query q(*database);
01236 std::string sql;
01237
01238 sql = "insert into chunkinfo(chunk,type,x,y,data,to_area,to_chunk,to_x,to_y)";
01239 {
01240 char slask[100];
01241 sprintf(slask," values(%ld",this -> chunk);
01242 sql += slask;
01243 }
01244 {
01245 char slask[100];
01246 sprintf(slask,", %ld",this -> type);
01247 sql += slask;
01248 }
01249 {
01250 char slask[100];
01251 sprintf(slask,", %ld",this -> x);
01252 sql += slask;
01253 }
01254 {
01255 char slask[100];
01256 sprintf(slask,", %ld",this -> y);
01257 sql += slask;
01258 }
01259 sql += ", '" + q.GetDatabase().safestr(this -> data) + "'";
01260 {
01261 char slask[100];
01262 sprintf(slask,", %ld",this -> to_area);
01263 sql += slask;
01264 }
01265 {
01266 char slask[100];
01267 sprintf(slask,", %ld",this -> to_chunk);
01268 sql += slask;
01269 }
01270 {
01271 char slask[100];
01272 sprintf(slask,", %ld",this -> to_x);
01273 sql += slask;
01274 }
01275 {
01276 char slask[100];
01277 sprintf(slask,", %ld",this -> to_y);
01278 sql += slask;
01279 }
01280 sql += ")";
01281 q.execute(sql);
01282 new_object = 0;
01283 unsigned long long int inserted_id = q.insert_id();
01284 num = inserted_id;
01285 return inserted_id;
01286 }
01287
01288
01289 void Chunkinfo::update()
01290 {
01291 update(this -> num);
01292 }
01293
01294
01295 void Chunkinfo::update(long i_num)
01296 {
01297 Query q(*database);
01298 std::string sql;
01299 {
01300 char slask[200];
01301 sprintf(slask,"update chunkinfo set chunk=%ld",this -> chunk);
01302 sql += slask;
01303 }
01304 {
01305 char slask[200];
01306 sprintf(slask,", type=%ld",this -> type);
01307 sql += slask;
01308 }
01309 {
01310 char slask[200];
01311 sprintf(slask,", x=%ld",this -> x);
01312 sql += slask;
01313 }
01314 {
01315 char slask[200];
01316 sprintf(slask,", y=%ld",this -> y);
01317 sql += slask;
01318 }
01319 sql += ", data='" + q.GetDatabase().safestr(this -> data) + "'";
01320 {
01321 char slask[200];
01322 sprintf(slask,", to_area=%ld",this -> to_area);
01323 sql += slask;
01324 }
01325 {
01326 char slask[200];
01327 sprintf(slask,", to_chunk=%ld",this -> to_chunk);
01328 sql += slask;
01329 }
01330 {
01331 char slask[200];
01332 sprintf(slask,", to_x=%ld",this -> to_x);
01333 sql += slask;
01334 }
01335 {
01336 char slask[200];
01337 sprintf(slask,", to_y=%ld",this -> to_y);
01338 sql += slask;
01339 }
01340 {
01341 char slask[200];
01342 sprintf(slask," where num='%ld'",i_num);
01343 sql += slask;
01344 }
01345 q.execute(sql);
01346 }
01347
01348
01349 void Chunkinfo::save()
01350 {
01351 if (new_object)
01352 insert();
01353 else
01354 update();
01355 }
01356
01357
01358 void Chunkinfo::erase()
01359 {
01360 if (!new_object)
01361 {
01362 std::string sql = "delete from chunkinfo where";
01363 Query q(*database);
01364 {
01365 char slask[200];
01366 sprintf(slask," num='%ld'",this -> num);
01367 sql += slask;
01368 }
01369 q.execute(sql);
01370 }
01371 }
01372
01373
01374 std::string Chunkinfo::xml()
01375 {
01376 Query q(*database);
01377 std::string dest;
01378 char slask[200];
01379 dest = "<CHUNKINFO>";
01380 sprintf(slask,"<NUM>%ld</NUM>",this -> num);
01381 dest += slask;
01382 sprintf(slask,"<CHUNK>%ld</CHUNK>",this -> chunk);
01383 dest += slask;
01384 sprintf(slask,"<TYPE>%ld</TYPE>",this -> type);
01385 dest += slask;
01386 sprintf(slask,"<X>%ld</X>",this -> x);
01387 dest += slask;
01388 sprintf(slask,"<Y>%ld</Y>",this -> y);
01389 dest += slask;
01390 dest += "<DATA>" + q.GetDatabase().xmlsafestr(this -> data) + "</DATA>";
01391 sprintf(slask,"<TO_AREA>%ld</TO_AREA>",this -> to_area);
01392 dest += slask;
01393 sprintf(slask,"<TO_CHUNK>%ld</TO_CHUNK>",this -> to_chunk);
01394 dest += slask;
01395 sprintf(slask,"<TO_X>%ld</TO_X>",this -> to_x);
01396 dest += slask;
01397 sprintf(slask,"<TO_Y>%ld</TO_Y>",this -> to_y);
01398 dest += slask;
01399 dest += "</CHUNKINFO>";
01400 return dest;
01401 }
01402
01403
01404 std::string Chunkinfo::xml(const std::string& tag,const std::string& xvalx)
01405 {
01406 Query q(*database);
01407 std::string dest;
01408 char slask[200];
01409 dest = "<CHUNKINFO " + tag + "=\"" + xvalx + "\">";
01410 sprintf(slask,"<NUM>%ld</NUM>",this -> num);
01411 dest += slask;
01412 sprintf(slask,"<CHUNK>%ld</CHUNK>",this -> chunk);
01413 dest += slask;
01414 sprintf(slask,"<TYPE>%ld</TYPE>",this -> type);
01415 dest += slask;
01416 sprintf(slask,"<X>%ld</X>",this -> x);
01417 dest += slask;
01418 sprintf(slask,"<Y>%ld</Y>",this -> y);
01419 dest += slask;
01420 dest += "<DATA>" + q.GetDatabase().xmlsafestr(this -> data) + "</DATA>";
01421 sprintf(slask,"<TO_AREA>%ld</TO_AREA>",this -> to_area);
01422 dest += slask;
01423 sprintf(slask,"<TO_CHUNK>%ld</TO_CHUNK>",this -> to_chunk);
01424 dest += slask;
01425 sprintf(slask,"<TO_X>%ld</TO_X>",this -> to_x);
01426 dest += slask;
01427 sprintf(slask,"<TO_Y>%ld</TO_Y>",this -> to_y);
01428 dest += slask;
01429 dest += "</CHUNKINFO>";
01430 return dest;
01431 }
01432
01433
01434 size_t Chunkinfo::num_cols()
01435 {
01436 return 10;
01437 }
01438
01439
01440 void Chunkinfo::clear()
01441 {
01442 this -> num = 0;
01443 this -> chunk = 0;
01444 this -> type = 0;
01445 this -> x = 0;
01446 this -> y = 0;
01447 this -> data = "";
01448 this -> to_area = 0;
01449 this -> to_chunk = 0;
01450 this -> to_x = 0;
01451 this -> to_y = 0;
01452 }
01453
01454
01455 void Chunkinfo::spawn(const std::string& sql)
01456 {
01457 Query q(*database);
01458 std::string temp;
01459
01460 clear();
01461
01462 if (!strncasecmp(sql.c_str(),"select * ",9))
01463 {
01464 temp = "select num,chunk,type,x,y,data,to_area,to_chunk,to_x,to_y " + sql.substr(9);
01465 } else
01466 temp = sql;
01467 q.get_result(temp);
01468 if (q.fetch_row())
01469 {
01470 this -> num = q.getval(0);
01471 this -> chunk = q.getval(1);
01472 this -> type = q.getval(2);
01473 this -> x = q.getval(3);
01474 this -> y = q.getval(4);
01475 this -> data = q.getstr(5);
01476 this -> to_area = q.getval(6);
01477 this -> to_chunk = q.getval(7);
01478 this -> to_x = q.getval(8);
01479 this -> to_y = q.getval(9);
01480 new_object = 0;
01481 } else
01482 clear();
01483 q.free_result();
01484 }
01485
01486
01487 void Chunkinfo::spawn(Query *qd,int offset)
01488 {
01489 clear();
01490
01491 this -> num = qd -> getval(0 + offset);
01492 this -> chunk = qd -> getval(1 + offset);
01493 this -> type = qd -> getval(2 + offset);
01494 this -> x = qd -> getval(3 + offset);
01495 this -> y = qd -> getval(4 + offset);
01496 this -> data = qd -> getstr(5 + offset);
01497 this -> to_area = qd -> getval(6 + offset);
01498 this -> to_chunk = qd -> getval(7 + offset);
01499 this -> to_x = qd -> getval(8 + offset);
01500 this -> to_y = qd -> getval(9 + offset);
01501 }
01502
01503
01504
01505
01506 }
01507 namespace db {
01508
01513 Terrain::Terrain(Database *db)
01514 {
01515 database = db;
01516 new_object = 1;
01517 clear();
01518 }
01519
01520
01521 Terrain::Terrain(Database *db,const std::string& sql)
01522 {
01523 database = db;
01524 new_object = 1;
01525 spawn(sql);
01526 }
01527
01528
01529 Terrain::Terrain(Database *db,Query *qd,int offset)
01530 {
01531 database = db;
01532 new_object = 0;
01533 spawn(qd, offset);
01534 }
01535
01536
01537 Terrain::Terrain(Database& db,long i_num):database(&db),new_object(1)
01538 {
01539 Query q(*database);
01540 std::string sql = "select * from terrain where ";
01541 {
01542 char slask[100];
01543 sprintf(slask,"num='%ld'",i_num);
01544 sql += slask;
01545 }
01546 spawn(sql);
01547 }
01548
01549
01550 Terrain::Terrain(Database& db,long i_area,const std::string& i_tchar):database(&db),new_object(1)
01551 {
01552 Query q(*database);
01553 std::string sql = "select * from terrain where ";
01554 {
01555 char slask[100];
01556 sprintf(slask,"area='%ld'",i_area);
01557 sql += slask;
01558 }
01559 sql += " and tchar='" + q.GetDatabase().safestr(i_tchar) + "'";
01560 spawn(sql);
01561 }
01562
01563
01564 Terrain::~Terrain()
01565 {
01566 }
01567
01568
01569 void Terrain::select(const std::string& sql)
01570 {
01571 spawn(sql);
01572 }
01573
01574
01575 unsigned long long int Terrain::insert()
01576 {
01577 Query q(*database);
01578 std::string sql;
01579
01580 sql = "insert into terrain(area,name,tchar,tcolor,impassable,delay)";
01581 {
01582 char slask[100];
01583 sprintf(slask," values(%ld",this -> area);
01584 sql += slask;
01585 }
01586 sql += ", '" + q.GetDatabase().safestr(this -> name) + "'";
01587 sql += ", '" + q.GetDatabase().safestr(this -> tchar) + "'";
01588 sql += ", '" + q.GetDatabase().safestr(this -> tcolor) + "'";
01589 {
01590 char slask[100];
01591 sprintf(slask,", %ld",this -> impassable);
01592 sql += slask;
01593 }
01594 {
01595 char slask[100];
01596 sprintf(slask,", %f",this -> delay);
01597 sql += slask;
01598 }
01599 sql += ")";
01600 q.execute(sql);
01601 new_object = 0;
01602 unsigned long long int inserted_id = q.insert_id();
01603 num = inserted_id;
01604 return inserted_id;
01605 }
01606
01607
01608 void Terrain::update()
01609 {
01610 update(this -> num);
01611 }
01612
01613
01614 void Terrain::update(long i_num)
01615 {
01616 Query q(*database);
01617 std::string sql;
01618 {
01619 char slask[200];
01620 sprintf(slask,"update terrain set area=%ld",this -> area);
01621 sql += slask;
01622 }
01623 sql += ", name='" + q.GetDatabase().safestr(this -> name) + "'";
01624 sql += ", tchar='" + q.GetDatabase().safestr(this -> tchar) + "'";
01625 sql += ", tcolor='" + q.GetDatabase().safestr(this -> tcolor) + "'";
01626 {
01627 char slask[200];
01628 sprintf(slask,", impassable=%ld",this -> impassable);
01629 sql += slask;
01630 }
01631 {
01632 char slask[200];
01633 sprintf(slask,", delay='%f'",this -> delay);
01634 sql += slask;
01635 }
01636 {
01637 char slask[200];
01638 sprintf(slask," where num='%ld'",i_num);
01639 sql += slask;
01640 }
01641 q.execute(sql);
01642 }
01643
01644
01645 void Terrain::save()
01646 {
01647 if (new_object)
01648 insert();
01649 else
01650 update();
01651 }
01652
01653
01654 void Terrain::erase()
01655 {
01656 if (!new_object)
01657 {
01658 std::string sql = "delete from terrain where";
01659 Query q(*database);
01660 {
01661 char slask[200];
01662 sprintf(slask," num='%ld'",this -> num);
01663 sql += slask;
01664 }
01665 q.execute(sql);
01666 }
01667 }
01668
01669
01670 std::string Terrain::xml()
01671 {
01672 Query q(*database);
01673 std::string dest;
01674 char slask[200];
01675 dest = "<TERRAIN>";
01676 sprintf(slask,"<NUM>%ld</NUM>",this -> num);
01677 dest += slask;
01678 sprintf(slask,"<AREA>%ld</AREA>",this -> area);
01679 dest += slask;
01680 dest += "<NAME>" + q.GetDatabase().xmlsafestr(this -> name) + "</NAME>";
01681 dest += "<TCHAR>" + q.GetDatabase().xmlsafestr(this -> tchar) + "</TCHAR>";
01682 dest += "<TCOLOR>" + q.GetDatabase().xmlsafestr(this -> tcolor) + "</TCOLOR>";
01683 sprintf(slask,"<IMPASSABLE>%ld</IMPASSABLE>",this -> impassable);
01684 dest += slask;
01685 sprintf(slask,"<DELAY>%f</DELAY>",this -> delay);
01686 dest += slask;
01687 dest += "</TERRAIN>";
01688 return dest;
01689 }
01690
01691
01692 std::string Terrain::xml(const std::string& tag,const std::string& xvalx)
01693 {
01694 Query q(*database);
01695 std::string dest;
01696 char slask[200];
01697 dest = "<TERRAIN " + tag + "=\"" + xvalx + "\">";
01698 sprintf(slask,"<NUM>%ld</NUM>",this -> num);
01699 dest += slask;
01700 sprintf(slask,"<AREA>%ld</AREA>",this -> area);
01701 dest += slask;
01702 dest += "<NAME>" + q.GetDatabase().xmlsafestr(this -> name) + "</NAME>";
01703 dest += "<TCHAR>" + q.GetDatabase().xmlsafestr(this -> tchar) + "</TCHAR>";
01704 dest += "<TCOLOR>" + q.GetDatabase().xmlsafestr(this -> tcolor) + "</TCOLOR>";
01705 sprintf(slask,"<IMPASSABLE>%ld</IMPASSABLE>",this -> impassable);
01706 dest += slask;
01707 sprintf(slask,"<DELAY>%f</DELAY>",this -> delay);
01708 dest += slask;
01709 dest += "</TERRAIN>";
01710 return dest;
01711 }
01712
01713
01714 size_t Terrain::num_cols()
01715 {
01716 return 7;
01717 }
01718
01719
01720 void Terrain::clear()
01721 {
01722 this -> num = 0;
01723 this -> area = 0;
01724 this -> name = "";
01725 this -> tchar = "";
01726 this -> tcolor = "";
01727 this -> impassable = 0;
01728 this -> delay = 0;
01729 }
01730
01731
01732 void Terrain::spawn(const std::string& sql)
01733 {
01734 Query q(*database);
01735 std::string temp;
01736
01737 clear();
01738
01739 if (!strncasecmp(sql.c_str(),"select * ",9))
01740 {
01741 temp = "select num,area,name,tchar,tcolor,impassable,delay " + sql.substr(9);
01742 } else
01743 temp = sql;
01744 q.get_result(temp);
01745 if (q.fetch_row())
01746 {
01747 this -> num = q.getval(0);
01748 this -> area = q.getval(1);
01749 this -> name = q.getstr(2);
01750 this -> tchar = q.getstr(3);
01751 this -> tcolor = q.getstr(4);
01752 this -> impassable = q.getval(5);
01753 this -> delay = q.getnum(6);
01754 new_object = 0;
01755 } else
01756 clear();
01757 q.free_result();
01758 }
01759
01760
01761 void Terrain::spawn(Query *qd,int offset)
01762 {
01763 clear();
01764
01765 this -> num = qd -> getval(0 + offset);
01766 this -> area = qd -> getval(1 + offset);
01767 this -> name = qd -> getstr(2 + offset);
01768 this -> tchar = qd -> getstr(3 + offset);
01769 this -> tcolor = qd -> getstr(4 + offset);
01770 this -> impassable = qd -> getval(5 + offset);
01771 this -> delay = qd -> getnum(6 + offset);
01772 }
01773
01774
01775
01776
01777 }
01778 namespace db {
01779
01784 Steps::Steps(Database *db)
01785 {
01786 database = db;
01787 new_object = 1;
01788 clear();
01789 }
01790
01791
01792 Steps::Steps(Database *db,const std::string& sql)
01793 {
01794 database = db;
01795 new_object = 1;
01796 spawn(sql);
01797 }
01798
01799
01800 Steps::Steps(Database *db,Query *qd,int offset)
01801 {
01802 database = db;
01803 new_object = 0;
01804 spawn(qd, offset);
01805 }
01806
01807
01808 Steps::Steps(Database& db,long i_num):database(&db),new_object(1)
01809 {
01810 Query q(*database);
01811 std::string sql = "select * from steps where ";
01812 {
01813 char slask[100];
01814 sprintf(slask,"num='%ld'",i_num);
01815 sql += slask;
01816 }
01817 spawn(sql);
01818 }
01819
01820
01821 Steps::Steps(Database& db,long i_player,long i_area,long i_zcoord,long i_ycoord):database(&db),new_object(1)
01822 {
01823 Query q(*database);
01824 std::string sql = "select * from steps where ";
01825 {
01826 char slask[100];
01827 sprintf(slask,"player='%ld'",i_player);
01828 sql += slask;
01829 }
01830 {
01831 char slask[100];
01832 sprintf(slask," and area='%ld'",i_area);
01833 sql += slask;
01834 }
01835 {
01836 char slask[100];
01837 sprintf(slask," and zcoord='%ld'",i_zcoord);
01838 sql += slask;
01839 }
01840 {
01841 char slask[100];
01842 sprintf(slask," and ycoord='%ld'",i_ycoord);
01843 sql += slask;
01844 }
01845 spawn(sql);
01846 }
01847
01848
01849 Steps::~Steps()
01850 {
01851 }
01852
01853
01854 void Steps::select(const std::string& sql)
01855 {
01856 spawn(sql);
01857 }
01858
01859
01860 unsigned long long int Steps::insert()
01861 {
01862 Query q(*database);
01863 std::string sql;
01864
01865 sql = "insert into steps(player,area,zcoord,ycoord,xcoords)";
01866 {
01867 char slask[100];
01868 sprintf(slask," values(%ld",this -> player);
01869 sql += slask;
01870 }
01871 {
01872 char slask[100];
01873 sprintf(slask,", %ld",this -> area);
01874 sql += slask;
01875 }
01876 {
01877 char slask[100];
01878 sprintf(slask,", %ld",this -> zcoord);
01879 sql += slask;
01880 }
01881 {
01882 char slask[100];
01883 sprintf(slask,", %ld",this -> ycoord);
01884 sql += slask;
01885 }
01886 sql += ", '" + q.GetDatabase().safestr(this -> xcoords) + "'";
01887 sql += ")";
01888 q.execute(sql);
01889 new_object = 0;
01890 unsigned long long int inserted_id = q.insert_id();
01891 num = inserted_id;
01892 return inserted_id;
01893 }
01894
01895
01896 void Steps::update()
01897 {
01898 update(this -> num);
01899 }
01900
01901
01902 void Steps::update(long i_num)
01903 {
01904 Query q(*database);
01905 std::string sql;
01906 {
01907 char slask[200];
01908 sprintf(slask,"update steps set player=%ld",this -> player);
01909 sql += slask;
01910 }
01911 {
01912 char slask[200];
01913 sprintf(slask,", area=%ld",this -> area);
01914 sql += slask;
01915 }
01916 {
01917 char slask[200];
01918 sprintf(slask,", zcoord=%ld",this -> zcoord);
01919 sql += slask;
01920 }
01921 {
01922 char slask[200];
01923 sprintf(slask,", ycoord=%ld",this -> ycoord);
01924 sql += slask;
01925 }
01926 sql += ", xcoords='" + q.GetDatabase().safestr(this -> xcoords) + "'";
01927 {
01928 char slask[200];
01929 sprintf(slask," where num='%ld'",i_num);
01930 sql += slask;
01931 }
01932 q.execute(sql);
01933 }
01934
01935
01936 void Steps::save()
01937 {
01938 if (new_object)
01939 insert();
01940 else
01941 update();
01942 }
01943
01944
01945 void Steps::erase()
01946 {
01947 if (!new_object)
01948 {
01949 std::string sql = "delete from steps where";
01950 Query q(*database);
01951 {
01952 char slask[200];
01953 sprintf(slask," num='%ld'",this -> num);
01954 sql += slask;
01955 }
01956 q.execute(sql);
01957 }
01958 }
01959
01960
01961 std::string Steps::xml()
01962 {
01963 Query q(*database);
01964 std::string dest;
01965 char slask[200];
01966 dest = "<STEPS>";
01967 sprintf(slask,"<NUM>%ld</NUM>",this -> num);
01968 dest += slask;
01969 sprintf(slask,"<PLAYER>%ld</PLAYER>",this -> player);
01970 dest += slask;
01971 sprintf(slask,"<AREA>%ld</AREA>",this -> area);
01972 dest += slask;
01973 sprintf(slask,"<ZCOORD>%ld</ZCOORD>",this -> zcoord);
01974 dest += slask;
01975 sprintf(slask,"<YCOORD>%ld</YCOORD>",this -> ycoord);
01976 dest += slask;
01977 dest += "<XCOORDS>" + q.GetDatabase().xmlsafestr(this -> xcoords) + "</XCOORDS>";
01978 dest += "</STEPS>";
01979 return dest;
01980 }
01981
01982
01983 std::string Steps::xml(const std::string& tag,const std::string& xvalx)
01984 {
01985 Query q(*database);
01986 std::string dest;
01987 char slask[200];
01988 dest = "<STEPS " + tag + "=\"" + xvalx + "\">";
01989 sprintf(slask,"<NUM>%ld</NUM>",this -> num);
01990 dest += slask;
01991 sprintf(slask,"<PLAYER>%ld</PLAYER>",this -> player);
01992 dest += slask;
01993 sprintf(slask,"<AREA>%ld</AREA>",this -> area);
01994 dest += slask;
01995 sprintf(slask,"<ZCOORD>%ld</ZCOORD>",this -> zcoord);
01996 dest += slask;
01997 sprintf(slask,"<YCOORD>%ld</YCOORD>",this -> ycoord);
01998 dest += slask;
01999 dest += "<XCOORDS>" + q.GetDatabase().xmlsafestr(this -> xcoords) + "</XCOORDS>";
02000 dest += "</STEPS>";
02001 return dest;
02002 }
02003
02004
02005 size_t Steps::num_cols()
02006 {
02007 return 6;
02008 }
02009
02010
02011 void Steps::clear()
02012 {
02013 this -> num = 0;
02014 this -> player = 0;
02015 this -> area = 0;
02016 this -> zcoord = 0;
02017 this -> ycoord = 0;
02018 this -> xcoords = "";
02019 }
02020
02021
02022 void Steps::spawn(const std::string& sql)
02023 {
02024 Query q(*database);
02025 std::string temp;
02026
02027 clear();
02028
02029 if (!strncasecmp(sql.c_str(),"select * ",9))
02030 {
02031 temp = "select num,player,area,zcoord,ycoord,xcoords " + sql.substr(9);
02032 } else
02033 temp = sql;
02034 q.get_result(temp);
02035 if (q.fetch_row())
02036 {
02037 this -> num = q.getval(0);
02038 this -> player = q.getval(1);
02039 this -> area = q.getval(2);
02040 this -> zcoord = q.getval(3);
02041 this -> ycoord = q.getval(4);
02042 this -> xcoords = q.getstr(5);
02043 new_object = 0;
02044 } else
02045 clear();
02046 q.free_result();
02047 }
02048
02049
02050 void Steps::spawn(Query *qd,int offset)
02051 {
02052 clear();
02053
02054 this -> num = qd -> getval(0 + offset);
02055 this -> player = qd -> getval(1 + offset);
02056 this -> area = qd -> getval(2 + offset);
02057 this -> zcoord = qd -> getval(3 + offset);
02058 this -> ycoord = qd -> getval(4 + offset);
02059 this -> xcoords = qd -> getstr(5 + offset);
02060 }
02061
02062
02063
02064
02065 }
02066 namespace db {
02067
02072 Race::Race(Database *db)
02073 {
02074 database = db;
02075 new_object = 1;
02076 clear();
02077 }
02078
02079
02080 Race::Race(Database *db,const std::string& sql)
02081 {
02082 database = db;
02083 new_object = 1;
02084 spawn(sql);
02085 }
02086
02087
02088 Race::Race(Database *db,Query *qd,int offset)
02089 {
02090 database = db;
02091 new_object = 0;
02092 spawn(qd, offset);
02093 }
02094
02095
02096 Race::Race(Database& db,long i_num):database(&db),new_object(1)
02097 {
02098 Query q(*database);
02099 std::string sql = "select * from race where ";
02100 {
02101 char slask[100];
02102 sprintf(slask,"num='%ld'",i_num);
02103 sql += slask;
02104 }
02105 spawn(sql);
02106 }
02107
02108
02109 Race::Race(Database& db,const std::string& i_name):database(&db),new_object(1)
02110 {
02111 Query q(*database);
02112 std::string sql = "select * from race where ";
02113 sql += "name='" + q.GetDatabase().safestr(i_name) + "'";
02114 spawn(sql);
02115 }
02116
02117
02118 Race::~Race()
02119 {
02120 }
02121
02122
02123 void Race::select(const std::string& sql)
02124 {
02125 spawn(sql);
02126 }
02127
02128
02129 unsigned long long int Race::insert()
02130 {
02131 Query q(*database);
02132 std::string sql;
02133
02134 sql = "insert into race(name,sightrange,hearing)";
02135 sql += " values('" + q.GetDatabase().safestr(this -> name) + "'";
02136 {
02137 char slask[100];
02138 sprintf(slask,", %f",this -> sightrange);
02139 sql += slask;
02140 }
02141 {
02142 char slask[100];
02143 sprintf(slask,", %f",this -> hearing);
02144 sql += slask;
02145 }
02146 sql += ")";
02147 q.execute(sql);
02148 new_object = 0;
02149 unsigned long long int inserted_id = q.insert_id();
02150 num = inserted_id;
02151 return inserted_id;
02152 }
02153
02154
02155 void Race::update()
02156 {
02157 update(this -> num);
02158 }
02159
02160
02161 void Race::update(long i_num)
02162 {
02163 Query q(*database);
02164 std::string sql;
02165 sql += "update race set name='" + q.GetDatabase().safestr(this -> name) + "'";
02166 {
02167 char slask[200];
02168 sprintf(slask,", sightrange='%f'",this -> sightrange);
02169 sql += slask;
02170 }
02171 {
02172 char slask[200];
02173 sprintf(slask,", hearing='%f'",this -> hearing);
02174 sql += slask;
02175 }
02176 {
02177 char slask[200];
02178 sprintf(slask," where num='%ld'",i_num);
02179 sql += slask;
02180 }
02181 q.execute(sql);
02182 }
02183
02184
02185 void Race::save()
02186 {
02187 if (new_object)
02188 insert();
02189 else
02190 update();
02191 }
02192
02193
02194 void Race::erase()
02195 {
02196 if (!new_object)
02197 {
02198 std::string sql = "delete from race where";
02199 Query q(*database);
02200 {
02201 char slask[200];
02202 sprintf(slask," num='%ld'",this -> num);
02203 sql += slask;
02204 }
02205 q.execute(sql);
02206 }
02207 }
02208
02209
02210 std::string Race::xml()
02211 {
02212 Query q(*database);
02213 std::string dest;
02214 char slask[200];
02215 dest = "<RACE>";
02216 sprintf(slask,"<NUM>%ld</NUM>",this -> num);
02217 dest += slask;
02218 dest += "<NAME>" + q.GetDatabase().xmlsafestr(this -> name) + "</NAME>";
02219 sprintf(slask,"<SIGHTRANGE>%f</SIGHTRANGE>",this -> sightrange);
02220 dest += slask;
02221 sprintf(slask,"<HEARING>%f</HEARING>",this -> hearing);
02222 dest += slask;
02223 dest += "</RACE>";
02224 return dest;
02225 }
02226
02227
02228 std::string Race::xml(const std::string& tag,const std::string& xvalx)
02229 {
02230 Query q(*database);
02231 std::string dest;
02232 char slask[200];
02233 dest = "<RACE " + tag + "=\"" + xvalx + "\">";
02234 sprintf(slask,"<NUM>%ld</NUM>",this -> num);
02235 dest += slask;
02236 dest += "<NAME>" + q.GetDatabase().xmlsafestr(this -> name) + "</NAME>";
02237 sprintf(slask,"<SIGHTRANGE>%f</SIGHTRANGE>",this -> sightrange);
02238 dest += slask;
02239 sprintf(slask,"<HEARING>%f</HEARING>",this -> hearing);
02240 dest += slask;
02241 dest += "</RACE>";
02242 return dest;
02243 }
02244
02245
02246 size_t Race::num_cols()
02247 {
02248 return 4;
02249 }
02250
02251
02252 void Race::clear()
02253 {
02254 this -> num = 0;
02255 this -> name = "";
02256 this -> sightrange = 0;
02257 this -> hearing = 0;
02258 }
02259
02260
02261 void Race::spawn(const std::string& sql)
02262 {
02263 Query q(*database);
02264 std::string temp;
02265
02266 clear();
02267
02268 if (!strncasecmp(sql.c_str(),"select * ",9))
02269 {
02270 temp = "select num,name,sightrange,hearing " + sql.substr(9);
02271 } else
02272 temp = sql;
02273 q.get_result(temp);
02274 if (q.fetch_row())
02275 {
02276 this -> num = q.getval(0);
02277 this -> name = q.getstr(1);
02278 this -> sightrange = q.getnum(2);
02279 this -> hearing = q.getnum(3);
02280 new_object = 0;
02281 } else
02282 clear();
02283 q.free_result();
02284 }
02285
02286
02287 void Race::spawn(Query *qd,int offset)
02288 {
02289 clear();
02290
02291 this -> num = qd -> getval(0 + offset);
02292 this -> name = qd -> getstr(1 + offset);
02293 this -> sightrange = qd -> getnum(2 + offset);
02294 this -> hearing = qd -> getnum(3 + offset);
02295 }
02296
02297
02298
02299
02300 }