void dungeon2_wild_pokemon_sample_level_boundaries(u8 *level_min, u8 *level_max, u8 mean,
u8 std_deviation, dungeon_generator2 *dg2) {
FIXED fx1 = FIXED_ADD(INT_TO_FIXED(mean), FIXED_MUL(INT_TO_FIXED(std_deviation),
dungeon2_rnd_normal(dg2)));
FIXED fx2 = FIXED_ADD(INT_TO_FIXED(mean), FIXED_MUL(INT_TO_FIXED(std_deviation),
dungeon2_rnd_normal(dg2)));
int x1 = min(100, max(2, FIXED_TO_INT(fx1)));
int x2 = min(100, max(2, FIXED_TO_INT(fx2)));
*level_min = (u8)min(x1, x2);
*level_max = (u8)max(x1, x2);
}
void
_cairo_trapezoid_array_translate_and_scale (cairo_trapezoid_t *offset_traps,
cairo_trapezoid_t *src_traps,
int num_traps,
double tx, double ty,
double sx, double sy)
{
int i;
cairo_fixed_t xoff = _cairo_fixed_from_double (tx);
cairo_fixed_t yoff = _cairo_fixed_from_double (ty);
if (sx == 1.0 && sy == 1.0) {
for (i = 0; i < num_traps; i++) {
offset_traps[i].top = src_traps[i].top + yoff;
offset_traps[i].bottom = src_traps[i].bottom + yoff;
offset_traps[i].left.p1.x = src_traps[i].left.p1.x + xoff;
offset_traps[i].left.p1.y = src_traps[i].left.p1.y + yoff;
offset_traps[i].left.p2.x = src_traps[i].left.p2.x + xoff;
offset_traps[i].left.p2.y = src_traps[i].left.p2.y + yoff;
offset_traps[i].right.p1.x = src_traps[i].right.p1.x + xoff;
offset_traps[i].right.p1.y = src_traps[i].right.p1.y + yoff;
offset_traps[i].right.p2.x = src_traps[i].right.p2.x + xoff;
offset_traps[i].right.p2.y = src_traps[i].right.p2.y + yoff;
}
} else {
cairo_fixed_t xsc = _cairo_fixed_from_double (sx);
cairo_fixed_t ysc = _cairo_fixed_from_double (sy);
for (i = 0; i < num_traps; i++) {
#define FIXED_MUL(_a, _b) \
(_cairo_int64_to_int32(_cairo_int64_rsl(_cairo_int32x32_64_mul((_a), (_b)), 16)))
offset_traps[i].top = FIXED_MUL(src_traps[i].top + yoff, ysc);
offset_traps[i].bottom = FIXED_MUL(src_traps[i].bottom + yoff, ysc);
offset_traps[i].left.p1.x = FIXED_MUL(src_traps[i].left.p1.x + xoff, xsc);
offset_traps[i].left.p1.y = FIXED_MUL(src_traps[i].left.p1.y + yoff, ysc);
offset_traps[i].left.p2.x = FIXED_MUL(src_traps[i].left.p2.x + xoff, xsc);
offset_traps[i].left.p2.y = FIXED_MUL(src_traps[i].left.p2.y + yoff, ysc);
offset_traps[i].right.p1.x = FIXED_MUL(src_traps[i].right.p1.x + xoff, xsc);
offset_traps[i].right.p1.y = FIXED_MUL(src_traps[i].right.p1.y + yoff, ysc);
offset_traps[i].right.p2.x = FIXED_MUL(src_traps[i].right.p2.x + xoff, xsc);
offset_traps[i].right.p2.y = FIXED_MUL(src_traps[i].right.p2.y + yoff, ysc);
#undef FIXED_MUL
}
}
}
FIXED FIXED_HORNER_SCHEME(FIXED x, FIXED *coefs, int num_coefs) {
FIXED result = 0;
for(int i = 0; i < num_coefs; i++) {
result = FIXED_MUL(result, x);
result = FIXED_ADD(result, coefs[num_coefs - i - 1]);
}
return result;
}
void anim_staraptor_oam_callback(oam_object *self){
FIXED period = INT_TO_FIXED(32);
FIXED amplitude = INT_TO_FIXED(3);
FIXED x = INT_TO_FIXED((self->private[0])++);
x = FIXED_DIV(x, period);
FIXED y = FIXED_COS(x);
y = FIXED_MUL(y, amplitude);
int y2 = FIXED_TO_INT(y);
self->y2 = (s16)y2;
}
void dungeon2_set_encounter_cave() {
dungeon_generator2 *dg2 = &(cmem.dg2);
dungeon2_cave_init_state(dg2);
pokemon_clear_opponent_party();
u16 species = *var_access(DUNGEON_OVERWORLD_SPECIES);
u8 mean = 0, std_deviation = 0;
dungeon2_cave_wild_pokemon_level_distribution(&mean, &std_deviation);
mean = (u8)(mean + std_deviation + std_deviation / 2); // High level for this pokemon
int level = FIXED_TO_INT(FIXED_ADD(INT_TO_FIXED(mean), FIXED_MUL(INT_TO_FIXED(std_deviation),
dungeon2_rnd_normal(dg2))));
level = max(min(level, 100), 2);
pid_t p = {dungeon2_rnd(dg2)};
pokemon_spawn_by_seed_algorithm(&opponent_pokemon[0], species, (u8)level, 32, true, p, false, 0,
dungeon2_encounter_rnd_generator, dungeon2_encounter_rnd_generator);
}
int main(int argc, char **argv)
{
struct tap tapfile;
struct wav wavfile;
FILE *infile;
long pulse;
long i;
fixedpoint len, accum;
long channels[2];
int wave[2];
int sample;
getopts(argc, argv);
if (invert) {
wave[0] = LOW;
wave[1] = HIGH;
} else {
wave[0] = HIGH;
wave[1] = LOW;
}
if (optind == argc) {
infile = stdin;
} else if (optind == argc - 1) {
if (!strcmp(argv[optind], "-")) {
infile = stdin;
} else {
infile = fopen(argv[optind], "rb");
if (!infile) {
perror(argv[optind]);
return 1;
}
}
} else {
fprintf(stderr, "%s: too many arguments\n", argv0);
usage();
return 1;
}
if (tap_read_header(&tapfile, infile)) {
fprintf(stderr, "%s: error reading TAP file\n", argv0);
return 1;
}
wavfile.SampleRate = samplerate;
wavfile.BitsPerSample = 8;
wavfile.NumChannels = 1;
if (wav_write_header(&wavfile, stdout)) {
fprintf(stderr, "%s: error writing WAV file\n", argv0);
return 1;
}
filter_init(&lowpass_filter, lowpass_freq, wavfile.SampleRate);
#if 0
/* put one initial sample so the first pulse is recognized */
channels[0] = wave[1];
wav_put_sample(&wavfile, channels);
accum = TO_FIXED(1.5);
#else
accum = TO_FIXED(2);
#endif
while ((pulse = tap_get_pulse(&tapfile)) >= 0) {
//fprintf(stderr, "pulse: %6ld (%04lx)\n", pulse, pulse);
//if (pulse < 8*256)
//++pulsehist[pulse/8];
len = TO_FIXED(((double)pulse * samplerate / PAL_MHZ / speed / 1000000));
if (len < TO_FIXED(2)) {
fprintf(stderr, "%s: warning: pulse length (%ld) is less than 2 samples\n", argv0, pulse);
}
#if 0
accum = FIXED_F(len + accum);
#else
len += accum;
accum = FIXED_F(len);
#endif
#if 0
fprintf(stderr, "%ld.%03ld 0.%03ld \n",
FIXED_I(len),
FIXED_F(len) * 1000 / FIXED_ONE,
FIXED_F(accum) * 1000 / FIXED_ONE);
#endif
for (i = 0; i < FIXED_I(len) / 2 - 1; ++i) {
channels[0] = filter_lowpass(&lowpass_filter, wave[0]) << 16;
wav_put_sample(&wavfile, channels);
}
for (; i < FIXED_I(len) - 2; ++i) {
channels[0] = filter_lowpass(&lowpass_filter, wave[1]) << 16;
wav_put_sample(&wavfile, channels);
}
#if 0
channels[0] = FIXED_MUL(wave[1], accum) +
FIXED_MUL(wave[0], FIXED_ONE - accum);
wav_put_sample(&wavfile, channels);
#else
sample = FIXED_MUL(wave[1], accum);
channels[0] = filter_lowpass(&lowpass_filter, sample) << 16;
wav_put_sample(&wavfile, channels);
sample -= wave[1];
channels[0] = filter_lowpass(&lowpass_filter, sample) << 16;
wav_put_sample(&wavfile, channels);
#endif
}
wav_close(&wavfile);
return 0;
}
void engine_move_actors (Context* context) {
static int ticks = ANIM_LEN;
Player* player = context->engine->player;
if (player->v_buf->v == NULL) {
return;
}
if (
player->target_x < 0
|| (
player->target_x == *player->x
&& player->target_y == *player->y
)
) {
player->anim = 0;
player->v_buf->v->bitmap = player->anims[0];
return;
}
Fixed vector_x = player->vector_x;
Fixed vector_y = player->vector_y;
if (player->recalculate) {
vector_x = FIXED_FROM_INT(player->target_x) - player->real_x;
vector_y = FIXED_FROM_INT(player->target_y) - player->real_y;
Fixed dist = FIXED_FROM_FLOAT(
Q_rsqrt(
FIXED_TO_FLOAT(
FIXED_MUL(vector_x, vector_x)
+ FIXED_MUL(vector_y, vector_y)
)
)
);
vector_x = FIXED_MUL(vector_x, dist);
vector_y = FIXED_MUL(vector_y, dist);
player->vector_x = vector_x;
player->vector_y = vector_y;
player->recalculate = 0;
}
player->real_x += FIXED_MUL(vector_x, FIXED_FROM_INT(PLAYER_SPEED));
player->real_y += FIXED_MUL(vector_y, FIXED_FROM_INT(PLAYER_SPEED));
if (ticks >= ANIM_LEN) {
ticks = 0;
player->anim++;
if (vector_x > 0 && player->anim > 2) {
player->anim = 2;
} else if (vector_x < 0 && player->anim > 4) {
player->anim = 4;
} else if (vector_x < 0 && player->anim < 3) {
player->anim = 3;
}
player->v_buf->v->bitmap = player->anims[player->anim];
}
if (
(vector_x > 0 && FIXED_TO_FLOAT(player->real_x) >= player->target_x)
|| (vector_x <= 0 && FIXED_TO_FLOAT(player->real_x) < player->target_x)
) {
player->real_x = FIXED_FROM_INT(player->target_x);
player->v_buf->v->bitmap = player->anims[0];
player->anim = 0;
}
if (
(vector_y > 0 && FIXED_TO_FLOAT(player->real_y) > player->target_y)
|| (vector_y < 0 && FIXED_TO_FLOAT(player->real_y) < player->target_y)
) {
player->real_y = FIXED_FROM_INT(player->target_y);
}
*player->x = FIXED_TO_INT(player->real_x);
*player->y = FIXED_TO_INT(player->real_y);
engine_update_box(player, context->engine);
ticks++;
}
FIXED lerp(FIXED v0, FIXED v1, FIXED t) {
return FIXED_MUL((FIXED_MAKE(1) - t), v0) + FIXED_MUL(t, v1);
}
