void ai_getClosestOpponent(int player, int* opponent, float *distance) {
int i;
vec2 v_player;
vec2 v_opponent;
*opponent = -1;
*distance = FLT_MAX;
getPositionFromIndex(v_player.v + 0, v_player.v + 1, player);
for(i = 0; i < game->players; i++) {
if(i == player)
continue;
if(game->player[i].data->speed > 0) {
vec2 diff;
float d;
getPositionFromIndex(v_opponent.v + 0, v_opponent.v + 1, i);
vec2_Sub(&diff, &v_player, &v_opponent);
// use manhattan distance instead of euclidean distance
d = (float) ( fabs(diff.v[0]) + fabs(diff.v[1]) );
// d = vec2Length(&diff);
if(d < *distance) {
*opponent = i;
*distance = d;
}
}
}
}
bool SpiralIterator::isInside(const Index index) const
{
Eigen::Vector2d position;
getPositionFromIndex(position, index, mapLength_, mapPosition_, resolution_, bufferSize_);
double squareNorm = (position - center_).array().square().sum();
return (squareNorm <= radiusSquare_);
}
bool EllipseIterator::isInside() const
{
Position position;
getPositionFromIndex(position, *(*internalIterator_), mapLength_, mapPosition_, resolution_, bufferSize_, bufferStartIndex_);
double value = ((transformMatrix_ * (position - center_)).array().square() / semiAxisSquare_).sum();
return (value <= 1);
}
void createEvent(int player, event_type_e eventType) {
GameEvent *e;
List *p = &(game2->events);
/* move to the end of the event list */
while (p->next)
p = p->next;
/* TODO: handle failed malloc */
e = (GameEvent*) malloc(sizeof(GameEvent));
p->data = e;
p->next = (List*) malloc(sizeof(List));
p->next->next = NULL;
e->type = eventType;
getPositionFromIndex(&e->x, &e->y, player);
e->player = player;
e->timestamp = game2->time.current;
}
void Audio_Idle(void) {
// iterate over all the players and update the engines
if(sample_engine->IsPlaying()) {
for(int i = 0; i < PLAYERS; i++) {
Player *p;
Sound::Source3D *p3d;
float x, y;
p3d = players[i];
p = game->player + i;
getPositionFromIndex(&x, &y, i);
p3d->_location = Vector3(x, y, 0);
float V = p->data->speed;
int dt = game2->time.current - p->data->turn_time;
if(dt < TURN_LENGTH) {
float t = (float)dt / TURNLENGTH;
float vx = (1 - t) * dirsX[p->data->last_dir] +
t * dirsX[p->data->dir];
float vy = (1 - t) * dirsY[p->data->last_dir] +
t * dirsY[p->data->dir];
p3d->_velocity = Vector3(V * vx, V * vy, 0);
} else {
p3d->_velocity = Vector3(V * dirsX[p->data->dir],
V * dirsY[p->data->dir],
0);
}
if(i == 0) {
if(p->data->boost_enabled) {
( (Sound::SourceEngine*) p3d )->_speedShift = 1.2f;
} else {
( (Sound::SourceEngine*) p3d )->_speedShift = 1.0f;
}
( (Sound::SourceEngine*) p3d )->_pitchShift =
p->data->speed / getSettingf("speed");
}
#if 0
if(i == 0) {
if( dt < TURNLENGTH ) {
float t = (float)dt / TURNLENGTH;
float speedShift = ( 1 - t ) * 0.4 + t * 0.3;
float pitchShift = ( 1 - t ) * 0.9 + t * 1.0;
( (Sound::SourceEngine*) p3d )->_speedShift = speedShift;
( (Sound::SourceEngine*) p3d )->_pitchShift = pitchShift;
} else {
( (Sound::SourceEngine*) p3d )->_speedShift = 0.3;
( (Sound::SourceEngine*) p3d )->_pitchShift = 1.0;
}
}
#endif
}
}
if(sample_recognizer->IsPlaying()) {
if (gSettingsCache.show_recognizer) {
vec2 p, v;
getRecognizerPositionVelocity(&p, &v);
// recognizerEngine->_location = Vector3(p.x, p.y, RECOGNIZER_HEIGHT);
recognizerEngine->_location = Vector3(p.v[0], p.v[1], 10.0f);
recognizerEngine->_velocity = Vector3(v.v[0], v.v[1], 0);
}
}
if(music && !music->IsPlaying()) {
// check if music is enabled. if it is, advance to
// next song
if(gSettingsCache.playMusic) {
scripting_Run("nextTrack()");
}
}
Sound::Listener& listener = sound->GetListener();
listener._location = Vector3(game->player[0].camera->cam);
Vector3 v1 = Vector3(game->player[0].camera->target);
Vector3 v2 = Vector3(game->player[0].camera->cam);
listener._direction = v1 - v2;
// listener._location = players[0]->_location;
// listener._direction = players[0]->_velocity;
listener._velocity = players[0]->_velocity;
listener._up = Vector3(0, 0, 1);
sound->SetMixMusic(gSettingsCache.playMusic);
sound->SetMixFX(gSettingsCache.playEffects);
sound->Idle();
}
int applyWallAcceleration(int player, int dt) {
// find distance to enemy walls left & right
enum { eLeft, eRight, eMax };
segment2 segments[eMax];
Data *data = game->player[player].data;
int dirLeft = (data->dir + 3) % 4;
int dirRight = (data->dir + 1) % 4;
float left, right;
float x, y;
vec2 vPos;
int i, j;
getPositionFromIndex(&x, &y, player);
vPos.v[0] = x;
vPos.v[1] = y;
for(i = 0; i < eMax; i++) {
vec2Copy(&segments[i].vStart, &vPos);
}
segments[eLeft].vDirection.v[0] = dirsX[dirLeft];
segments[eLeft].vDirection.v[1] = dirsY[dirLeft];
segments[eRight].vDirection.v[0] = dirsX[dirRight];
segments[eRight].vDirection.v[1] = dirsY[dirRight];
left = FLT_MAX;
right = FLT_MAX;
for(i = 0; i < game->players; i++) {
segment2 *wall = game->player[i].data->trails;
if(i == player)
continue;
if(game->player[i].data->trail_height < TRAIL_HEIGHT)
continue;
for(j = 0; j < game->player[i].data->trailOffset + 1; j++) {
float t1, t2;
vec2 v;
if(segment2_Intersect(&v, &t1, &t2, segments + eLeft, wall) &&
t1 > 0 && t1 < left && t2 >= 0 && t2 <= 1)
left = t1;
if(segment2_Intersect(&v, &t1, &t2, segments + eRight, wall) &&
t1 > 0 && t1 < right && t2 >= 0 && t2 <= 1)
right = t1;
wall++;
}
}
{
float accell_limit = getSettingf("wall_accel_limit");
if(left < accell_limit || right < accell_limit) {
float boost = getSettingf("wall_accel_use") * dt / 1000.0f;
data->speed += boost;
return 1;
} else {
return 0;
}
}
}
bool PolygonIterator::isInside() const
{
Position position;
getPositionFromIndex(position, *(*internalIterator_), mapLength_, mapPosition_, resolution_, bufferSize_, bufferStartIndex_);
return polygon_.isInside(position);
}
void ai_getDistances(int player, AI_Distances *distances) {
enum { eFront = 0, eLeft, eRight, eBackleft, eMax };
segment2 segments[eMax];
vec2 v, vPos;
Data *data = game->player[player].data;
int dirLeft = (data->dir + 3) % 4;
int dirRight = (data->dir + 1) % 4;
int i, j;
float *front = &distances->front;
float *right = &distances->right;
float *left = &distances->left;
float *backleft = &distances->backleft;
getPositionFromIndex(vPos.v + 0, vPos.v + 1, player);
for(i = 0; i < eMax; i++) {
vec2_Copy(&segments[i].vStart, &vPos);
}
segments[eFront].vDirection.v[0] = (float) dirsX[data->dir];
segments[eFront].vDirection.v[1] = (float) dirsY[data->dir];
segments[eLeft].vDirection.v[0] = (float) dirsX[dirLeft];
segments[eLeft].vDirection.v[1] = (float) dirsY[dirLeft];
segments[eRight].vDirection.v[0] = (float) dirsX[dirRight];
segments[eRight].vDirection.v[1] = (float) dirsY[dirRight];
segments[eBackleft].vDirection.v[0] = (float) dirsX[dirLeft] - dirsX[data->dir];
segments[eBackleft].vDirection.v[1] = (float) dirsY[dirLeft] - dirsY[data->dir];
vec2_Normalize(&segments[eBackleft].vDirection,
&segments[eBackleft].vDirection);
*front = FLT_MAX;
*left = FLT_MAX;
*right = FLT_MAX;
*backleft = FLT_MAX;
// loop over all segment
for(i = 0; i < game->players; i++) {
segment2 *wall = game->player[i].data->trails;
if(game->player[i].data->trail_height < TRAIL_HEIGHT)
continue;
for(j = 0; j < game->player[i].data->trailOffset + 1; j++) {
float t1, t2;
if(i == player && j == game->player[i].data->trailOffset)
break;
if(segment2_Intersect(&v, &t1, &t2, segments + eFront, wall) &&
t1 > 0 && t1 < *front && t2 >= 0 && t2 <= 1)
*front = t1;
if(segment2_Intersect(&v, &t1, &t2, segments + eLeft, wall) &&
t1 > 0 && t1 < *left && t2 >= 0 && t2 <= 1)
*left = t1;
if(segment2_Intersect(&v, &t1, &t2, segments + eRight, wall) &&
t1 > 0 && t1 < *right && t2 >= 0 && t2 <= 1)
*right = t1;
if(segment2_Intersect(&v, &t1, &t2, segments + eBackleft, wall) &&
t1 > 0 && t1 < *backleft && t2 >= 0 && t2 <= 1)
*backleft = t1;
wall++;
}
}
for(i = 0; i < game2->level->nBoundaries; i++) {
float t1, t2;
segment2* wall = game2->level->boundaries + i;
if(segment2_Intersect(&v, &t1, &t2, segments + eFront, wall) &&
t1 > 0 && t1 < *front && t2 >= 0 && t2 <= 1)
*front = t1;
if(segment2_Intersect(&v, &t1, &t2, segments + eLeft, wall) &&
t1 > 0 && t1 < *left && t2 >= 0 && t2 <= 1)
*left = t1;
if(segment2_Intersect(&v, &t1, &t2, segments + eRight, wall) &&
t1 > 0 && t1 < *right && t2 >= 0 && t2 <= 1)
*right = t1;
if(segment2_Intersect(&v, &t1, &t2, segments + eBackleft, wall) &&
t1 > 0 && t1 < *backleft && t2 >= 0 && t2 <= 1)
*backleft = t1;
}
// update debug render segments
{
AI *ai = game->player[player].ai;
vec2_Copy(&ai->front.vStart, &vPos);
vec2_Copy(&ai->left.vStart, &vPos);
vec2_Copy(&ai->right.vStart, &vPos);
vec2_Copy(&ai->backleft.vStart, &vPos);
ai->front.vDirection.v[0] = *front * dirsX[data->dir];
ai->front.vDirection.v[1] = *front * dirsY[data->dir];
ai->left.vDirection.v[0] = *left * dirsX[dirLeft];
ai->left.vDirection.v[1] = *left * dirsY[dirLeft];
ai->right.vDirection.v[0] = *right * dirsX[dirRight];
ai->right.vDirection.v[1] = *right * dirsY[dirRight];
ai->backleft.vDirection.v[0] = (float) (dirsX[dirLeft] - dirsX[data->dir]);
ai->backleft.vDirection.v[1] = (float) (dirsY[dirLeft] - dirsY[data->dir]);
vec2_Normalize(&ai->backleft.vDirection,
&ai->backleft.vDirection);
vec2_Scale(&ai->backleft.vDirection,
&ai->backleft.vDirection,
*backleft);
}
// printf("%.2f, %.2f, %.2f\n", *front, *right, *left);
return;
}
void ai_getConfig(int player, int target,
AI_Configuration *config) {
Data *data;
getPositionFromIndex(config->player.vStart.v + 0,
config->player.vStart.v + 1,
player);
getPositionFromIndex(config->opponent.vStart.v + 0,
config->opponent.vStart.v + 1,
target);
data = game->player[player].data;
config->player.vDirection.v[0] = dirsX[ data->dir ] * data->speed;
config->player.vDirection.v[1] = dirsY[ data->dir ] * data->speed;
data = game->player[target].data;
config->opponent.vDirection.v[0] = dirsX[ data->dir ] * data->speed;
config->opponent.vDirection.v[1] = dirsY[ data->dir ] * data->speed;
// compute sector
{
vec2 diff;
vec3 v1, v2, v3;
vec3 up = { { 0, 0, 1 } };
float cosphi;
float phi;
int i;
vec2_Sub(&diff, &config->player.vStart, &config->opponent.vStart);
v1.v[0] = diff.v[0];
v1.v[1] = diff.v[1];
v1.v[2] = 0;
v2.v[0] = config->opponent.vDirection.v[0];
v2.v[1] = config->opponent.vDirection.v[1];
v2.v[2] = 0;
vec3_Normalize(&v1, &v1);
vec3_Normalize(&v2, &v2);
vec3_Cross(&v3, &v1, &v2);
vec3_Normalize(&v3, &v3);
cosphi = vec3_Dot(&v1, &v2);
nebu_Clamp(&cosphi, -1, 1);
phi = (float) acos(cosphi);
if(vec3_Dot(&v3, &up) > 0)
phi = 2 * (float) M_PI - phi;
for(i = 0; i < 8; i++) {
phi -= (float) M_PI / 4;
if(phi < 0) {
config->location = i;
break;
}
}
}
// compute intersection
{
segment2 seg1;
segment2 seg2;
seg1.vStart = config->opponent.vStart;
seg1.vDirection = config->opponent.vDirection;
seg2.vStart = config->player.vStart;
vec2_Orthogonal( &seg2.vDirection, &config->opponent.vDirection );
vec2_Normalize( &seg2.vDirection, &seg2.vDirection );
vec2_Scale( &seg2.vDirection,
&seg2.vDirection,
vec2_Length( &config->player.vDirection )
);
segment2_Intersect( &config->intersection,
&config->t_opponent, &config->t_player,
&seg1, &seg2 );
if(config->t_player < 0)
config->t_player *= -1;
}
}
bool GridMap::getPosition(const Eigen::Array2i& index, Eigen::Vector2d& position) const
{
return getPositionFromIndex(position, index, length_, position_, resolution_, bufferSize_, bufferStartIndex_);
}
