float
SDL_sqrtf(float x)
{
#if defined(HAVE_SQRTF)
return sqrtf(x);
#else
return (float)SDL_sqrt((double)x);
#endif
}
void CGame::handleEnemyShots()
{
for (std::list<std::unique_ptr<CShell>>::iterator shell = enemyShells.begin(); shell != enemyShells.end(); shell++)
{
if ((*shell)->direction > 0)
{
//fighter shells are faster
if ((*shell)->fast == true)
(*shell)->box.x += 10;
else
(*shell)->box.x += 5;
}
if ((*shell)->direction < 0)
(*shell)->box.x -= 5;
//decrease distance needed for exploding shell to blow
if ((*shell)->exploding)
{
(*shell)->distance -= 5;
//stop moving
if ((*shell)->distance < 0)
(*shell)->direction = 0;
}
//if not exploded already and at distance needed for explosion
if ((*shell)->doIExplode() && !(*shell)->exploded)
{
(*shell)->exploded = true;
//explosion timer
(*shell)->timer.Start();
int plane_radius = SDL_sqrt((PLANE_HEIGHT*PLANE_HEIGHT + PLANE_WIDTH*PLANE_WIDTH))/2;
if (pointToPointDistance(plane.getBox().x + PLANE_WIDTH/2, plane.getBox().y +PLANE_HEIGHT/2, (*shell)->box.x + 2, (*shell)->box.y + 2) < ((*shell)->radius + plane_radius))
{
//if distance less than sum of radi, then collision with plane
plane.removeLife();
shell->reset();
enemyShells.erase(shell++);
continue;
}
}
//if shell goes out of screen
if (((*shell)->box.x > SCREEN_WIDTH) || ((*shell)->box.x < 0))
{
shell->reset();
enemyShells.erase(shell++);
}
}
}
static float dollarDifference(SDL_FloatPoint* points,SDL_FloatPoint* templ,float ang)
{
/* SDL_FloatPoint p[DOLLARNPOINTS]; */
float dist = 0;
SDL_FloatPoint p;
int i;
for (i = 0; i < DOLLARNPOINTS; i++) {
p.x = (float)(points[i].x * SDL_cos(ang) - points[i].y * SDL_sin(ang));
p.y = (float)(points[i].x * SDL_sin(ang) + points[i].y * SDL_cos(ang));
dist += (float)(SDL_sqrt((p.x-templ[i].x)*(p.x-templ[i].x)+
(p.y-templ[i].y)*(p.y-templ[i].y)));
}
return dist/DOLLARNPOINTS;
}
double
SDL_acos(double val)
{
#if defined(HAVE_ACOS)
return acos(val);
#else
double result;
if (val == -1.0) {
result = M_PI;
} else {
result = SDL_atan(SDL_sqrt(1.0 - val * val) / val);
if (result < 0.0)
{
result += M_PI;
}
}
return result;
#endif
}
/*
* Simulates desktop's glRotatef. The matrix is returned in column-major
* order.
*/
static void
rotate_matrix(float angle, float x, float y, float z, float *r)
{
float radians, c, s, c1, u[3], length;
int i, j;
radians = (float)(angle * M_PI) / 180.0f;
c = SDL_cosf(radians);
s = SDL_sinf(radians);
c1 = 1.0f - SDL_cosf(radians);
length = (float)SDL_sqrt(x * x + y * y + z * z);
u[0] = x / length;
u[1] = y / length;
u[2] = z / length;
for (i = 0; i < 16; i++) {
r[i] = 0.0;
}
r[15] = 1.0;
for (i = 0; i < 3; i++) {
r[i * 4 + (i + 1) % 3] = u[(i + 2) % 3] * s;
r[i * 4 + (i + 2) % 3] = -u[(i + 1) % 3] * s;
}
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
r[i * 4 + j] += c1 * u[i] * u[j] + (i == j ? c : 0.0f);
}
}
}
void SDL_GestureProcessEvent(SDL_Event* event)
{
float x,y;
SDL_FloatPoint path[DOLLARNPOINTS];
int index;
int i;
float pathDx, pathDy;
SDL_FloatPoint lastP;
SDL_FloatPoint lastCentroid;
float lDist;
float Dist;
float dtheta;
float dDist;
if (event->type == SDL_FINGERMOTION ||
event->type == SDL_FINGERDOWN ||
event->type == SDL_FINGERUP) {
SDL_GestureTouch* inTouch = SDL_GetGestureTouch(event->tfinger.touchId);
/* Shouldn't be possible */
if (inTouch == NULL) return;
x = event->tfinger.x;
y = event->tfinger.y;
/* Finger Up */
if (event->type == SDL_FINGERUP) {
inTouch->numDownFingers--;
#ifdef ENABLE_DOLLAR
if (inTouch->recording) {
inTouch->recording = SDL_FALSE;
dollarNormalize(&inTouch->dollarPath,path);
/* PrintPath(path); */
if (recordAll) {
index = SDL_AddDollarGesture(NULL,path);
for (i = 0; i < SDL_numGestureTouches; i++)
SDL_gestureTouch[i].recording = SDL_FALSE;
}
else {
index = SDL_AddDollarGesture(inTouch,path);
}
if (index >= 0) {
SDL_SendDollarRecord(inTouch,inTouch->dollarTemplate[index].hash);
}
else {
SDL_SendDollarRecord(inTouch,-1);
}
}
else {
int bestTempl;
float error;
error = dollarRecognize(&inTouch->dollarPath,
&bestTempl,inTouch);
if (bestTempl >= 0){
/* Send Event */
unsigned long gestureId = inTouch->dollarTemplate[bestTempl].hash;
SDL_SendGestureDollar(inTouch,gestureId,error);
/* printf ("%s\n",);("Dollar error: %f\n",error); */
}
}
#endif
/* inTouch->gestureLast[j] = inTouch->gestureLast[inTouch->numDownFingers]; */
if (inTouch->numDownFingers > 0) {
inTouch->centroid.x = (inTouch->centroid.x*(inTouch->numDownFingers+1)-
x)/inTouch->numDownFingers;
inTouch->centroid.y = (inTouch->centroid.y*(inTouch->numDownFingers+1)-
y)/inTouch->numDownFingers;
}
}
else if (event->type == SDL_FINGERMOTION) {
float dx = event->tfinger.dx;
float dy = event->tfinger.dy;
#ifdef ENABLE_DOLLAR
SDL_DollarPath* path = &inTouch->dollarPath;
if (path->numPoints < MAXPATHSIZE) {
path->p[path->numPoints].x = inTouch->centroid.x;
path->p[path->numPoints].y = inTouch->centroid.y;
pathDx =
(path->p[path->numPoints].x-path->p[path->numPoints-1].x);
pathDy =
(path->p[path->numPoints].y-path->p[path->numPoints-1].y);
path->length += (float)SDL_sqrt(pathDx*pathDx + pathDy*pathDy);
path->numPoints++;
}
#endif
lastP.x = x - dx;
lastP.y = y - dy;
lastCentroid = inTouch->centroid;
inTouch->centroid.x += dx/inTouch->numDownFingers;
inTouch->centroid.y += dy/inTouch->numDownFingers;
/* printf("Centrid : (%f,%f)\n",inTouch->centroid.x,inTouch->centroid.y); */
if (inTouch->numDownFingers > 1) {
SDL_FloatPoint lv; /* Vector from centroid to last x,y position */
SDL_FloatPoint v; /* Vector from centroid to current x,y position */
/* lv = inTouch->gestureLast[j].cv; */
lv.x = lastP.x - lastCentroid.x;
lv.y = lastP.y - lastCentroid.y;
lDist = (float)SDL_sqrt(lv.x*lv.x + lv.y*lv.y);
/* printf("lDist = %f\n",lDist); */
v.x = x - inTouch->centroid.x;
v.y = y - inTouch->centroid.y;
/* inTouch->gestureLast[j].cv = v; */
Dist = (float)SDL_sqrt(v.x*v.x+v.y*v.y);
/* SDL_cos(dTheta) = (v . lv)/(|v| * |lv|) */
/* Normalize Vectors to simplify angle calculation */
lv.x/=lDist;
lv.y/=lDist;
v.x/=Dist;
v.y/=Dist;
dtheta = (float)SDL_atan2(lv.x*v.y - lv.y*v.x,lv.x*v.x + lv.y*v.y);
dDist = (Dist - lDist);
if (lDist == 0) {dDist = 0;dtheta = 0;} /* To avoid impossible values */
/* inTouch->gestureLast[j].dDist = dDist;
inTouch->gestureLast[j].dtheta = dtheta;
printf("dDist = %f, dTheta = %f\n",dDist,dtheta);
gdtheta = gdtheta*.9 + dtheta*.1;
gdDist = gdDist*.9 + dDist*.1
knob.r += dDist/numDownFingers;
knob.ang += dtheta;
printf("thetaSum = %f, distSum = %f\n",gdtheta,gdDist);
printf("id: %i dTheta = %f, dDist = %f\n",j,dtheta,dDist); */
SDL_SendGestureMulti(inTouch,dtheta,dDist);
}
else {
/* inTouch->gestureLast[j].dDist = 0;
inTouch->gestureLast[j].dtheta = 0;
inTouch->gestureLast[j].cv.x = 0;
inTouch->gestureLast[j].cv.y = 0; */
}
/* inTouch->gestureLast[j].f.p.x = x;
inTouch->gestureLast[j].f.p.y = y;
break;
pressure? */
}
if (event->type == SDL_FINGERDOWN) {
inTouch->numDownFingers++;
inTouch->centroid.x = (inTouch->centroid.x*(inTouch->numDownFingers - 1)+
x)/inTouch->numDownFingers;
inTouch->centroid.y = (inTouch->centroid.y*(inTouch->numDownFingers - 1)+
y)/inTouch->numDownFingers;
/* printf("Finger Down: (%f,%f). Centroid: (%f,%f\n",x,y,
inTouch->centroid.x,inTouch->centroid.y); */
#ifdef ENABLE_DOLLAR
inTouch->dollarPath.length = 0;
inTouch->dollarPath.p[0].x = x;
inTouch->dollarPath.p[0].y = y;
inTouch->dollarPath.numPoints = 1;
#endif
}
}
}
/* DollarPath contains raw points, plus (possibly) the calculated length */
static int dollarNormalize(const SDL_DollarPath *path,SDL_FloatPoint *points)
{
int i;
float interval;
float dist;
int numPoints = 0;
SDL_FloatPoint centroid;
float xmin,xmax,ymin,ymax;
float ang;
float w,h;
float length = path->length;
/* Calculate length if it hasn't already been done */
if (length <= 0) {
for (i=1;i < path->numPoints; i++) {
float dx = path->p[i ].x - path->p[i-1].x;
float dy = path->p[i ].y - path->p[i-1].y;
length += (float)(SDL_sqrt(dx*dx+dy*dy));
}
}
/* Resample */
interval = length/(DOLLARNPOINTS - 1);
dist = interval;
centroid.x = 0;centroid.y = 0;
/* printf("(%f,%f)\n",path->p[path->numPoints-1].x,path->p[path->numPoints-1].y); */
for (i = 1; i < path->numPoints; i++) {
float d = (float)(SDL_sqrt((path->p[i-1].x-path->p[i].x)*(path->p[i-1].x-path->p[i].x)+
(path->p[i-1].y-path->p[i].y)*(path->p[i-1].y-path->p[i].y)));
/* printf("d = %f dist = %f/%f\n",d,dist,interval); */
while (dist + d > interval) {
points[numPoints].x = path->p[i-1].x +
((interval-dist)/d)*(path->p[i].x-path->p[i-1].x);
points[numPoints].y = path->p[i-1].y +
((interval-dist)/d)*(path->p[i].y-path->p[i-1].y);
centroid.x += points[numPoints].x;
centroid.y += points[numPoints].y;
numPoints++;
dist -= interval;
}
dist += d;
}
if (numPoints < DOLLARNPOINTS-1) {
SDL_SetError("ERROR: NumPoints = %i\n",numPoints);
return 0;
}
/* copy the last point */
points[DOLLARNPOINTS-1] = path->p[path->numPoints-1];
numPoints = DOLLARNPOINTS;
centroid.x /= numPoints;
centroid.y /= numPoints;
/* printf("Centroid (%f,%f)",centroid.x,centroid.y); */
/* Rotate Points so point 0 is left of centroid and solve for the bounding box */
xmin = centroid.x;
xmax = centroid.x;
ymin = centroid.y;
ymax = centroid.y;
ang = (float)(SDL_atan2(centroid.y - points[0].y,
centroid.x - points[0].x));
for (i = 0; i<numPoints; i++) {
float px = points[i].x;
float py = points[i].y;
points[i].x = (float)((px - centroid.x)*SDL_cos(ang) -
(py - centroid.y)*SDL_sin(ang) + centroid.x);
points[i].y = (float)((px - centroid.x)*SDL_sin(ang) +
(py - centroid.y)*SDL_cos(ang) + centroid.y);
if (points[i].x < xmin) xmin = points[i].x;
if (points[i].x > xmax) xmax = points[i].x;
if (points[i].y < ymin) ymin = points[i].y;
if (points[i].y > ymax) ymax = points[i].y;
}
/* Scale points to DOLLARSIZE, and translate to the origin */
w = xmax-xmin;
h = ymax-ymin;
for (i=0; i<numPoints; i++) {
points[i].x = (points[i].x - centroid.x)*DOLLARSIZE/w;
points[i].y = (points[i].y - centroid.y)*DOLLARSIZE/h;
}
return numPoints;
}
// Update: draw background
update_status ModuleBlinky::Update()
{
Animation* current_animation = &idle;
Animation* horitzontal = &a_hor;
Animation* vertical = &a_vert;
float position_x = position.x;
float position_y = position.y;
int i_position_x = position.x;
int i_position_y = position.y;
int tilepos_x = ((i_position_x + 16) / 16) * 16;
int tilepos_y = ((i_position_y + 16) / 16) * 16;
int d_up = 1000;
int d_down = 1000;
int d_right = 1000;
int d_left = 1000;
float speed = 1.5;
if (SDL_GetTicks() - time <= 700){
direction = 2;
//if (SDL_GetTicks() - time >= 2000) direction = 1;
}
else if (SDL_GetTicks() - time <= 810){
direction = 1;
}
else {
if (turn == true){
if (App->player->s_map[(tilepos_y / 16)][(tilepos_x / 16)] == -1 || App->player->s_map[(tilepos_y / 16)][(tilepos_x / 16)] == -2){
if (App->player->s_map[(tilepos_y / 16) - 1][(tilepos_x / 16)] != 2){
d_up = SDL_sqrt(((tilepos_x)-App->player->position.x)*(tilepos_x - App->player->position.x) + ((tilepos_y - 16) - App->player->position.y)*((tilepos_y - 16) - App->player->position.y));
}
if (App->player->s_map[(tilepos_y / 16) + 1][(tilepos_x / 16)] != 2){
d_down = SDL_sqrt(((tilepos_x)-App->player->position.x)*(tilepos_x - App->player->position.x) + ((tilepos_y + 16) - App->player->position.y)*((tilepos_y + 16) - App->player->position.y));
}
if (App->player->s_map[(tilepos_y / 16)][(tilepos_x / 16) - 1] != 2){
d_left = SDL_sqrt(((tilepos_x - 16) - App->player->position.x)*((tilepos_x - 16) - App->player->position.x) + ((tilepos_y)-App->player->position.y)*((tilepos_y)-App->player->position.y));
}
if (App->player->s_map[(tilepos_y / 16)][(tilepos_x / 16) + 1] != 2){
d_right = SDL_sqrt(((tilepos_x + 16) - App->player->position.x)*((tilepos_x + 16) - App->player->position.x) + ((tilepos_y)-App->player->position.y)*((tilepos_y)-App->player->position.y));
}
if (direction == 0){
d_left = 1000;
}
if (direction == 1){
d_right = 1000;
}
if (direction == 2){
d_down = 1000;
}
if (direction == 3){
d_up = 1000;
}
if (d_up <= d_down && d_up <= d_right && d_up <= d_left){
direction = 2; turn = false;
}
else if (d_right <= d_down && d_right <= d_left && d_right <= d_up){
direction = 0; turn = false;
}
else if (d_down <= d_up && d_down <= d_right && d_down <= d_left){
direction = 3; turn = false;
}
else if (d_left <= d_up && d_left <= d_right && d_left <= d_down){
direction = 1; turn = false;
}
}
if (App->player->power == true){
d_up = 0;
d_down = 0;
d_right = 0;
d_left = 0;
if (App->player->s_map[(tilepos_y / 16)][(tilepos_x / 16)] == -1 || App->player->s_map[(tilepos_y / 16)][(tilepos_x / 16)] == -2){
if (App->player->s_map[(tilepos_y / 16) - 1][(tilepos_x / 16)] != 2){
d_up = SDL_sqrt(((tilepos_x)-App->player->position.x)*(tilepos_x - App->player->position.x) + ((tilepos_y - 16) - App->player->position.y)*((tilepos_y - 16) - App->player->position.y));
}
if (App->player->s_map[(tilepos_y / 16) + 1][(tilepos_x / 16)] != 2){
d_down = SDL_sqrt(((tilepos_x)-App->player->position.x)*(tilepos_x - App->player->position.x) + ((tilepos_y + 16) - App->player->position.y)*((tilepos_y + 16) - App->player->position.y));
}
if (App->player->s_map[(tilepos_y / 16)][(tilepos_x / 16) - 1] != 2){
d_left = SDL_sqrt(((tilepos_x - 16) - App->player->position.x)*((tilepos_x - 16) - App->player->position.x) + ((tilepos_y)-App->player->position.y)*((tilepos_y)-App->player->position.y));
}
if (App->player->s_map[(tilepos_y / 16)][(tilepos_x / 16) + 1] != 2){
d_right = SDL_sqrt(((tilepos_x + 16) - App->player->position.x)*((tilepos_x + 16) - App->player->position.x) + ((tilepos_y)-App->player->position.y)*((tilepos_y)-App->player->position.y));
}
if (d_up >= d_down && d_up >= d_right && d_up >= d_left){
direction = 2; turn = false;
}
else if (d_down >= d_up && d_down >= d_right && d_down >= d_left){
direction = 3; turn = false;
}
else if (d_right >= d_down && d_right >= d_left && d_right >= d_up){
direction = 0; turn = false;
}
else if (d_left >= d_up && d_left >= d_right && d_left >= d_down){
direction = 1; turn = false;
}
}
}
}
}
if (App->player->power == true ||App->player->god ==true){
if (SDL_GetTicks() - App->player->time > 2000 && SDL_GetTicks() - App->player->time < 4000){
current_animation = &scared2;
}
else
current_animation = &scared;
}
else{
if (direction == 0){
current_animation = &right;
//position.x += speed;
}
if (direction == 1){
current_animation = &left;
//position.x -= speed;
}
if (direction == 2){
current_animation = &up;
//position.y -= speed;
}
if (direction == 3){
current_animation = &down;
//position.y += speed;
}
}
if (direction == 0 && App->player->s_map[tilepos_y / 16][(tilepos_x / 16)] != 2){
position_x = position_x + speed;
position.x = position_x;
position.y = (i_position_y / 16) * 16 + 8;
}
if (direction == 1 && App->player->s_map[tilepos_y / 16][(tilepos_x / 16)] != 2){
position_x = position_x - speed;
position.x = position_x;
position.y = (i_position_y / 16) * 16 + 8;
}
if (direction == 2 && App->player->s_map[tilepos_y / 16][(tilepos_x / 16)] != 2){
position_y = position_y - speed;
position.y = position_y;
position.x = (i_position_x / 16) * 16 + 8;
}
if (direction == 3 && App->player->s_map[tilepos_y / 16][(tilepos_x / 16)] != 2){
position_y = position_y + speed;
position.y = position_y;
position.x = (i_position_x / 16) * 16 + 8;
}
if (direction == 0 && App->player->s_map[tilepos_y / 16][(tilepos_x / 16) + 1] == 2){
position_x = position_x - speed;
position.x = (i_position_x / 16) * 16 + 8;
}
if (direction == 1 && App->player->s_map[tilepos_y / 16][(tilepos_x / 16) - 1] == 2){
position_x = position_x + speed;
position.x = (i_position_x / 16) * 16 + 8;
}
if (direction == 2 && App->player->s_map[(tilepos_y / 16) - 1][(tilepos_x / 16)] == 2){
position_y = position_y + speed;
position.y = (i_position_y / 16) * 16 + 8;
}
if (direction == 3 && App->player->s_map[(tilepos_y / 16) + 1][(tilepos_x / 16)] == 2){
position_y = position_y - speed;
position.y = (i_position_y / 16) * 16 + 8;
}
float t_positionx = position.x;
float t_positiony = position.y;
float t_position_x = t_positionx;
float t_position_y = t_positiony;
int p_position_x = App->player->position.x;
int p_position_y = App->player->position.y;
int player_position_x = (( p_position_x+ 16) / 16) * 16;
int player_position_y = ((p_position_y + 16) / 16) * 16;
bool t_turn = true;
// Collider--------------
col->SetPos(tilepos_x, tilepos_y);
int i = 0, n = 0;
int temp_dir = direction;
bool ret = false;
int cont = 0;
if (debug ==true){
while (ret != true){
d_up = 1000;
d_down = 1000;
d_left = 1000;
d_right = 1000;
//t_position_x + i != App->player->position.x && t_position_y + n != App->player->position.y
float t_position_x = t_positionx;
float t_position_y = t_positiony;
int t_i_position_x = t_positionx;
int t_i_position_y = t_positiony;
int t_tilepos_y = ((t_i_position_y + 16) / 16) * 16;
int t_tilepos_x = ((t_i_position_x + 16) / 16) * 16;
if (t_turn == true){
if (App->player->s_map[(t_tilepos_y / 16)][(t_tilepos_x / 16)] == -1 || App->player->s_map[(t_tilepos_y / 16)][(t_tilepos_x / 16)] == -2){
if (App->player->s_map[(t_tilepos_y / 16) - 1][(t_tilepos_x / 16)] != 2){
d_up = SDL_sqrt(((t_tilepos_x)-App->player->position.x)*(t_tilepos_x - App->player->position.x) + ((t_tilepos_y - 16) - App->player->position.y)*((t_tilepos_y - 16) - App->player->position.y));
}
if (App->player->s_map[(t_tilepos_y / 16) + 1][(t_tilepos_x / 16)] != 2){
d_down = SDL_sqrt(((t_tilepos_x)-App->player->position.x)*(t_tilepos_x - App->player->position.x) + ((t_tilepos_y + 16) - App->player->position.y)*((t_tilepos_y + 16) - App->player->position.y));
}
if (App->player->s_map[(t_tilepos_y / 16)][(t_tilepos_x / 16) - 1] != 2){
d_left = SDL_sqrt(((t_tilepos_x - 16) - App->player->position.x)*((t_tilepos_x - 16) - App->player->position.x) + ((t_tilepos_y)-App->player->position.y)*((t_tilepos_y)-App->player->position.y));
}
if (App->player->s_map[(t_tilepos_y / 16)][(t_tilepos_x / 16) + 1] != 2){
d_right = SDL_sqrt(((t_tilepos_x + 16) - App->player->position.x)*((t_tilepos_x + 16) - App->player->position.x) + ((t_tilepos_y)-App->player->position.y)*((t_tilepos_y)-App->player->position.y));
}
if (temp_dir == 0){
d_left = 1000;
}
if (temp_dir == 1){
d_right = 1000;
}
if (temp_dir == 2){
d_down = 1000;
}
if (temp_dir == 3){
d_up = 1000;
}
if (d_up <= d_down && d_up <= d_right && d_up <= d_left){
temp_dir = 2; t_turn = false;
}
else if (d_right <= d_down && d_right <= d_left && d_right <= d_up){
temp_dir = 0; t_turn = false;
}
else if (d_down <= d_up && d_down <= d_right && d_down <= d_left){
temp_dir = 3; t_turn = false;
}
else if (d_left <= d_up && d_left <= d_right && d_left <= d_down){
temp_dir = 1; t_turn = false;
}
}
}
if (temp_dir == 0 && App->player->s_map[t_tilepos_y / 16][(t_tilepos_x / 16)] != 2){
t_position_x = t_position_x + speed;
t_positionx = t_position_x;
t_positiony = (t_i_position_y / 16) * 16 + 8;
}
if (temp_dir == 1 && App->player->s_map[t_tilepos_y / 16][(t_tilepos_x / 16)] != 2){
t_position_x = t_position_x - speed;
t_positionx = t_position_x;
t_positiony = (t_i_position_y / 16) * 16 + 8;
}
if (temp_dir == 2 && App->player->s_map[t_tilepos_y / 16][(t_tilepos_x / 16)] != 2){
t_position_y = t_position_y - speed;
t_positiony = t_position_y;
t_positionx = (t_i_position_x / 16) * 16 + 8;
}
if (temp_dir == 3 && App->player->s_map[t_tilepos_y / 16][(t_tilepos_x / 16)] != 2){
t_position_y = t_position_y + speed;
t_positiony = t_position_y;
t_positionx = (t_i_position_x / 16) * 16 + 8;
}
if (temp_dir == 0 && App->player->s_map[t_tilepos_y / 16][(t_tilepos_x / 16) + 1] == 2){
t_position_x = t_position_x - speed;
t_positionx = (t_i_position_x / 16) * 16 + 8;
}
if (temp_dir == 0 || temp_dir == 1){
App->render->Blit(graphics, t_tilepos_x, t_tilepos_y, &(horitzontal->GetCurrentFrame()));
}
else App->render->Blit(graphics, t_tilepos_x, t_tilepos_y, &(vertical->GetCurrentFrame()));
if (temp_dir == 0){
t_tilepos_x += 16;
}
if (temp_dir == 1){
t_tilepos_x -= 16;
}
if (temp_dir == 2){
t_tilepos_y -= 16;
}
if (temp_dir == 3){
t_tilepos_y += 16;
}
if (App->player->s_map[(t_tilepos_y / 16)][(t_tilepos_x / 16)] != -1 && App->player->s_map[(t_tilepos_y / 16)][(t_tilepos_x / 16)] != -2)
{
t_turn = true;
}
if ((t_tilepos_y == player_position_y && t_tilepos_x == player_position_x) || cont >= 100){
ret = true;
t_turn = true;
temp_dir = direction;
}
cont++;
}
}
if (destroyed == false)
App->render->Blit(graphics, position.x, position.y, &(current_animation->GetCurrentFrame()));
if (App->player->s_map[(tilepos_y / 16)][(tilepos_x / 16)] == -3)
{
position.x = 0;
}
if (App->player->s_map[(tilepos_y / 16)][(tilepos_x / 16)] == -4)
{
position.x = 410;
}
// Draw everything --------------------------------------
SDL_Rect r = current_animation->GetCurrentFrame();
//App->render->Blit(graphics, position.x, position.y - r.h, &r);
/*int tilepos_x_temp = ((i_position_x + 16) / 16) * 16;
int tilepos_y_temp = ((i_position_y + 16) / 16) * 16;
if (tilepos_x_temp != tilepos_x || tilepos_y_temp != tilepos_y){
turn = true;
}*/
if (App->player->s_map[(tilepos_y / 16)][(tilepos_x / 16)] != -1 && App->player->s_map[(tilepos_y / 16)][(tilepos_x / 16)] != -2)
{
turn = true;
}
return UPDATE_CONTINUE;
}
