void river_animation_generate(int seed) { /** VARIÁVEIS *****************************************************/ int i = 0; /* Contador */ TStrip new_line; /* Linha gerada */ TStrip first_line; /* 1ª linha gedara */ int zone = Config.zone; /* 'Zona de conforto' */ float flux = Config.flux; /* Fluxo total do rio */ int height = Config.height; /* Altura total do grid */ int length = Config.length; /* Largura total do rio */ int freq = Config.freq_island; /* Distância entre ilhas */ float prob = Config.prob_island; /* Probabilidade de ilhas */ Link new_node; frame_length = length*5; frame_height = 0; /* Zera altura do frame de impressão do rio */ /* Inicializa semente geradora de faixas de terreno * e cria lista para colocá-las: nosso cenário */ tstrip_seed(seed); tstrip_island(prob, freq); river = list_init(height); /** INICIALIZA RIO ************************************************/ /* Primeira linha, que servirá de base para todo o rio */ first_line = tstrip_generate(length, zone, flux, NO_BASE, NULL); new_node = list_new_node(first_line); /* Preenche 'altura' faixas de terreno na lista: */ list_insert(river, new_node); for(i = 1, base = first_line; i < height; i++, base = new_line) { new_line = tstrip_generate(length, zone, flux, base, NULL); new_node = list_new_node(new_line); list_insert(river, new_node); } /** IMPRIME RIO ***************************************************/ gui_window_clear(); list_select(river, HEAD, strip_print); boat_hpos = (int) (Config.length/2.0); boat_vpos = frame_height/5; gui_boat_draw(&boat_hpos, &boat_vpos, 5); gui_window_update(P1.lifes); }
ListNode *list_insert(LinkedList *list, ListNode *node, void *e) { ListNode *new_node; if (list == NULL) return NULL; new_node = list_new_node(e); // Check whether malloc succeeded. // Return NULL in case of failure. if (new_node == NULL) return NULL; // Update tail when inserting after the last element the list if (node == list->tail) list->tail = new_node; if (list->head == NULL) list->head = new_node; // Update pointers to adjacent nodes new_node->prev = node; if (node != NULL) { new_node->next = node->next; if (node->next != NULL) node->next->prev = new_node; // Insert node into existent list. node->next = new_node; } return new_node; }
void list_insert_after(List* self, ADT p_data) { RealList* l_reallist = (RealList*)self; ListNode* l_node; l_node = list_new_node(); l_node->data = addref(ADT, p_data); if ( l_reallist->current ) { if ( l_reallist->current->next ) { l_node->prev = l_reallist->current->next; l_reallist->current->next->prev = l_node; } else {/*if the current node is tail*/ l_reallist->tail = l_node; } l_node->prev = l_reallist->current; l_reallist->current->next = l_node; } else {/*if the self is empty.*/ l_reallist->head = l_node; l_reallist->tail = l_node; } l_reallist->current = l_node; l_reallist->length++; }
void list_insert_front(list *l, struct token *tk) { struct lnode *n = list_new_node(tk); n->next = l->front; if (l->front == NULL) l->last = n; l->front = n; }
static struct lnode *list_insert_after_node(struct lnode *node, struct token *t) { struct lnode *n = list_new_node(t); if (node != NULL) { n->next = node->next; node->next = n; } return n; }
list_node_t* bnf_new_rule(char* name, bnf_node_t* root) { bnf_rule_t* node = (bnf_rule_t*) list_new_node(sizeof(*node), 0); if (node) { node->name = name; node->root = root; } return (list_node_t*) node; }
list_node_t* bnf_new_state(bnf_node_t* state, char* text, list_t mem) { bnf_state_t* node = (bnf_state_t*) list_new_node(sizeof(*node), 0); if (node) { node->state = state; node->text = text; node->mem = mem; } return (list_node_t*) node; }
static int bnf_call_visit(bnf_state_t* state, bnf_visitor_t* visitor) { bnf_call_t* call = (bnf_call_t*) state->state; bnf_rule_t* rule = bnf_visitor_find_rule(visitor, call->rule); bnf_rule_exit_t* rule_exit; if (rule) { rule_exit = (bnf_rule_exit_t*) list_new_node(sizeof(*rule_exit), state->mem); rule_exit->caller = state->state; bnf_visitor_visit(visitor, rule->root, state->text, (list_node_t*) rule_exit); } return 0; }
int list_insert(list_t L, list_iter_t pos, element_t x) { list_node_t node = list_new_node(x); if (NULL == L || NULL == pos || NULL == node) return RESULT_FAIL; node->prev = ((list_node_t)pos)->prev; node->next = ((list_node_t)pos); ((list_node_t)pos)->prev->next = node; ((list_node_t)pos)->prev = node; ++L->size; return RESULT_OK; }
void list_append(list_t* lst, void* data) { list_node_t *node = list_new_node(); node->data = data; if (lst->last) { /* we have last item, just append the new one */ lst->last->next = node; node->prev = lst->last; lst->last = node; } else { /* no items in the list */ lst->last = node; lst->head = node; } lst->size++; }
/// create a new map iterator positioned on the mininum node. MapIter map_iter_new (Map *m, void *pkey, void *pvalue) { if (root(m) == NULL) // empty map return NULL; MapIter iter = obj_new(MapIterStruct,map_iter_free); iter->map = m; iter->node = (PEntry)root(m); iter->vstack = list_new_node(false); iter->pkey = (void**)pkey; iter->pvalue = (void**)pvalue; go_down_left(iter); iter->key = iter->node->key; iter->value = map_value_data(m,iter->node); if (iter->pkey) { *iter->pkey = iter->key; *iter->pvalue = iter->value; } return iter; }
ListNode *list_unshift(LinkedList *list, void *e) { ListNode *node; if (list == NULL) return NULL; node = list_new_node(e); if (node == NULL) return NULL; node->next = list->head; if (list->head) list->head->prev = node; list->head = node; if (list->tail == NULL) list->tail = node; return node; }