void fill_maze(int x, int y, int lenght = 0)
{
cell& cur = maze[x][y];
cur.visited = true;
if(lenght > endlen)
{
endx = x;
endy = y;
endlen = lenght;
}
for(int i = 0; i < 30; i++) // all directions in random order
{
direction dir = random_dir();
int cx = x, cy = y; // neightbor
if(!offset(dir, cx, cy))
continue;
cell& n = maze[cx][cy];
if(n.visited)
continue;
// make path
cur.break_wall(dir);
n.break_wall(opposite(dir));
// recursion
fill_maze(cx, cy, lenght + 1);
}
}
Vec3 DiffuseMaterial::out_direction(Vec3 const &in, Vec3 const &norm, double &brdf, RGB &color, CRandomMersenne *rng)
{
// Generamos una nueva direccion. Sera una direccion aleatoria en la
// semiesfera definida por la normal.
brdf = 1.0f;
color = radiance() * brdf;
return versor(random_dir(norm, rng->Random(), rng->Random()));
}
/*
* place_worm_tail_randomly()
*
* Place a worm tail somewhere on a level behind the head.
* This routine essentially reverses the order of the wsegs from head
* to tail while placing them.
* x, and y are most likely the worm->mx, and worm->my, but don't *need* to
* be, if somehow the head is disjoint from the tail.
*/
void
place_worm_tail_randomly(struct monst *worm, xchar x, xchar y, enum rng rng)
{
int wnum = worm->wormno;
struct level *lev = worm->dlevel;
struct wseg *curr = lev->wtails[wnum];
struct wseg *new_tail;
xchar ox = x, oy = y;
/* if (!wnum) return; bullet proofing */
if (wnum && (!lev->wtails[wnum] || !lev->wheads[wnum])) {
impossible("place_worm_tail_randomly: wormno is set without a tail!");
return;
}
lev->wheads[wnum] = new_tail = curr;
curr = curr->nseg;
new_tail->nseg = NULL;
new_tail->wx = x;
new_tail->wy = y;
while (curr) {
xchar nx, ny;
char tryct = 0;
/* pick a random direction from x, y and search for goodpos() */
do {
random_dir(ox, oy, &nx, &ny, rng);
} while (!goodpos(lev, nx, ny, worm, 0) && (tryct++ < 50));
if (tryct < 50) {
place_worm_seg(worm, nx, ny);
curr->wx = ox = nx;
curr->wy = oy = ny;
lev->wtails[wnum] = curr;
curr = curr->nseg;
lev->wtails[wnum]->nseg = new_tail;
new_tail = lev->wtails[wnum];
if (lev == level)
newsym(nx, ny);
} else { /* Oops. Truncate because there was */
toss_wsegs(lev, curr, FALSE); /* no place for the rest of it */
curr = NULL;
}
}
}
void CShootingObject::FireBullet(const Fvector& pos,
const Fvector& shot_dir,
float fire_disp,
const CCartridge& cartridge,
u16 parent_id,
u16 weapon_id,
bool send_hit)
{
Fvector dir;
random_dir(dir,shot_dir,fire_disp);
m_vCurrentShootDir = dir;
m_vCurrentShootPos = pos;
m_iCurrentParentID = parent_id;
bool aim_bullet;
if (m_bUseAimBullet)
{
if (ParentMayHaveAimBullet())
{
if (m_fPredBulletTime==0.0)
{
aim_bullet=true;
}
else
{
if ((Device.fTimeGlobal-m_fPredBulletTime)>=m_fTimeToAim)
{
aim_bullet=true;
}
else
{
aim_bullet=false;
}
}
}
else
{
aim_bullet=false;
}
}
else
{
aim_bullet=false;
}
m_fPredBulletTime = Device.fTimeGlobal;
float l_fHitPower = 0.0f;
float l_fHitPowerCritical = 0.0f;
if (ParentIsActor())//если из оружия стреляет актёр(игрок)
{
if (GameID() == eGameIDSingle)
{
l_fHitPower = fvHitPower[g_SingleGameDifficulty];
l_fHitPowerCritical = fvHitPowerCritical[g_SingleGameDifficulty];
}
else
{
l_fHitPower = fvHitPower[egdMaster];
l_fHitPowerCritical = fvHitPowerCritical[egdMaster];
}
}
else
{
l_fHitPower = fvHitPower[egdMaster];
l_fHitPowerCritical = fvHitPowerCritical[egdMaster];
}
Level().BulletManager().AddBullet( pos, dir,
m_fStartBulletSpeed * cur_silencer_koef.bullet_speed,
l_fHitPower * cur_silencer_koef.hit_power,
l_fHitPowerCritical,
fHitImpulse * cur_silencer_koef.hit_impulse,
parent_id, weapon_id,
ALife::eHitTypeFireWound, fireDistance, cartridge, send_hit, aim_bullet);
}
void test_planner(int rank)
{
/*
* create and destroy many plans, at random. Check the
* garbage-collecting allocator of twiddle factors
*/
int i, dim;
int r, s;
fftw_mpi_plan p[PLANNER_TEST_SIZE];
fftwnd_mpi_plan pnd[PLANNER_TEST_SIZE];
int *narr, maxdim;
chk_mem_leak = 0;
verbose--;
please_wait();
if (rank < 1)
rank = 1;
narr = (int *) fftw_malloc(rank * sizeof(int));
for (i = 0; i < PLANNER_TEST_SIZE; ++i) {
p[i] = (fftw_mpi_plan) 0;
pnd[i] = (fftwnd_mpi_plan) 0;
}
if (PLANNER_TEST_SIZE >= 8) {
p[0] = fftw_mpi_create_plan(MPI_COMM_WORLD, 1024, FFTW_FORWARD, 0);
p[1] = fftw_mpi_create_plan(MPI_COMM_WORLD, 1024, FFTW_FORWARD, 0);
p[2] = fftw_mpi_create_plan(MPI_COMM_WORLD, 1024, FFTW_BACKWARD, 0);
p[3] = fftw_mpi_create_plan(MPI_COMM_WORLD, 1024, FFTW_BACKWARD, 0);
p[4] = fftw_mpi_create_plan(MPI_COMM_WORLD, 1024, FFTW_FORWARD, 0);
p[5] = fftw_mpi_create_plan(MPI_COMM_WORLD, 1024, FFTW_FORWARD, 0);
p[6] = fftw_mpi_create_plan(MPI_COMM_WORLD, 1024, FFTW_BACKWARD, 0);
p[7] = fftw_mpi_create_plan(MPI_COMM_WORLD, 1024, FFTW_BACKWARD, 0);
}
maxdim = (int) pow(8192, 1.0/rank);
for (i = 0; i < PLANNER_TEST_SIZE * PLANNER_TEST_SIZE; ++i) {
r = rand();
if (r < 0)
r = -r;
r = r % PLANNER_TEST_SIZE;
for (dim = 0; dim < rank; ++dim) {
do {
s = rand();
if (s < 0)
s = -s;
s = s % maxdim + 1;
} while (s == 0);
narr[dim] = s;
}
if (rank == 1) {
if (p[r])
fftw_mpi_destroy_plan(p[r]);
p[r] = fftw_mpi_create_plan(MPI_COMM_WORLD,
narr[0], random_dir(),
measure_flag | wisdom_flag);
}
if (rank > 1) {
if (pnd[r])
fftwnd_mpi_destroy_plan(pnd[r]);
pnd[r] = fftwnd_mpi_create_plan(MPI_COMM_WORLD, rank, narr,
random_dir(), measure_flag |
wisdom_flag);
}
if (i % (PLANNER_TEST_SIZE * PLANNER_TEST_SIZE / 20) == 0) {
WHEN_VERBOSE(0, my_printf("test planner: so far so good\n"));
WHEN_VERBOSE(0, my_printf("test planner: iteration %d"
" out of %d\n",
i, PLANNER_TEST_SIZE * PLANNER_TEST_SIZE));
}
}
for (i = 0; i < PLANNER_TEST_SIZE; ++i) {
if (p[i])
fftw_mpi_destroy_plan(p[i]);
if (pnd[i])
fftwnd_mpi_destroy_plan(pnd[i]);
}
fftw_free(narr);
verbose++;
chk_mem_leak = 1;
}
void test_planner(int rank)
{
/*
* create and destroy many plans, at random. Check the
* garbage-collecting allocator of twiddle factors
*/
int i, dim;
int r, s;
fftw_plan p[PLANNER_TEST_SIZE];
fftwnd_plan pnd[PLANNER_TEST_SIZE];
int *narr, maxdim;
chk_mem_leak = 0;
verbose--;
please_wait();
if (rank < 1)
rank = 1;
narr = (int *) fftw_malloc(rank * sizeof(int));
maxdim = (int) pow(8192.0, 1.0/rank);
for (i = 0; i < PLANNER_TEST_SIZE; ++i) {
p[i] = (fftw_plan) 0;
pnd[i] = (fftwnd_plan) 0;
}
for (i = 0; i < PLANNER_TEST_SIZE * PLANNER_TEST_SIZE; ++i) {
r = rand();
if (r < 0)
r = -r;
r = r % PLANNER_TEST_SIZE;
for (dim = 0; dim < rank; ++dim) {
do {
s = rand();
if (s < 0)
s = -s;
s = s % maxdim + 1;
} while (s == 0);
narr[dim] = s;
}
if (rank == 1) {
if (p[r])
fftw_destroy_plan(p[r]);
p[r] = fftw_create_plan(narr[0], random_dir(), measure_flag |
wisdom_flag);
if (paranoid && narr[0] < 200)
test_correctness(narr[0]);
}
if (pnd[r])
fftwnd_destroy_plan(pnd[r]);
pnd[r] = fftwnd_create_plan(rank, narr,
random_dir(), measure_flag |
wisdom_flag);
if (i % (PLANNER_TEST_SIZE * PLANNER_TEST_SIZE / 20) == 0) {
WHEN_VERBOSE(0, printf("test planner: so far so good\n"));
WHEN_VERBOSE(0, printf("test planner: iteration %d out of %d\n",
i, PLANNER_TEST_SIZE * PLANNER_TEST_SIZE));
}
}
for (i = 0; i < PLANNER_TEST_SIZE; ++i) {
if (p[i])
fftw_destroy_plan(p[i]);
if (pnd[i])
fftwnd_destroy_plan(pnd[i]);
}
fftw_free(narr);
verbose++;
chk_mem_leak = 1;
}
void CShootingObject::FireBullet(const Fvector& pos,
const Fvector& shot_dir,
float fire_disp,
const CCartridge& cartridge,
u16 parent_id,
u16 weapon_id,
bool send_hit)
{
Fvector dir;
random_dir(dir,shot_dir,fire_disp);
if (constDeviation.pitch != 0 || constDeviation.yaw != 0) // WARN: при больших значениях девиации стрелок может отсрелить себе голову!
{
float dir_yaw, dir_pitch;
dir.getHP(dir_yaw, dir_pitch);
dir_pitch += constDeviation.pitch;
dir_yaw += constDeviation.yaw;
dir.setHP(dir_yaw, dir_pitch);
}
m_vCurrentShootDir = dir;
m_vCurrentShootPos = pos;
m_iCurrentParentID = parent_id;
bool aim_bullet;
if (m_bUseAimBullet)
{
if (ParentMayHaveAimBullet())
{
if (m_fPredBulletTime==0.0)
{
aim_bullet=true;
}
else
{
if ((Device.fTimeGlobal-m_fPredBulletTime)>=m_fTimeToAim)
{
aim_bullet=true;
}
else
{
aim_bullet=false;
}
}
}
else
{
aim_bullet=false;
}
}
else
{
aim_bullet=false;
}
m_fPredBulletTime = Device.fTimeGlobal;
float l_fHitPower;
if (ParentIsActor())//если из оружия стреляет актёр(игрок)
{
if (GameID() == GAME_SINGLE)
{
l_fHitPower=fvHitPower[g_SingleGameDifficulty];
}
else
{
l_fHitPower=fvHitPower[egdMaster];
}
}
else
{
l_fHitPower=fvHitPower[egdMaster];
}
Level().BulletManager().AddBullet( pos, dir, m_fStartBulletSpeed, l_fHitPower,
fHitImpulse, parent_id, weapon_id,
m_eHitType, fireDistance, cartridge, send_hit, aim_bullet);
}
