Пример #1
0
/* fonction d'initialisation de notre chaine avec les 258 premiers elements de base
 * et declaration du tableau de pointeur sur un sous arbre-naire du dictionnaire
 * indexe par les codes */
arbre_n* init(){
	arbre_n* ptr_tmp;
	chaine_octet* chaine_tmp = (chaine_octet*) malloc(sizeof(chaine_octet));
	chaine_tmp->next = NULL;
	chaine_tmp->octet = 0;
	/* initialisation du premier element */
	ptr_arbre_n = create_elem(0, chaine_tmp, 0);
	tab_arbre[0] = ptr_arbre_n;
	
	ptr_tmp = ptr_arbre_n;
	for (int i=1;i<256;i++){
		chaine_tmp = (chaine_octet*) malloc(sizeof(chaine_octet));
		chaine_tmp->next = NULL;
		chaine_tmp->octet = i;
		ptr_tmp->freres = create_elem(i, chaine_tmp, 0); // dernier element de la chaine pointe sur Nil
		ptr_tmp = ptr_tmp->freres;
		tab_arbre[i] = ptr_tmp; // on met le pointeur sur l'element i dans tab[i]
	}
	
	ptr_tmp->freres = create_elem(256, NULL, 0); // dernier element de la chaine pointe sur Nil
	ptr_tmp = ptr_tmp->freres;
	tab_arbre[256] = ptr_tmp;
	ptr_tmp->freres = create_elem(257, NULL, 0); // dernier element de la chaine pointe sur Nil
	ptr_tmp = ptr_tmp->freres;
	tab_arbre[257] = ptr_tmp;
	ptr_tmp->freres = create_elem(258, NULL, 0); // dernier element de la chaine pointe sur Nil
	tab_arbre[258] = ptr_tmp->freres;

	nb_elem = 259;

	return ptr_arbre_n;
}
Пример #2
0
t_env			*add_elem_end(t_env *list, char *name, char *arg)
{
	t_env	*tmp;

	tmp = list;
	if (!list)
		return (create_elem(name, arg));
	while (list->next)
		list = list->next;
	list->next = create_elem(name, arg);
	return (tmp);
}
Пример #3
0
int					select_in_box(t_data *data, t_selection *s)
{
	t_elem			*elem;
	t_elem			*new_elem;

	elem = data->wizards->head;
	while (elem)
	{
		if ((elem->wizard->cx > s->sx
			&& elem->wizard->cx < s->cx
			&& elem->wizard->cy > s->sy
			&& elem->wizard->cy < s->cy) ||
			(elem->wizard->cx < s->sx
			&& elem->wizard->cx > s->cx
			&& elem->wizard->cy < s->sy
			&& elem->wizard->cy > s->cy) ||
			(elem->wizard->cx < s->sx
			&& elem->wizard->cx > s->cx
			&& elem->wizard->cy > s->sy
			&& elem->wizard->cy < s->cy) ||
			(elem->wizard->cx > s->sx
			&& elem->wizard->cx < s->cx
			&& elem->wizard->cy < s->sy
			&& elem->wizard->cy > s->cy))
		{
			if (!(new_elem = create_elem(TYPE_NONE)))
				return (0);
			new_elem->wizard = elem->wizard;
			if (!(data->selected = list_push_back(data->selected, new_elem)))
				return (0);
		}
		elem = elem->next;
	}
	return (1);
}
Пример #4
0
void LexList:: put_lex (const Lex & l)
{
    ListElem * cur = first;

    if ( first == 0 ) {
        first = create_elem (l);
    }
    else {
        ListElem * prev;
        while ( cur != 0 ) {
            prev = cur;
            cur = cur->next;
        }
        cur = create_elem (l);
        prev->next = cur;
    }
}
Пример #5
0
t_file	*create_real_list(t_file *list, t_file *list2)
{
	if (ft_strequ(list2->path, "") && ft_strequ(list2->name, ""))
	{
		free(list2->path);
		list2->path = ft_strdup("/");
	}
	if (!list)
	{
		list = create_elem(list2->path, NULL, list2->name);
		if (list)
			list->av_name = ft_strdup(list2->av_name);
	}
	else
		add_elem_end_av(list2->path, list, list2->name, list2->av_name);
	return (list);
}
Пример #6
0
/* fonction d'insertion d'un code dans la liste
 * insere de facon a conserver l'ordre alphabeteique*/
void insert (chaine_octet* prefixe, unsigned int suffixe){
	arbre_n *ptr_parent, *ptr_new, *ptr_cour, *ptr_suiv;
	int i=0;
	
	ptr_parent = search(prefixe);
	//printf("------ ");
	//afficher_octet(prefixe);
	//printf(" ------");
	chaine_octet* d = cat_str_char(prefixe, suffixe);
	//afficher_octet(d);
	ptr_new = create_elem(nb_elem, d, ptr_parent->code);
	
	/* on cherche l'emplacement exact du mot parmis les enfants du noeud qu'on vient de trouve */
	if (ptr_parent->enfant == NULL){
		ptr_parent->enfant = ptr_new;
	}
	else{ // on cherche la place dans l'ordre alphabetique
		ptr_cour = ptr_parent->enfant;
		ptr_suiv = ptr_cour->freres;
		
		/* les mots utilises pour chercher sont de longueur minimale 3 : ascii + car + '\0' */
		while ((ptr_suiv != NULL) && (cmp_chaine_octet(ptr_new->mot, ptr_cour->mot)>0)){
			ptr_cour = ptr_suiv;
			ptr_suiv = ptr_suiv->freres;
		}
		
		if (ptr_cour == ptr_parent->enfant && (cmp_chaine_octet(ptr_new->mot, ptr_cour->mot)<0)){ // insertion en tete
			ptr_parent->enfant = ptr_new;
			ptr_new->freres = ptr_cour;
		}
		else { //insertion diverse (en queue ou au milieu c'est pareil
			ptr_new->freres = ptr_suiv;
			ptr_cour->freres = ptr_new;
		}
	}
	
	tab_arbre[nb_elem] = ptr_new; //mise a jour du tableau de pointeur
	nb_elem++;
}
Пример #7
0
void pack_trolley(tree *t, list *l, char *ware_name, int amount)
{
  if(amount <= 0) return;

  char *key = make_key(ware_name);
  elem *e = get_elem_in_list_DB(l, key);

  if(e)
    {
      incr_amount(e, amount);

      node *n = get_node_in_tree(t, key);
      ware *w = (ware*)n->content;
      int tot_price = (w->price) * amount;

      incr_trolley_price(l, tot_price);
    }
  else
    {
      elem *new_elem = create_elem();
      trolley *new_trolley = create_trolley();
      
      new_elem->box = new_trolley;
      
      new_trolley->key = strdup(key);
      new_trolley->amount = amount;

      insert_elem_in_list(l, new_elem);

      node *n = get_node_in_tree(t, key);
      ware *w = (ware*)n->content;
      int tot_price = (w->price) * amount;
      
      incr_trolley_price(l, tot_price);
    }

  if(key) free(key);
}
Пример #8
0
t_list			*get_env_in_list(char **mainenv)
{
  char			**tmp;
  t_env			*env;
  t_list		*list;

  list = NULL;
  env = NULL;
  if ((env = malloc(sizeof(t_env))))
    {
      while (*mainenv)
	{
	  tmp = my_str_to_wordtab(*mainenv, '=');
	  env->scope = tmp[0];
	  env->value = tmp[1];
	  printf("tmp1 = %s, tmp2 = %s\n", tmp[0], tmp[1]);
	  if ((list = add_elem_to_list(list, create_elem(env))) == NULL)
	    return (NULL);
	  mainenv++;
	}
    }
  return (list);
}
Пример #9
0
int					main_loop(t_data *data)
{
	SDL_Event	event;
	int			quit = 0;
	t_elem		*elem;
	t_elem		*new_elem;

	while (!quit)
	{
		while (SDL_PollEvent(&event))
		{
			if (event.type == SDL_QUIT)
				quit = 1;
			if (event.type == SDL_KEYDOWN)
			{
				if (event.key.keysym.scancode == SDL_SCANCODE_ESCAPE)
					quit = 1;
				if (event.key.keysym.scancode == SDL_SCANCODE_UP)
					data->camera.y -= data->camera.speed;
				if (event.key.keysym.scancode == SDL_SCANCODE_DOWN)
					data->camera.y += data->camera.speed;
				if (event.key.keysym.scancode == SDL_SCANCODE_RIGHT)
					data->camera.x += data->camera.speed;
				if (event.key.keysym.scancode == SDL_SCANCODE_LEFT)
					data->camera.x -= data->camera.speed;
				if (event.key.keysym.scancode == SDL_SCANCODE_LSHIFT)
					data->shift = 1;
				if (event.key.keysym.scancode == SDL_SCANCODE_LCTRL)
					data->ctrl = 1;
			}
			if (event.type == SDL_KEYUP)
			{
				if (event.key.keysym.scancode == SDL_SCANCODE_LSHIFT)
					data->shift = 0;
				if (event.key.keysym.scancode == SDL_SCANCODE_LCTRL)
					data->ctrl = 0;
			}
			if (event.type == SDL_MOUSEMOTION)
			{
				data->mouse_x = event.motion.x;
				data->mouse_y = event.motion.y;
			}
			if (event.type == SDL_MOUSEBUTTONDOWN)
			{
				if (event.button.button == SDL_BUTTON_LEFT)
				{
					if (!data->shift && !list_clear(data->selected))
						return (0);
					elem = data->wizards->head;
					while (elem)
					{
						if (mouse_in_hitcl(data->mouse_x + data->camera.x, data->mouse_y + data->camera.y, &elem->wizard->hitcl))
						{
							if (!(new_elem = create_elem(TYPE_NONE)))
								return (0);
							new_elem->wizard = elem->wizard;
							if (!(data->selected = list_push_back(data->selected, new_elem)))
								return (0);
						}
						elem = elem->next;
					}
					data->selection.status = 1;
					data->selection.sx = data->mouse_x + data->camera.x;
					data->selection.sy = data->mouse_y + data->camera.y;
					data->selection.cx = data->selection.sx;
					data->selection.cy = data->selection.sy;
				}
				if (event.button.button == SDL_BUTTON_RIGHT)
				{
					if (data->selected->size > 0)
					{
						if (!new_wizard_formation(data->selected, data->mouse_x + data->camera.x, data->mouse_y + data->camera.y))
							return (0);
					}
/*					elem = data->selected->head;
					while (elem)
					{
						elem->wizard->vdest.x = data->mouse_x + data->camera.x;
						elem->wizard->vdest.y = data->mouse_y + data->camera.y;
						elem->wizard->move = 1;
						if (!set_new_wizard_angle(elem->wizard, elem->wizard->vdest.x, elem->wizard->vdest.y))
							return (0);
						elem = elem->next;
					}*/
				}
			}
			if (event.type == SDL_MOUSEBUTTONUP)
			{
				if (event.button.button == SDL_BUTTON_LEFT)
				{
					data->selection.status = 0;
					if (!select_in_box(data, &data->selection))
						return (0);
				}
			}
		}

		if (!update_camera(data))
			return (0);
		update_selection_box(data, &data->selection);
		elem = data->wizards->head;
		while (elem)
		{
			if (!update_wizard(elem->wizard))
				return (0);
			update_wizard_collision(data->wizards, elem->wizard);
			elem = elem->next;
		}

		render(data);

		SDL_GL_SwapWindow(data->window);
		SDL_Delay(1000 / 60);
	}
	return (1);
}