void Prefs_PageSizes::restoreDefaults(struct ApplicationPrefs *prefsData)
{
PageSize ps(prefsData->docSetupPrefs.pageSize);
QStringList sizeList(ps.sizeList());
QStringList activeSizeList(ps.activeSizeList());
activeSizesListWidget->clear();
availableSizesListWidget->clear();
for (int i = 0; i < activeSizeList.count(); ++i)
{
QListWidgetItem* lwi=new QListWidgetItem();
PageSize ps2(activeSizeList.at(i));
lwi->setText(ps2.nameTR());
lwi->setToolTip(QString("%1 x %2 %3").arg(ps2.originalWidth()).arg(ps2.originalHeight()).arg(ps2.originalUnit()));
activeSizesListWidget->addItem(lwi);
}
for (int i = 0; i < sizeList.count(); ++i)
{
if (!activeSizeList.contains(sizeList.at(i)))
{
QListWidgetItem* lwi=new QListWidgetItem();
PageSize ps2(sizeList.at(i));
lwi->setText(ps2.nameTR());
lwi->setToolTip(QString("%1 x %2 %3").arg(ps2.originalWidth()).arg(ps2.originalHeight()).arg(ps2.originalUnit()));
availableSizesListWidget->addItem(lwi);
}
}
}
void MapgenV6::generateCaves(int max_stone_y)
{
float cave_amount = NoisePerlin2D(np_cave, node_min.X, node_min.Y, seed);
int volume_nodes = (node_max.X - node_min.X + 1) *
(node_max.Y - node_min.Y + 1) * MAP_BLOCKSIZE;
cave_amount = MYMAX(0.0, cave_amount);
u32 caves_count = cave_amount * volume_nodes / 50000;
u32 bruises_count = 1;
PseudoRandom ps(blockseed + 21343);
PseudoRandom ps2(blockseed + 1032);
if (ps.range(1, 6) == 1)
bruises_count = ps.range(0, ps.range(0, 2));
if (getBiome(node_min) == BT_DESERT) {
caves_count /= 3;
bruises_count /= 3;
}
for (u32 i = 0; i < caves_count + bruises_count; i++) {
bool large_cave = (i >= caves_count);
CaveV6 cave(this, &ps, &ps2, large_cave);
cave.makeCave(node_min, node_max, max_stone_y);
}
}
void array_var_bool_element(IntVar* _x, vec<BoolView>& a, BoolView y, int offset) {
_x->specialiseToEL();
IntView<4> x(_x, 1, -offset);
vec<Lit> ps1(a.size()+1);
vec<Lit> ps2(a.size()+1);
// Add clause !y \/ c_1 \/ ... \/ c_n
// Add clause y \/ d_1 \/ ... \/ d_n
ps1[0] = ~y;
ps2[0] = y;
for (int i = 0; i < a.size(); i++) {
BoolView c_i(Lit(sat.newVar(),1));
BoolView d_i(Lit(sat.newVar(),1));
sat.addClause(~c_i, x = i);
sat.addClause(~c_i, a[i]);
sat.addClause(~d_i, x = i);
sat.addClause(~d_i, ~a[i]);
vec<Lit> ps3(3), ps4(3);
ps3[0] = y; ps3[1] = ~a[i]; ps3[2] = (x != i);
sat.addClause(ps3);
ps4[0] = ~y; ps4[1] = a[i]; ps4[2] = (x != i);
sat.addClause(ps4);
ps1[i+1] = c_i;
ps2[i+1] = d_i;
}
sat.addClause(ps1);
sat.addClause(ps2);
}
void MapgenV6::generateCaves(int max_stone_y)
{
float cave_amount = NoisePerlin2D(np_cave, node_min.X, node_min.Y, seed);
int volume_nodes = (node_max.X - node_min.X + 1) *
(node_max.Y - node_min.Y + 1) * MAP_BLOCKSIZE;
cave_amount = MYMAX(0.0, cave_amount);
u32 caves_count = cave_amount * volume_nodes / 50000;
u32 bruises_count = 1;
PseudoRandom ps(blockseed + 21343);
PseudoRandom ps2(blockseed + 1032);
if (ps.range(1, 6) == 1)
bruises_count = ps.range(0, ps.range(0, 2));
if (getBiome(v2s16(node_min.X, node_min.Z)) == BT_DESERT) {
caves_count /= 3;
bruises_count /= 3;
}
for (u32 i = 0; i < caves_count + bruises_count; i++) {
CavesV6 cave(ndef, &gennotify, water_level, c_water_source, c_lava_source);
bool large_cave = (i >= caves_count);
cave.makeCave(vm, node_min, node_max, &ps, &ps2,
large_cave, max_stone_y, heightmap);
}
}
void check_compare_y_at_x_left()
{
Polycurve_conic_traits_2 traits;
Polycurve_conic_traits_2::Construct_x_monotone_curve_2
construct_x_monotone_curve_2 = traits.construct_x_monotone_curve_2_object();
Polycurve_conic_traits_2::Compare_y_at_x_left_2 cmp_y_at_x_left_2 =
traits.compare_y_at_x_left_2_object();
//create constructing curves
Rat_point_2 ps2(1, 10);
Rat_point_2 pmid2(5, 4);
Rat_point_2 pt2(10, 1);
Conic_curve_2 c1(ps2, pmid2, pt2);
Rat_point_2 ps3(10, 1);
Rat_point_2 pmid3(5, 4);
Rat_point_2 pt3(1, 10);
Conic_curve_2 c2(ps3, pmid3, pt3);
//construct x-monotone curve(compatible with polyline class)
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc1 =
construct_x_monotone_curve_2(c1);
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc2 =
construct_x_monotone_curve_2(c2);
Polycurve_conic_traits_2::Point_2 intersection_point =
Polycurve_conic_traits_2::Point_2(5,4);
CGAL::Comparison_result result;
result = cmp_y_at_x_left_2(polyline_xmc1, polyline_xmc2, intersection_point);
std::cout << "Compare_y_at_x_left:: Expected Answer: equal, Computed answer: "
<< (result == CGAL::SMALLER ? "smaller":
(result == CGAL::LARGER ? "Larger" : "equal")) << std::endl;
}
void check_merge_2()
{
Polycurve_conic_traits_2 traits;
Polycurve_conic_traits_2::Construct_x_monotone_curve_2
construct_x_monotone_curve_2 = traits.construct_x_monotone_curve_2_object();
Polycurve_conic_traits_2::Merge_2 merge_2 = traits.merge_2_object();
//create a curve
Rat_point_2 ps1(1, 10);
Rat_point_2 pmid1(5, 4);
Rat_point_2 pt1(10, 1);
Conic_curve_2 c1(ps1, pmid1, pt1);
Rat_point_2 ps2(10, 1);
Rat_point_2 pmid2(15, 14);
Rat_point_2 pt2(20, 20);
Conic_curve_2 c2(ps2, pmid2, pt2);
//construct x-monotone curve (compatible with polyline class)
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc1 =
construct_x_monotone_curve_2(c1);
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc2 =
construct_x_monotone_curve_2(c2);
Polycurve_conic_traits_2::X_monotone_curve_2 merged_xmc;
merge_2(polyline_xmc1, polyline_xmc2, merged_xmc);
std::cout<< "Merge_2:: Mergable x-monotone curves merged successfully"
<< std:: endl;
}
int main()
{
printf("what");
//audio
av_config_setup();
//load_song("intro.wav");
//start_songO();
///PS2
ps2();
return 0;
}
void tst_QRegion::intersected_data()
{
QTest::addColumn<QRegion>("r1");
QTest::addColumn<QRegion>("r2");
QTest::addColumn<bool>("intersects");
// QTest::addColumn<QRegion>("intersected");
QPolygon ps1(8);
QPolygon ps2(8);
ps1.putPoints(0,8, 20,20, 50,20, 50,100, 70,100, 70,20, 120,20, 120,200, 20, 200);
ps2.putPoints(0,8, 100,150, 140,150, 140,160, 160,160, 160,150, 200,150, 200,180, 100,180);
QTest::newRow("task30716") << QRegion(ps1) << QRegion(ps2) << true;
}
void check_equal()
{
bool are_equal;
Polycurve_conic_traits_2 traits;
Polycurve_conic_traits_2::Equal_2 equal = traits.equal_2_object();
Polycurve_conic_traits_2::Construct_x_monotone_curve_2
construct_x_monotone_curve_2 = traits.construct_x_monotone_curve_2_object();
//create some curves
Conic_point_2 ps1(Rational(1,4), 4);
Conic_point_2 pt1(2, Rational(1,2));
Conic_curve_2 c1(0, 0, 1, 0, 0, -1, CGAL::COUNTERCLOCKWISE, ps1, pt1);
Conic_point_2 ps2(Rational(1,4), 4);
Conic_point_2 pt2(2, Rational(1,2));
Conic_curve_2 c2(0, 0, 1, 0, 0, -1, CGAL::COUNTERCLOCKWISE, ps2, pt2);
Rat_point_2 ps3(Rational(1,4), 4);
Rat_point_2 pmid3(Rational(3,2), 2);
Rat_point_2 pt3(2, Rational(1,3));
Conic_curve_2 c3(ps3, pmid3, pt3);
Rat_point_2 ps4(1, 5);
Rat_point_2 pmid4(Rational(3,2), 3);
Rat_point_2 pt4(3, Rational(1,3));
Conic_curve_2 c4(ps4, pmid4, pt4);
// //make x_monotone
Polycurve_conic_traits_2::X_monotone_curve_2 xmc1 =
construct_x_monotone_curve_2(c1);
Polycurve_conic_traits_2::X_monotone_curve_2 xmc2 =
construct_x_monotone_curve_2(c2);
Polycurve_conic_traits_2::X_monotone_curve_2 xmc3 =
construct_x_monotone_curve_2(c3);
Polycurve_conic_traits_2::X_monotone_curve_2 xmc4 =
construct_x_monotone_curve_2(c4);
are_equal = equal(xmc1, xmc2);
std::cout << "Two equal conic arcs are computed as: "
<< ((are_equal) ? "equal" : "Not equal") << std::endl;
are_equal = equal(xmc3, xmc2);
std::cout << "Two un-equal conic arcs are computed as: "
<< ((are_equal) ? "equal" : "Not equal") << std::endl;
are_equal = equal(xmc3, xmc4);
std::cout << "Two un-equal conic arcs are computed as: "
<< ((are_equal) ? "equal" : "Not equal") << std::endl;
}
void MapgenV7P::generateCaves(s16 max_stone_y, s16 large_cave_depth)
{
if (max_stone_y < node_min.Y)
return;
PseudoRandom ps(blockseed + 21343);
PseudoRandom ps2(blockseed + 1032);
u32 large_caves_count = (node_max.Y <= large_cave_depth) ? ps.range(0, 2) : 0;
for (u32 i = 0; i < small_caves_count + large_caves_count; i++) {
CavesV6 cave(ndef, &gennotify, water_level, c_water_source, c_lava_source);
bool large_cave = (i >= small_caves_count);
cave.makeCave(vm, node_min, node_max, &ps, &ps2,
large_cave, max_stone_y, heightmap);
}
}
void ClientConnection::RestoreArea(RECT &r)
{
int x = r.left;
int y = r.top;
int w = r.right - r.left;
int h = r.bottom - r.top;
HBITMAP m_hTempBitmap=NULL;
HDC m_hTempBitmapDC=NULL;
boost::recursive_mutex::scoped_lock l(m_bitmapdcMutex);
ObjectSelector b1(m_hBitmapDC, m_hBitmap);
PaletteSelector ps1(m_hBitmapDC, m_hPalette);
m_hTempBitmapDC = CreateCompatibleDC(m_hBitmapDC);
m_hTempBitmap = CreateCompatibleBitmap(m_hBitmapDC, w, h);
ObjectSelector b3(m_hTempBitmapDC, m_hTempBitmap);
PaletteSelector ps3(m_hTempBitmapDC, m_hPalette);
ObjectSelector b2(m_hCacheBitmapDC, m_hCacheBitmap);
PaletteSelector ps2(m_hCacheBitmapDC, m_hPalette);
if (!BitBlt(m_hTempBitmapDC, 0, 0, w, h, m_hBitmapDC, x, y, SRCCOPY))
{
//vnclog.Print(0, _T("Error saving temp bitmap\n"));
Log.WinError(_ERROR_, "Error saving temp bitmap");
}
if (!BitBlt(m_hBitmapDC, x, y, w, h, m_hCacheBitmapDC, x, y, SRCCOPY))
{
//vnclog.Print(0, _T("Error restoring screen\n"));
Log.WinError(_ERROR_, "Error restoring screen");
}
if (!BitBlt(m_hCacheBitmapDC, x, y, w, h, m_hTempBitmapDC, 0, 0, SRCCOPY))
{
//vnclog.Print(0, _T("Error restoring screen under cursor\n"));
Log.WinError(_ERROR_, "Error restoring screen under cursor");
}
DeleteDC(m_hTempBitmapDC);
if (m_hTempBitmap != NULL)
DeleteObject(m_hTempBitmap);
if (m_hCacheBitmapDC != NULL)
DeleteObject(m_hTempBitmapDC);
}
void ClientConnection::SaveArea(RECT &r)
{
if (!m_opts.m_fEnableCache) return; // sf@2002
int x = r.left;
int y = r.top;
int w = r.right - r.left;
int h = r.bottom - r.top;
omni_mutex_lock l(m_bitmapdcMutex);
ObjectSelector b1(m_hBitmapDC, m_hBitmap);
PaletteSelector ps1(m_hBitmapDC, m_hPalette);
ObjectSelector b2(m_hCacheBitmapDC, m_hCacheBitmap);
PaletteSelector ps2(m_hCacheBitmapDC, m_hPalette);
if (m_hCacheBitmapDC!=NULL) if (!BitBlt(m_hCacheBitmapDC, x, y, w, h, m_hBitmapDC, x, y, SRCCOPY)) {
vnclog.Print(0, _T("Error saving screen\n"));
}
}
void MapgenV7::generateCaves(int max_stone_y) {
PseudoRandom ps(blockseed + 21343);
PseudoRandom ps2(blockseed + 1032);
int volume_nodes = (node_max.X - node_min.X + 1) *
(node_max.Y - node_min.Y + 1) * MAP_BLOCKSIZE;
float cave_amount = NoisePerlin2D(&nparams_v6_def_cave,
node_min.X, node_min.Y, seed);
u32 caves_count = MYMAX(0.0, cave_amount) * volume_nodes / 50000;
for (u32 i = 0; i < caves_count; i++) {
CaveV6 cave(this, &ps, &ps2, false, c_water_source, c_lava_source);
cave.makeCave(node_min, node_max, max_stone_y);
}
u32 bruises_count = (ps.range(1, 6) == 1) ? ps.range(0, ps.range(0, 2)) : 1;
for (u32 i = 0; i < bruises_count; i++) {
CaveV6 cave(this, &ps, &ps2, true, c_water_source, c_lava_source);
cave.makeCave(node_min, node_max, max_stone_y);
}
}
void check_are_mergable()
{
Polycurve_conic_traits_2 traits;
Polycurve_conic_traits_2::Construct_x_monotone_curve_2
construct_x_monotone_curve_2 = traits.construct_x_monotone_curve_2_object();
Polycurve_conic_traits_2::Are_mergeable_2 are_mergeable_2 =
traits.are_mergeable_2_object();
//create a curve
Rat_point_2 ps1(1, 10);
Rat_point_2 pmid1(5, 4);
Rat_point_2 pt1(10, 1);
Conic_curve_2 c1(ps1, pmid1, pt1);
Rat_point_2 ps2(10, 1);
Rat_point_2 pmid2(15, 14);
Rat_point_2 pt2(20, 20);
Conic_curve_2 c2(ps2, pmid2, pt2);
Rat_point_2 ps3(Rational(1,4), 4);
Rat_point_2 pmid3(Rational(3,2), 2);
Rat_point_2 pt3(2, Rational(1,3));
Conic_curve_2 c3(ps3, pmid3, pt3);
//construct x-monotone curve(compatible with polyline class)
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc1 =
construct_x_monotone_curve_2(c1);
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc2 =
construct_x_monotone_curve_2(c2);
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc3 =
construct_x_monotone_curve_2(c3);
bool result = are_mergeable_2(polyline_xmc1, polyline_xmc2);
std::cout << "Are_mergable:: Mergable x-monotone polycurves are Computed as: "
<< ((result)? "Mergable" : "Not-Mergable") << std::endl;
result = are_mergeable_2(polyline_xmc1, polyline_xmc3);
std::cout << "Are_mergable:: Non-Mergable x-monotone polycurves are Computed as: "
<< ((result)? "Mergable" : "Not-Mergable") << std::endl;
}
void EGS_TrackView::setProjection(EGS_Vector pxo, EGS_Vector px_screen, EGS_Vector pv1_screen,
EGS_Vector pv2_screen, EGS_Float psx, EGS_Float psy) {
// set camera and screen variables
xo = pxo;
sx = psx;
sy = psy;
x_screen = px_screen;
v1_screen = pv1_screen;
v2_screen = pv2_screen;
v1_screen.normalize();
v2_screen.normalize();
// calculate the equation of the projection plane defined by the screen:
// a*x + b*y + c*z = 1
EGS_Vector ps1(x_screen);
EGS_Vector ps2(x_screen + v1_screen);
EGS_Vector ps3(x_screen + v2_screen);
double d = det(ps1, ps2, ps3);
EGS_Vector a1 = ps1; a1.x = 1;
EGS_Vector a2 = ps2; a2.x = 1;
EGS_Vector a3 = ps3; a3.x = 1;
double d1 = det(a1, a2, a3);
EGS_Vector b1 = ps1; b1.y = 1;
EGS_Vector b2 = ps2; b2.y = 1;
EGS_Vector b3 = ps3; b3.y = 1;
double d2 = det(b1, b2, b3);
EGS_Vector c1 = ps1; c1.z = 1;
EGS_Vector c2 = ps2; c2.z = 1;
EGS_Vector c3 = ps3; c3.z = 1;
double d3 = det(c1, c2, c3);
// avoid seg faults
if (d == 0.0000) d += 0.001;
m_scr_a = d1/d;
m_scr_b = d2/d;
m_scr_c = d3/d;
};
void MapgenV6::generateCaves(int max_stone_y) {
// 24ms @cs=8
//TimeTaker timer1("caves");
/*double cave_amount = 6.0 + 6.0 * noise2d_perlin(
0.5+(double)node_min.X/250, 0.5+(double)node_min.Y/250,
data->seed+34329, 3, 0.50);*/
const s16 max_spread_amount = MAP_BLOCKSIZE;
float cave_amount = NoisePerlin2D(np_cave, node_min.X, node_min.Y, seed);
cave_amount = MYMAX(0.0, cave_amount);
u32 caves_count = cave_amount * volume_nodes / 50000;
u32 bruises_count = 1;
PseudoRandom ps(blockseed + 21343);
PseudoRandom ps2(blockseed + 1032);
if (ps.range(1, 6) == 1)
bruises_count = ps.range(0, ps.range(0, 2));
if (getBiome(v2s16(node_min.X, node_min.Z)) == BT_DESERT) {
caves_count /= 3;
bruises_count /= 3;
}
for(u32 jj = 0; jj < caves_count + bruises_count; jj++) {
/*int avg_height = (int)
((base_rock_level_2d(data->seed, v2s16(node_min.X, node_min.Z)) +
base_rock_level_2d(data->seed, v2s16(node_max.X, node_max.Z))) / 2);
if ((node_max.Y + node_min.Y) / 2 > avg_height)
break;*/
bool large_cave = (jj >= caves_count);
Cave cave;
defineCave(cave, ps, node_min, large_cave);
v3f main_direction(0,0,0);
// Allowed route area size in nodes
v3s16 ar = central_area_size;
// Area starting point in nodes
v3s16 of = node_min;
// Allow a bit more
//(this should be more than the maximum radius of the tunnel)
s16 insure = 10;
s16 more = max_spread_amount - cave.max_tunnel_diameter / 2 - insure;
ar += v3s16(1,0,1) * more * 2;
of -= v3s16(1,0,1) * more;
s16 route_y_min = 0;
// Allow half a diameter + 7 over stone surface
s16 route_y_max = -of.Y + max_stone_y + cave.max_tunnel_diameter/2 + 7;
// Limit maximum to area
route_y_max = rangelim(route_y_max, 0, ar.Y-1);
if(large_cave)
{
s16 min = 0;
if(node_min.Y < water_level && node_max.Y > water_level)
{
min = water_level - cave.max_tunnel_diameter/3 - of.Y;
route_y_max = water_level + cave.max_tunnel_diameter/3 - of.Y;
}
route_y_min = ps.range(min, min + cave.max_tunnel_diameter);
route_y_min = rangelim(route_y_min, 0, route_y_max);
}
s16 route_start_y_min = route_y_min;
s16 route_start_y_max = route_y_max;
route_start_y_min = rangelim(route_start_y_min, 0, ar.Y-1);
route_start_y_max = rangelim(route_start_y_max, route_start_y_min, ar.Y-1);
// Randomize starting position
v3f orp(
(float)(ps.next()%ar.X)+0.5,
(float)(ps.range(route_start_y_min, route_start_y_max))+0.5,
(float)(ps.next()%ar.Z)+0.5
);
v3s16 startp(orp.X, orp.Y, orp.Z);
startp += of;
MapNode airnode(CONTENT_AIR);
MapNode waternode(c_water_source);
MapNode lavanode(c_lava_source);
/*
Generate some tunnel starting from orp
*/
for(u16 j=0; j<cave.tunnel_routepoints; j++)
{
if(j%cave.dswitchint==0 && large_cave == false)
{
main_direction = v3f(
((float)(ps.next()%20)-(float)10)/10,
((float)(ps.next()%20)-(float)10)/30,
((float)(ps.next()%20)-(float)10)/10
);
main_direction *= (float)ps.range(0, 10)/10;
}
// Randomize size
s16 min_d = cave.min_tunnel_diameter;
s16 max_d = cave.max_tunnel_diameter;
s16 rs = ps.range(min_d, max_d);
// Every second section is rough
bool randomize_xz = (ps2.range(1,2) == 1);
v3s16 maxlen;
if(large_cave)
{
maxlen = v3s16(
rs*cave.part_max_length_rs,
rs*cave.part_max_length_rs/2,
rs*cave.part_max_length_rs
);
}
else
{
maxlen = v3s16(
rs*cave.part_max_length_rs,
ps.range(1, rs*cave.part_max_length_rs),
rs*cave.part_max_length_rs
);
}
v3f vec;
vec = v3f(
(float)(ps.next()%(maxlen.X*1))-(float)maxlen.X/2,
(float)(ps.next()%(maxlen.Y*1))-(float)maxlen.Y/2,
(float)(ps.next()%(maxlen.Z*1))-(float)maxlen.Z/2
);
// Jump downward sometimes
if(!large_cave && ps.range(0,12) == 0)
{
vec = v3f(
(float)(ps.next()%(maxlen.X*1))-(float)maxlen.X/2,
(float)(ps.next()%(maxlen.Y*2))-(float)maxlen.Y*2/2,
(float)(ps.next()%(maxlen.Z*1))-(float)maxlen.Z/2
);
}
/*if(large_cave){
v3f p = orp + vec;
s16 h = find_ground_level_clever(vmanip,
v2s16(p.X, p.Z), ndef);
route_y_min = h - rs/3;
route_y_max = h + rs;
}*/
vec += main_direction;
v3f rp = orp + vec;
if(rp.X < 0)
rp.X = 0;
else if(rp.X >= ar.X)
rp.X = ar.X-1;
if(rp.Y < route_y_min)
rp.Y = route_y_min;
else if(rp.Y >= route_y_max)
rp.Y = route_y_max-1;
if(rp.Z < 0)
rp.Z = 0;
else if(rp.Z >= ar.Z)
rp.Z = ar.Z-1;
vec = rp - orp;
for(float f=0; f<1.0; f+=1.0/vec.getLength())
{
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++)
{
/*// Make better floors in small caves
if(y0 <= -rs/2 && rs<=7)
continue;*/
if (cave.large_cave_is_flat) {
// Make large caves not so tall
if (rs > 7 && abs(y0) >= rs/3)
continue;
}
s16 z = cp.Z + z0;
s16 y = cp.Y + y0;
s16 x = cp.X + x0;
v3s16 p(x,y,z);
p += of;
if(vm->m_area.contains(p) == false)
continue;
u32 i = vm->m_area.index(p);
if(large_cave) {
if (cave.flooded && full_node_min.Y < water_level &&
full_node_max.Y > water_level) {
if (p.Y <= water_level)
vm->m_data[i] = waternode;
else
vm->m_data[i] = airnode;
} else if (cave.flooded && full_node_max.Y < water_level) {
if (p.Y < startp.Y - 2)
vm->m_data[i] = lavanode;
else
vm->m_data[i] = airnode;
} else {
vm->m_data[i] = airnode;
}
} else {
// Don't replace air or water or lava or ignore
if (vm->m_data[i].getContent() == CONTENT_IGNORE ||
vm->m_data[i].getContent() == CONTENT_AIR ||
vm->m_data[i].getContent() == c_water_source ||
vm->m_data[i].getContent() == c_lava_source)
continue;
vm->m_data[i] = airnode;
// Set tunnel flag
vm->m_flags[i] |= VMANIP_FLAG_CAVE;
}
}
}
}
}
orp = rp;
}
}
}
void PyHelpersTest::RunTests()
{
// Test py::Ptr construction
{
{
// NULL pointer
PyObject * p = NULL;
SHOULDFAIL(py::Ptr(p, /* allowNULL: */false));
py::Ptr pp1(p, /* allowNULL: */true);
TEST((PyObject *)pp1 == NULL);
TEST(pp1.isNULL());
}
// Non-NULL pointer
{
PyObject * p = PyTuple_New(1);
py::Ptr pp2(p);
TEST(!pp2.isNULL());
TEST((PyObject *)pp2 == p);
pp2.release();
TEST(pp2.isNULL());
Py_DECREF(p);
}
// assign
{
PyObject * p = PyTuple_New(1);
TEST(p->ob_refcnt == 1);
py::Ptr pp(NULL, /* allowNULL */ true);
TEST(pp.isNULL());
NTA_DEBUG << "*** Before assign";
pp.assign(p);
NTA_DEBUG << "*** After assign";
TEST(p->ob_refcnt == 2);
TEST(!(pp.isNULL()));
Py_DECREF(p);
TEST(p->ob_refcnt == 1);
}
}
// py::String
{
py::String ps1(std::string("123"));
TEST(PyString_Check(ps1) != 0);
py::String ps2("123", size_t(3));
TEST(PyString_Check(ps2) != 0);
py::String ps3("123");
TEST(PyString_Check(ps3) != 0);
std::string s1(PyString_AsString(ps1));
std::string s2(PyString_AsString(ps2));
std::string s3(PyString_AsString(ps3));
std::string expected("123");
TEST(s1 == expected);
TEST(s2 == expected);
TEST(s3 == expected);
TEST(std::string(ps1) == expected);
TEST(std::string(ps2) == expected);
TEST(std::string(ps3) == expected);
PyObject * p = PyString_FromString("777");
py::String ps4(p);
TEST(std::string(ps4) == std::string("777"));
}
// py::Int
{
py::Int n1(-5);
py::Int n2(-6666);
py::Int n3(long(0));
py::Int n4(555);
py::Int n5(6666);
TEST(n1 == -5);
int x = n2;
int expected = -6666;
TEST(x == expected);
TEST(n3 == 0);
TEST(n4 == 555);
x = n5;
expected = 6666;
TEST(x == expected);
}
// py::Long
{
py::Long n1(-5);
py::Long n2(-66666666);
py::Long n3(long(0));
py::Long n4(555);
py::Long n5(66666666);
TEST(n1 == -5);
long x = n2;
long expected = -66666666;
TEST(x == expected);
TEST(n3 == 0);
TEST(n4 == 555);
x = n5;
expected = 66666666;
TEST(x == expected);
}
// py::UnsignedLong
{
py::UnsignedLong n1((unsigned long)(-5));
py::UnsignedLong n2((unsigned long)(-66666666));
py::UnsignedLong n3((unsigned long)(0));
py::UnsignedLong n4(555);
py::UnsignedLong n5(66666666);
TEST(n1 == (unsigned long)(-5));
TEST(n2 == (unsigned long)(-66666666));
TEST(n3 == 0);
TEST(n4 == 555);
TEST(n5 == 66666666);
}
// py::Float
{
TEST(py::Float::getMax() == std::numeric_limits<double>::max());
TEST(py::Float::getMin() == std::numeric_limits<double>::min());
py::Float max(std::numeric_limits<double>::max());
py::Float min(std::numeric_limits<double>::min());
py::Float n1(-0.5);
py::Float n2(double(0));
py::Float n3(333.555);
py::Float n4(0.02);
py::Float n5("0.02");
TEST(max == py::Float::getMax());
TEST(min == py::Float::getMin());
TEST(n1 == -0.5);
TEST(n2 == 0);
TEST(n3 == 333.555);
TEST(n4 == 0.02);
TEST(n5 == 0.02);
}
// py::Tuple
{
py::String s1("item_1");
py::String s2("item_2");
// Empty tuple
{
py::Tuple empty;
TEST(PyTuple_Check(empty) != 0);
TEST(empty.getCount() == 0);
SHOULDFAIL(empty.setItem(0, s1));
SHOULDFAIL(empty.getItem(0));
}
// One item tuple
{
py::Tuple t1(1);
TEST(PyTuple_Check(t1) != 0);
TEST(t1.getCount() == 1);
t1.setItem(0, s1);
py::String item1(t1.getItem(0));
TEST(std::string(item1) == std::string(s1));
py::String fastItem1(t1.fastGetItem(0));
TEST(std::string(fastItem1) == std::string(s1));
fastItem1.release();
SHOULDFAIL(t1.setItem(1, s2));
SHOULDFAIL(t1.getItem(1));
TEST(t1.getCount() == 1);
}
// 2 items tuple
{
py::Tuple t2(2);
TEST(PyTuple_Check(t2) != 0);
TEST(t2.getCount() == 2);
t2.setItem(0, s1);
py::String item1(t2.getItem(0));
TEST(std::string(item1) == std::string(s1));
py::String fastItem1(t2.fastGetItem(0));
TEST(std::string(fastItem1) == std::string(s1));
fastItem1.release();
t2.setItem(1, s2);
py::String item2(t2.getItem(1));
TEST(std::string(item2) == std::string(s2));
py::String fastItem2(t2.fastGetItem(1));
TEST(std::string(fastItem2) == std::string(s2));
fastItem2.release();
SHOULDFAIL(t2.setItem(2, s2));
SHOULDFAIL(t2.getItem(2));
TEST(t2.getCount() == 2);
}
}
// py::List
{
py::String s1("item_1");
py::String s2("item_2");
// Empty list
{
py::List empty;
TEST(PyList_Check(empty) != 0);
TEST(empty.getCount() == 0);
SHOULDFAIL(empty.setItem(0, s1));
SHOULDFAIL(empty.getItem(0));
}
// One item list
{
py::List t1;
TEST(PyList_Check(t1) != 0);
TEST(t1.getCount() == 0);
t1.append(s1);
py::String item1(t1.getItem(0));
TEST(std::string(item1) == std::string(s1));
py::String fastItem1(t1.fastGetItem(0));
TEST(std::string(fastItem1) == std::string(s1));
fastItem1.release();
TEST(t1.getCount() == 1);
TEST(std::string(item1) == std::string(s1));
SHOULDFAIL(t1.getItem(1));
}
// Two items list
{
py::List t2;
TEST(PyList_Check(t2) != 0);
TEST(t2.getCount() == 0);
t2.append(s1);
py::String item1(t2.getItem(0));
TEST(std::string(item1) == std::string(s1));
py::String fastItem1(t2.fastGetItem(0));
TEST(std::string(fastItem1) == std::string(s1));
fastItem1.release();
t2.append(s2);
TEST(t2.getCount() == 2);
py::String item2(t2.getItem(1));
TEST(std::string(item2) == std::string(s2));
py::String fastItem2(t2.fastGetItem(1));
TEST(std::string(fastItem2) == std::string(s2));
fastItem2.release();
SHOULDFAIL(t2.getItem(2));
}
}
// py::Dict
{
// Empty dict
{
py::Dict d;
TEST(PyDict_Size(d) == 0);
TEST(d.getItem("blah") == NULL);
}
// Failed External PyObject *
{
// NULL object
SHOULDFAIL(py::Dict(NULL));
// Wrong type (must be a dictionary)
py::String s("1234");
try
{
py::Dict d(s.release());
NTA_THROW << "py::Dict d(s) Should fail!!!";
}
catch(...)
{
}
// SHOULDFAIL fails to fail :-)
//SHOULDFAIL(py::Dict(s));
}
// Successful external PyObject *
{
PyObject * p = PyDict_New();
PyDict_SetItem(p, py::String("1234"), py::String("5678"));
py::Dict d(p);
TEST(PyDict_Contains(d, py::String("1234")) == 1);
PyDict_SetItem(d, py::String("777"), py::String("999"));
TEST(PyDict_Contains(d, py::String("777")) == 1);
}
// getItem with default (exisiting and non-exisitng key)
{
py::Dict d;
d.setItem("A", py::String("AAA"));
PyObject * defaultItem = (PyObject *)123;
py::String A(d.getItem("A"));
TEST(std::string(A) == std::string("AAA"));
// No "B" in the dict, so expect to get the default item
PyObject * B = (d.getItem("B", defaultItem));
TEST(B == defaultItem);
PyDict_SetItem(d, py::String("777"), py::String("999"));
TEST(PyDict_Contains(d, py::String("777")) == 1);
}
//NTA_DEBUG << ss << ": " << ss->ob_refcnt;
}
// py::Module
{
py::Module module("sys");
TEST(std::string(PyModule_GetName(module)) == std::string("sys"));
}
// py::Class
{
py::Class c("datetime", "date");
}
// py::Instance
{
py::Tuple args(3);
args.setItem(0, py::Long(2000));
args.setItem(1, py::Long(11));
args.setItem(2, py::Long(5));
py::Instance date("datetime", "date", args, py::Dict());
// Test invoke()
{
py::String result(date.invoke("__str__", py::Tuple(), py::Dict()));
std::string res((const char *)result);
std::string expected("2000-11-05");
TEST(res == expected);
}
// Test hasAttr()
{
py::String result(date.invoke("__str__", py::Tuple(), py::Dict()));
std::string res((const char *)result);
std::string expected("2000-11-05");
TEST(!(date.hasAttr("No such attribute")));
TEST(date.hasAttr("year"));
}
// Test getAttr()
{
py::Int year(date.getAttr("year"));
TEST(2000 == long(year));
}
// Test toString()
{
std::string res((const char *)py::String(date.toString()));
std::string expected("2000-11-05");
TEST(res == expected);
}
}
// Test custom exception
{
py::Tuple args(1);
args.setItem(0, py::String("error message!"));
py::Instance e(PyExc_RuntimeError, args);
e.setAttr("traceback", py::String("traceback!!!"));
PyErr_SetObject(PyExc_RuntimeError, e);
try
{
py::checkPyError(0);
}
catch (const nta::Exception & e)
{
NTA_DEBUG << e.getMessage();
}
}
}
bool check_compare_y_at_x_2()
{
Polycurve_conic_traits_2 traits;
Polycurve_conic_traits_2::Compare_y_at_x_2 cmp_y_at_x_2 =
traits.compare_y_at_x_2_object();
//polycurve constructors
Polycurve_conic_traits_2::Construct_x_monotone_curve_2
construct_x_mono_polycurve = traits.construct_x_monotone_curve_2_object();
Polycurve_conic_traits_2::Construct_curve_2 construct_polycurve =
traits.construct_curve_2_object();
//create a curve
Rat_point_2 ps1(1, 10);
Rat_point_2 pmid1(5, 4);
Rat_point_2 pt1(10, 1);
Conic_curve_2 c1(ps1, pmid1, pt1);
//create a curve
Rat_point_2 ps2(10, 1);
Rat_point_2 pmid2(15, 5);
Rat_point_2 pt2(20, 10);
Conic_curve_2 c2(ps2, pmid2, pt2);
Conic_curve_2 c3(1,0,0,0,-1,0,CGAL::COUNTERCLOCKWISE,
Conic_point_2(Algebraic(0), Algebraic(0)),
Conic_point_2(Algebraic(3), Algebraic(9)));
Conic_curve_2 c4(1,0,0,0,-1,0,CGAL::COUNTERCLOCKWISE,
Conic_point_2(Algebraic(3), Algebraic(9)),
Conic_point_2(Algebraic(5), Algebraic(25)));
std::vector<Conic_curve_2> conic_curves, conic_curves_2, Conic_curves_3;
conic_curves.push_back(c1);
conic_curves.push_back(c2);
//conic_curves_2.push_back(c3);
//conic_curves_2.push_back(c4);
Conic_x_monotone_curve_2 xc1(c1);
Conic_x_monotone_curve_2 xc2(c2);
Conic_x_monotone_curve_2 xc3(c3);
Conic_x_monotone_curve_2 xc4(c4);
std::vector<Conic_x_monotone_curve_2> xmono_conic_curves, xmono_conic_curves_2;
/* VERY IMPORTANT
* For efficiency reasons, we recommend users not to construct x-monotone
* conic arc directly, but rather use the Make_x_monotone_2 functor supplied
* by the conic-arc traits class to convert conic curves to x-monotone curves.
*/
xmono_conic_curves.push_back(xc1);
xmono_conic_curves.push_back(xc2);
xmono_conic_curves_2.push_back(xc3);
xmono_conic_curves_2.push_back(xc4);
//construct x-monotone poly-curve
Polycurve_conic_traits_2::X_monotone_curve_2 conic_x_mono_polycurve =
construct_x_mono_polycurve(xmono_conic_curves.begin(),
xmono_conic_curves.end());
Polycurve_conic_traits_2::X_monotone_curve_2 conic_x_mono_polycurve_2 =
construct_x_mono_polycurve(xmono_conic_curves_2.begin(),
xmono_conic_curves_2.end());
//construct poly-curve
Polycurve_conic_traits_2::Curve_2 conic_polycurve =
construct_polycurve(conic_curves.begin(), conic_curves.end());
//Polycurve_conic_traits_2::Curve_2 conic_polycurve_2 =
// construct_polycurve(conic_curves_2.begin(), conic_curves_2.end());
//make x-monotone curve
//Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc1 =
// construct_x_monotone_curve_2(c1);
//create points
Polycurve_conic_traits_2::Point_2
point_above_line = Polycurve_conic_traits_2::Point_2(2,10),
point_below_line = Polycurve_conic_traits_2::Point_2(4,7),
point_on_line = Polycurve_conic_traits_2::Point_2(2,4);
CGAL::Comparison_result result;
result = cmp_y_at_x_2(point_above_line, conic_x_mono_polycurve_2);
std::cout << "Compare_y_at_x_2:: for point above the curve computed Answer is: "
<< (result == CGAL::SMALLER ? "Below":
(result == CGAL::LARGER ? "Above" : "On-line")) << std::endl;
result = cmp_y_at_x_2(point_below_line, conic_x_mono_polycurve_2);
std::cout << "Compare_y_at_x_2:: for point below the curve computed Answer is: "
<< (result == CGAL::SMALLER ? "Below":
(result == CGAL::LARGER ? "Above" : "On-line")) << std::endl;
result = cmp_y_at_x_2(point_on_line, conic_x_mono_polycurve_2);
std::cout << "Compare_y_at_x_2:: for point on the curve computed Answer is: "
<< (result == CGAL::SMALLER ? "Below":
(result == CGAL::LARGER ? "Above" : "On-line")) << std::endl;
return true;
}
TriggerSettingsRocketOrb* SceneVectorizer :: getRocketTronFountain(float hueStartOffset, float hueChange, float speedMultiplier, bool useLaser) {
ParticleRendererBase* particleLineRenderer;
particleLineRenderer = new ParticleRendererGlitchLine(1.2);
ParticleSystemSettings ps, ps2;
//particleLineRenderer->lineWidth = 2;
//whiteImage.loadImage("img/ParticleWhite.png");
// ParticleData
// size range
// size modifier
// velocity range
// life range
// drag
// gravity
// colour
// colour modifier
// renderer
// EmmisionData
// Frequency
// Burst/continuous
// range of start sizes for particles
// range of colours for particles
// optional colour modifier
// PHYSICS
ps.speedMin = 0;
ps.speedMax = 30;
ps.directionZ = -90;
ps.directionZVar = 90;
//ps.directionZVar = 0;
ps.directionYVar = 0;
ps.drag = 0.90;
ps.gravity.set(0,0);
//LIFE
ps.lifeMin = 0.5;
ps.lifeMax = 0.7;
//APPEARANCE
ps.sizeStartMin = 4;
ps.sizeStartMax = 6;
ps.sizeChangeRatio = 1;
ps.hueStartMin = -5+hueStartOffset;
ps.hueStartMax = 0+hueStartOffset;
ps.hueChange = hueChange;
ps.brightnessStartMin = 230;
ps.brightnessStartMax = 255;
ps.brightnessEnd = 0;
ps.saturationMin = 150;
ps.saturationMax = 255;
ps.saturationEnd = 255;
ps.emitMode = PARTICLE_EMIT_CONTINUOUS;
if(useLaser) ps.emitCount = 20;
else ps.emitCount = 40;
ps.emitDelay = 0;
ps.emitLifeTime= 1.4;
ps.emitStartSizeModifier = 0;
ps.emitSpeedModifier = 10;
ps.emitHueModifierOffset = 0;
ps.emitInheritVelocity = 0;
ps.startSound = "DirtyTechno";
ps.renderer = particleLineRenderer;
RocketSettings* rs = new RocketSettings();
rs->startSpeedMin = 800 * speedMultiplier;
rs->startSpeedMax = 950 * speedMultiplier;
rs->direction = -90;
rs->directionVar = 0;
rs->gravity.y = 0;
rs->setLifeTime(1.4);
rs->drag = 0.9;
//ps.timeSpeed = rs->timeSpeed = 0.8;
RocketSettings* rs2 = NULL;
if(useLaser) {
rs2 = new RocketSettings(*rs);
ParticleRendererBase* particleLineRendererLaser = new ParticleRendererGlitchLineLaser();
ParticleSystemSettings ps2(ps);
ps2.renderer = particleLineRendererLaser;
rs2->addParticleSystemSetting(ps2);
}
rs->addParticleSystemSetting(ps);
TriggerSettingsRocketOrb* ts = new TriggerSettingsRocketOrb();
ts->addRocketSettings(rs);
if(rs2!=NULL) {
ts->addRocketSettings(rs2);
vector<float>probs;
probs.push_back(9);
probs.push_back(1);
ts->setProbabilities(probs);
}
ts->rotateOnFire = true;
ts->rotationExtent = 20;
ts->rotationSpeed = 4;
ts->radius = 6;
ts->rechargeSettings = TriggerRechargeSettings::superFastMultiples;
ts->hue = hueStartOffset;
ts->saturation = 200;
return ts;
};
