void ft_bresenham(t_id *s)
{
s->dx = ft_abs(s->x1 - s->x0);
s->dy = ft_abs(s->y1 - s->y0);
s->sx = s->x0 < s->x1 ? 1 : -1;
s->sy = s->y0 < s->y1 ? 1 : -1;
s->err = (s->dx > s->dy ? s->dx : -s->dy) / 2;
while (1)
{
mlx_image_put_pixel(s, s->x0, s->y0);
if (s->x0 == s->x1 && s->y0 == s->y1)
break;
s->e2 = s->err;
if (s->e2 > -s->dx)
{
s->err-= s->dy;
s->x0+= s->sx;
}
if (s->e2 < s->dy)
{
s->err+= s->dx;
s->y0+= s->sy;
}
}
}
void ft_new_draw_algo(t_pts *pts, t_mlx *mlx)
{
float incl;
int i;
int px;
int py;
i = 0;
if ((ft_abs(pts->mx2 - pts->mx1) >= ft_abs(pts->my2 - pts->my1)
&& pts->mx1 != pts->mx2) || pts->my1 == pts->my2)
{
incl = (float)(pts->my2 - pts->my1) / (float)(pts->mx2 - pts->mx1);
while ((i += sgn(pts->mx2 - pts->mx1)) != (pts->mx2 - pts->mx1))
{
py = incl * i + pts->my1;
mlx_pixel_put(mlx->mlx, mlx->win, (i + pts->mx1), py, 0xffffff);
}
}
else
{
incl = (float)(pts->mx2 - pts->mx1) / (float)(pts->my2 - pts->my1);
while ((i += sgn(pts->my2 - pts->my1)) != (pts->my2 - pts->my1))
{
px = incl * i + pts->mx1;
mlx_pixel_put(mlx->mlx, mlx->win, px, (i + pts->my1), 0xffffff);
}
}
}
void draw_floor(t_env *e, t_trac_data *d)
{
int floor_tex_x;
int floor_tex_y;
int y;
t_colors col;
d->dist_wall = d->perp_wall_dist;
d->dist_player = 0.0;
if (d->draw_end < 0)
d->draw_end = SCREEN_HEIGHT;
y = d->draw_end - 1;
while (++y < SCREEN_HEIGHT)
{
d->current_dist = SCREEN_HEIGHT / (2.0 * y - SCREEN_HEIGHT);
d->weight = (d->current_dist - d->dist_player)
/ (d->dist_wall - d->dist_player);
d->current_floor_x = d->weight * d->floor_x_wall
+ (1.0 - d->weight) * e->p.pos_x;
d->current_floor_y = d->weight * d->floor_y_wall
+ (1.0 - d->weight) * e->p.pos_y;
floor_tex_x = ft_abs((int)(d->current_floor_x * TEX_WIDTH) % TEX_WIDTH);
floor_tex_y = ft_abs((int)(d->current_floor_y
* TEX_HEIGHT) % TEX_HEIGHT);
floor_pixel_color(e, floor_tex_x, floor_tex_y, &col);
print_floor(e, d, &col, y);
}
}
char *ft_itoa_base(int value, int base)
{
char *str;
int i;
int isneg;
if (base < 2 || base > 16 || value == 0)
return (ft_returnzero());
if (!(str = ft_allocstr(value, base)))
return (NULL);
i = 0;
isneg = 0;
if (base == 10 && value < 0)
isneg = 1;
while (value != 0)
{
if (value % base <= 9)
str[i++] = ft_abs(value % base) + '0';
else
str[i++] = (ft_abs(value % base) - 10) + 'a';
value /= base;
}
if (isneg)
str[i++] = '-';
str[i] = '\0';
ft_strrev(str);
return (str);
}
static void line(t_glob *g)
{
t_ligne l;
l.dx = ft_abs(g->e->x_1 - g->e->x_0);
l.sx = g->e->x_0 < g->e->x_1 ? 1 : -1;
l.dy = ft_abs(g->e->y_1 - g->e->y_0);
l.sy = g->e->y_0 < g->e->y_1 ? 1 : -1;
l.err = (l.dx > l.dy ? l.dx : -l.dy) / 2;
while (1)
{
ft_pixel_put_image(g->e->img[0], g->e->x_0, g->e->y_0, 0x808080);
if (g->e->x_0 == g->e->x_1 && g->e->y_0 == g->e->y_1)
break ;
l.e2 = l.err;
if (l.e2 > -l.dx)
{
l.err -= l.dy;
g->e->x_0 += l.sx;
}
if (l.e2 < l.dy)
{
l.err += l.dx;
g->e->y_0 += l.sy;
}
}
}
void calc_light(t_param *param, t_info *info, t_list *spot)
{
t_info *light;
t_spot *o_spot;
t_lum lum;
int *s_color;
if (info->distance < 0)
return ;
s_color = init_color();
while (spot)
{
o_spot = (t_spot *)spot->content;
light = init_light(info, o_spot);
calc_intersection(param, light);
if (point_cmp(info->r_pos, light->r_pos) == 1)
{
lum.fading = ft_abs(calc_fading(light->r_line.vec, info->vec_n));
lum.shining = ft_abs(calc_shining(info->vec_n, light->r_line.vec));
info->light += o_spot->value * lum.fading;
info->light += o_spot->value * lum.shining * lum.fading;
calc_color(&s_color, o_spot->color, o_spot->value, lum.fading);
}
spot = spot->next;
}
info->color = retrieve_col(s_color, damer(param, info, info->s_pos),
get_shine(info));
}
int mlx_putline(t_mlxdata *data, t_ipoint a, t_ipoint b)
{
int x;
if (a.x > WIDTH || b.x > WIDTH || a.y > HEIGHT || b.y > HEIGHT
|| a.x < 0 || b.x < 0 || a.y < 0 || b.y < 0)
return (0);
b.color = a.color;
if (ft_abs(b.y - a.y) > ft_abs(b.x - a.x))
{
if (a.y > b.y)
swap_points(&a, &b);
swap_xy(&a);
swap_xy(&b);
x = a.x;
while (x <= b.x)
{
mlx_putpxl_img(data->img,
(int)(a.y + ((b.y - a.y) * (x - a.x)) / (b.x - a.x)),
(int)x, a.color);
x++;
}
}
else
mlx_putlinetwo(data, a, b);
return (1);
}
char *ft_itoa_base_long(long long value, int base)
{
int len;
int i;
char *ret;
long long tmp;
if (base < 2 || base > 16)
return (NULL);
len = 1;
tmp = value;
while ((tmp = tmp / base))
len++;
if (!(ret = (char*)malloc(sizeof(char) * len + 1)))
return (NULL);
ret[len--] = '\0';
while (len >= 0 && value / base != 0)
{
i = ft_abs(value % base);
ret[len] = i < 10 ? i + '0' : i + '7';
value /= base;
len--;
}
i = ft_abs(value % base);
ret[len--] = i < 10 ? i + '0' : i + '7';
return (ret);
}
void line(t_pos *p1, t_pos *p2, t_env *map)
{
t_cor t;
t.dx = ft_abs(p2->x - p1->x);
t.sx = p1->x < p2->x ? 1 : -1;
t.dy = ft_abs(p2->y - p1->y);
t.sy = p1->y < p2->y ? 1 : -1;
t.err = (t.dx > t.dy ? t.dx : -t.dy) / 2;
while (1)
{
mlx_pixel_put(map->mlx, map->win, p1->x, p1->y, map->color);
if (p1->x == p2->x && p1->y == p2->y)
break ;
t.e2 = t.err;
if (t.e2 > -t.dx)
{
t.err -= t.dy;
p1->x += t.sx;
}
if (t.e2 < t.dy)
{
t.err += t.dx;
p1->y += t.sy;
}
}
}
void conv_i(t_spec *spec, t_print *print)
{
int i;
int j;
intmax_t p;
p = get_param(spec->hljz, print->ap);
if (p >= -9223372036854775807)
{
i = (p < 0) || (spec->flags & 3);
j = !(spec->prec || p) ? 0
: (ft_max(spec->prec + i, ft_nbrlen(ft_abs(p)) + i));
++spec->mfw;
(spec->flags & E_ZERO) ? apply_plusspace(print, spec, p >= 0)
: --spec->mfw;
(spec->flags & E_ZERO && p > 0) ? --spec->prec : 0;
(!(spec->flags & E_DASH)) ? apply_mfw(print, spec, spec->mfw - j) : 0;
!(spec->flags & E_ZERO) ? apply_plusspace(print, spec, p >= 0) : 0;
apply_numprec(print, spec, ft_nbrlen(ft_abs(p)));
(!spec->prec && !p) ? 0 : ft_sitoa(p, print, ft_nbrlen(ft_abs(p)));
j = (spec->flags & 3) && (p > 0);
(spec->flags & E_DASH) ? apply_mfw(print, spec, spec->mfw +
(p >= 0) - j) : 0;
}
}
int ft_putnbr_base(long nb, const char *base)
{
long div;
long i;
long result;
long size_base;
i = 0;
size_base = ft_strlen(base);
if (nb < 0)
{
ft_putchar('-');
i++;
}
div = 1;
while (ft_abs((nb / div)) >= size_base)
div = div * size_base;
while (div > 0)
{
result = ft_abs((nb / div) % size_base);
ft_putchar(base[result]);
div = div / size_base;
i++;
}
return (i);
}
void ft_putnbr_fd(int n, int fd)
{
if (n < 0)
ft_putchar_fd('-', fd);
if (n > 9 || n < -9)
ft_putnbr_fd(ft_abs(n / 10), fd);
ft_putchar_fd(ft_abs(n % 10) + 48, fd);
}
t_frac ft_reduce(t_frac frac)
{
t_frac result;
int pgcd;
int sign;
pgcd = ft_pgcd(frac.nom, frac.denom);
sign = (frac.nom * frac.denom < 0 ? -1 : 1);
result.nom = ft_abs(frac.nom) / pgcd * sign;
result.denom = ft_abs(frac.denom) / pgcd;
return result;
}
int ft_ultimate_range(int **range, int min, int max)
{
int i;
int *result;
if (min >= max || !(result = (int*)malloc(sizeof(int) * ft_abs(max - min))))
return (0);
i = 0;
while (i++ < ft_abs(max - min))
result[i - 1] = (min + i - 1);
*range = result;
return (ft_abs(max - min));
}
t_line_data *new_line_data(t_env *e, int x, int y, int x2, int y2)
{
t_line_data *l;
if (!(l = (t_line_data*)malloc(sizeof(t_line_data))))
return (NULL);
l->dx = ft_abs(x2 - x);
l->dy = ft_abs(y2 -y);
l->ix = (x < x2) ? 1 : -1;
l->iy = (y < y2) ? 1 : -1;
l->err = (l->dx > l->dy) ? l->dx /2 : -l->dy /2;
return (l);
}
void ft_putnbr(int n)
{
if (n >= 10 || n <= -10)
{
ft_putnbr(n / 10);
ft_putnbr(ft_abs(n % 10));
}
else
{
if (n < 0)
ft_putchar('-');
ft_putchar('0' + ft_abs(n));
}
}
int ft_contiguity(int x, int y, int x_p0, int y_p0)
{
int p;
int p0;
int p0_diff;
p0 = x_p0 + y_p0;
p = x + y;
p0_diff = p - p0;
p = ft_abs(x) + ft_abs(y);
if (p0_diff > 1 || p0_diff < -1 || p > 3)
return (0);
return (1);
}
static void ft_fill_cone(t_rtv1 *rtv1, char **tab, char **tri, int i)
{
char *hexa;
rtv1->obj.cone[i].posx = ft_atoid(tri[0]);
rtv1->obj.cone[i].posy = ft_atoid(tri[1]);
rtv1->obj.cone[i].posz = ft_atoid(tri[2]);
rtv1->obj.cone[i].base_size = ft_atoid(tab[1]);
rtv1->obj.cone[i].height = ft_atoid(tab[2]);
if ((hexa = ft_strstr(tab[3], "0x")))
rtv1->obj.cone[i].color = ft_abs(ft_atoi_base(&hexa[2], 16));
else
rtv1->obj.cone[i].color = ft_abs(ft_atoi_base(tab[3], 16));
}
void ft_cut_select(t_it *it)
{
int length;
int temp;
int a;
int b;
tputs(tgetstr("me", NULL), 0, my_putchar);
it->r_video = 0;
length = ft_abs(it->i - it->saved_i) + 1;
temp = it->i;
a = it->i - it->offset;
b = it->saved_i - it->offset;
move_begin(it);
if (temp > it->saved_i)
{
ft_memdel((void**)&it->tmp_buffer);
it->tmp_buffer = ft_strsub(it->line, b, length);
cut_selection(b, a, it);
}
else
{
ft_memdel((void**)&it->tmp_buffer);
it->tmp_buffer = ft_strsub(it->line, a, length);
cut_selection(a, b, it);
}
tputs(tgetstr("cd", NULL), 0, my_putchar);
ft_putstr(it->line);
it->i += ft_strlen(it->line);
}
static void ft_replace_vid(t_it *it, int rewrite)
{
int length;
int temp;
if (rewrite)
{
tputs(tgetstr("mr", NULL), 0, my_putchar);
ft_putchar(it->line[(it->i - return_offset() - 2)]);
tputs(tgetstr("le", NULL), 0, my_putchar);
}
else
{
temp = it->i;
tputs(tgetstr("me", NULL), 0, my_putchar);
length = ft_abs(it->i - it->saved_i) + 1;
ft_move_saved(it);
if (temp > it->saved_i)
{
ft_memdel((void**)&it->tmp_buffer);
it->tmp_buffer = ft_strsub(it->line,
((it->i - return_offset() - 2)), length);
}
else
{
ft_memdel((void**)&it->tmp_buffer);
it->tmp_buffer = ft_strsub(it->line,
((temp - return_offset() - 2)), length);
}
ft_putstr(it->tmp_buffer);
it->i += ft_strlen(it->tmp_buffer);
}
}
char *ft_itoa(int n)
{
char *str;
int len;
int sign;
len = ft_nblen(n);
sign = (n < 0 ? 1 : 0);
str = NULL;
str = (char*)malloc(sizeof(char) * (len + sign + 1));
if (str)
{
str = str + len + sign;
*str = '\0';
if (n == 0)
*--str = '0';
while (n != 0)
{
*--str = ft_abs(n % 10) + 48;
n = n / 10;
}
if (sign)
*--str = '-';
}
return (str);
}
int ft_check(int row, int column) // check if the position is valid or not
{
int i;
i = 1;
while (i <= row - 1)
{
if (board[i] == column)
return (0);
else
if (ft_abs(board[i] - column) == ft_abs(i - row))
return (0);
i++;
}
return (1);
}
char *ft_itoabase(int n, int base, int maj)
{
int psc;
int res;
int i;
char *str;
psc = 0;
i = 0;
res = (n < 0) ? -1 : 1;
n = ft_abs(n);
while (n >= puissance(base, psc))
psc++;
psc--;
str = ft_strnew(psc + 1);
if (n == 0 || base == 0)
str[0] = '0';
res == -1 ? str[i++] = '-' : 0;
while (psc >= 0)
{
str[i] = how_n(&n, base, psc, maj);
psc--;
i++;
}
return (str);
}
int det_paths2(int nant, t_l_data *d, int **paths, int ibck)
{
int tot;
d->i2 = 0;
if (paths[d->i + 1])
d->i2 = ft_abs(paths[d->i][0] - paths[d->i + 1][0]);
ibck = d->i;
d->i = -1;
tot = 0;
while (++d->i <= ibck && d->i2 && nant)
{
d->i = d->i > ibck ? 0 : d->i;
if (nant - d->i2 >= 0)
{
nant -= d->i2;
d->plen[d->i] += d->i2;
}
else if (nant - 1 >= 0)
{
add_to_dplen(tot, d, nant);
}
}
d->i = ibck;
d->i++;
return (nant);
}
char *ft_itoa(int n)
{
int nblen;
int sign;
char *res;
sign = ft_signint(n);
nblen = ft_lenint(n);
res = NULL;
res = (char *)malloc(sizeof(char) * (nblen + sign + 1));
if (res)
{
res = res + nblen + sign;
*res = '\0';
if (!n)
*--res = '0';
while (n != 0)
{
*--res = ft_abs(n % 10) + '0';
n = n / 10;
}
if (sign)
*--res = '-';
}
return (res);
}
/* checking for attacks */
int ft_check(int row, int col)
{
int i;
i = 1;
while (i <= row - 1)
{
if (board[i] == col)
return (0);
else
if (ft_abs(board[i] - col) == ft_abs(i - row))
return (0);
i++;
}
return (1); /* no attacks */
}
int is_pseudo_ordered(t_s *list)
{
int ret;
int tmpval;
int firstval;
t_s *tmp;
ret = 0;
tmp = list;
tmpval = tmp->val;
firstval = tmpval;
while (tmp)
{
while ((tmp->val) <= tmp->n->val)
{
tmp = tmp->n;
if (tmp->n->val == tmpval)
return (l(list) - ret > ret ? ret : -(ft_abs(l(list) - ret)));
}
list = list->n;
tmp = list;
tmpval = tmp->val;
ret++;
if (tmpval == firstval)
return (0);
}
return (ret);
}
void calculating_distances(t_env *e, t_trac_data *d, t_obj *ray)
{
if (d->side == 0)
d->perp_wall_dist = fabs((d->map_x - ray->pos_x
+ (1 - d->step_x) / 2) / ray->dir_x);
else
d->perp_wall_dist = fabs((d->map_y - ray->pos_y
+ (1 - d->step_y) / 2) / ray->dir_y);
d->line_height = ft_abs((int)(SCREEN_HEIGHT / d->perp_wall_dist));
d->wall_type = ft_atoi(e->world[d->map_x][d->map_y]);
if (d->side == 1)
d->wall_x = ray->pos_x
+ ((d->map_y - ray->pos_y
+ (1 - d->step_y) / 2) / ray->dir_y) * ray->dir_x;
else
d->wall_x = ray->pos_y
+ ((d->map_x - ray->pos_x
+ (1 - d->step_x) / 2) / ray->dir_x) * ray->dir_y;
d->wall_x -= floor((d->wall_x));
d->tex_x = (int)(d->wall_x * (double)(TEX_WIDTH));
if (d->side == 0 && ray->dir_x > 0)
d->tex_x = TEX_WIDTH - d->tex_x - 1;
if (d->side == 1 && ray->dir_y < 0)
d->tex_x = TEX_WIDTH - d->tex_x - 1;
}
void calc_door_dist(t_env *e, t_trac_data *d, t_obj *ray)
{
d->door_hit = 1;
if (d->side == 0)
d->perp_door_dist = fabs((d->map_x - ray->pos_x
+ (1 - d->step_x) / 2) / ray->dir_x);
else
d->perp_door_dist = fabs((d->map_y - ray->pos_y
+ (1 - d->step_y) / 2) / ray->dir_y);
d->dline_height = ft_abs((int)(SCREEN_HEIGHT / d->perp_door_dist));
d->door_type = ft_atoi((char *)&e->world[d->map_x][d->map_y][1]);
if (d->side == 1)
d->door_x = ray->pos_x
+ ((d->map_y - ray->pos_y
+ (1 - d->step_y) / 2) / ray->dir_y) * ray->dir_x;
else
d->door_x = ray->pos_y
+ ((d->map_x - ray->pos_x
+ (1 - d->step_x) / 2) / ray->dir_x) * ray->dir_y;
d->door_x -= floor((d->door_x));
d->dtex_x = (int)(d->door_x * (double)(TEX_WIDTH));
if (d->side == 0 && ray->dir_x > 0)
d->dtex_x = TEX_WIDTH - d->dtex_x - 1;
if (d->side == 1 && ray->dir_y < 0)
d->dtex_x = TEX_WIDTH - d->dtex_x - 1;
}
void ft_modulo_key(int *n, const int max, const int dir)
{
if (!dir)
*n = (*n - 1) < 0 ? max - 1 : *n - 1;
if (dir)
*n = ft_abs((*n + 1) % max);
}
