void cfade_set(GtkWidget *w, struct pack *p)
{
struct gchan *tmp1, *tmp2;
float value;
gchar tmp[4];
// func(_("cfade_set get data for pos %u"), p->id);
tmp1 = (struct gchan *) list_get_data(listachan, 0, p->id);
tmp2 = (struct gchan *) list_get_data(listachan, 0, p->id+1);
value = GTK_ADJUSTMENT(p->adj)->value;
mixer->crossfade(tmp1->idx-1, 1.0-value, tmp2->idx-1, value);
g_signal_handler_block(G_OBJECT(tmp1->adjvol), tmp1->volid);
g_signal_handler_block(G_OBJECT(tmp2->adjvol), tmp2->volid);
gtk_adjustment_set_value(GTK_ADJUSTMENT(tmp1->adjvol), value);
snprintf(tmp, sizeof(tmp), "%d", (int)
((1.0-GTK_ADJUSTMENT(tmp1->adjvol)->value)*100));
gtk_label_set_text(GTK_LABEL(tmp1->vol_lab), (gchar *) tmp);
gtk_adjustment_set_value(GTK_ADJUSTMENT(tmp2->adjvol),
1.0-value);
snprintf(tmp, sizeof(tmp), "%d", (int)
((1.0-GTK_ADJUSTMENT(tmp2->adjvol)->value)*100));
gtk_label_set_text(GTK_LABEL(tmp2->vol_lab), (gchar *) tmp);
g_signal_handler_unblock(G_OBJECT(tmp1->adjvol), tmp1->volid);
g_signal_handler_unblock(G_OBJECT(tmp2->adjvol), tmp2->volid);
}
void*
multiset_del_item (multiset_t* mset, void* item)
{
void* ret;
list_t** liter;
list_t* ltmp;
set_t* set;
ret = NULL;
set = (set_t*)mset;
if(set && set->cmp) {
liter = &(set->items);
while(*liter) {
if(!set->cmp((list_get_data(item_t, (*liter)))->item, item))
break;
else
liter = &((*liter)->next);
}
if(*liter) {
ret = (list_get_data(item_t, (*liter)))->item;
if((list_get_data(item_t, (*liter)))->size > 1) {
(list_get_data(item_t, (*liter)))->size--;
} else {
ltmp = *liter;
*liter = list_next(*liter);
XFREE(ltmp);
mset->dorder--;
}
set->imark = NULL;
set->order--;
mset->step = 0;
}
} else warning("null pointer");
return ret;
}
void*
multiset_add_item (multiset_t* mset, void* item)
{
void* ret;
int cmp;
list_t** liter;
set_t* set;
ret = NULL;
set = (set_t*)mset;
if(set && set->cmp) {
cmp = 1;
liter = &(set->items);
while(*liter) {
cmp = set->cmp((list_get_data(item_t, (*liter)))->item, item);
if(cmp >= 0)
break;
else
liter = &((*liter)->next);
}
if(!cmp) {
(list_get_data(item_t, (*liter)))->size++;
ret = (list_get_data(item_t, (*liter)))->item;
} else {
*liter = list_add_data(XMALLOC(list_t, 1), *liter, XMALLOC(item_t, 1));
(list_get_data(item_t, (*liter)))->item = item;
(list_get_data(item_t, (*liter)))->size = 1;
mset->dorder++;
ret = item;
}
set->imark = NULL;
set->order++;
mset->step = 0;
} else warning("null pointer");
return ret;
}
void gcb_set_talk(GtkWidget *w)
{
unsigned int i;
float voltmp[MAX_CHANNELS];
struct gchan *c = NULL;
if(GTK_TOGGLE_BUTTON(w)->active) {
for(i = 0; i < MAX_CHANNELS; i++) {
c = (struct gchan *) list_get_data(listachan, i+1, 0);
if(c) {
storevol[i]= GTK_ADJUSTMENT(c->adjvol)->value;
if(storevol[i] < TALK_VOLUME)
voltmp[i]=0.0;
else
voltmp[i]= TALK_VOLUME;
gtk_adjustment_set_value(GTK_ADJUSTMENT(c->adjvol), voltmp[i]);
}
}
mixer->set_all_volumes(&voltmp[0]);
}
else {
for(i = 0; i < MAX_CHANNELS; i++) {
c = (struct gchan *) list_get_data(listachan, i+1, 0);
if(c)
gtk_adjustment_set_value(GTK_ADJUSTMENT(c->adjvol),
storevol[i]);
}
mixer->set_all_volumes(&storevol[0]);
}
}
struct bomb* search_bomb(struct map* map, int x, int y, int state) {
struct list* bList = map_get_bombs(map);
while(bList != NULL) {
if(list_get_x(bList) == x && list_get_y(bList) == y) {
struct bomb* bomb = list_get_data(bList);
if(bomb->state == state)
return list_get_data(bList);
}
bList = list_get_next(bList);
}
return NULL;
}
multiset_t*
multiset_copy (multiset_t* mset)
{
size_t iter;
multiset_t* mscp;
item_t* item;
list_t* liter;
set_t* set;
void* obj;
mscp = NULL;
set = (set_t*)mset;
if(set && set->cmp && set->cp) {
mscp = XMALLOC(multiset_t, 1);
init_multiset(mscp);
multiset_cmp_function(mscp, set->cmp);
multiset_cp_function(mscp, set->cp);
liter = set->items;
while(liter) {
item = list_get_data(item_t, liter);
obj = set->cp(item->item);
for(iter = 0; iter < item->size; iter++)
multiset_add_item(mscp, obj);
liter = list_next(liter);
}
} else warning("null pointer");
return mscp;
}
bool gtkgui_sel_playlist(unsigned int chan, int row)
{
struct gchan *c = NULL;
GtkTreeModel *model = NULL;
GtkTreeSelection *selection = NULL;
GtkTreeIter iter;
GtkTreePath *path = NULL;
c = (struct gchan *) list_get_data(listachan, chan+1, 0);
if(!c) return false;
if(!c->playmode)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(c->play), FALSE);
gtk_entry_set_text(GTK_ENTRY(c->ptime), "00:00:00");
gtk_adjustment_set_value(GTK_ADJUSTMENT(c->adjprog), 0.0);
model = gtk_tree_view_get_model(GTK_TREE_VIEW(c->tree));
if(!model) return false;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(c->tree));
if(!selection) return false;
gtk_tree_selection_get_selected(selection, NULL, &iter);
path = gtk_tree_model_get_path(model, &iter);
if(!path) return false;
gtk_tree_selection_select_path(selection, path);
gtk_tree_path_free(path);
return true;
}
list_t * list_delete(list_t *li, void *data)
{
if(!li)
return NULL;
list_t *i = li;
if(data) {
i = list_get_first(li);
while(i) {
if(data == list_get_data(i))
break;
i = i->next;
}
if(!i)
return li;
}
list_t *r = NULL;
if(i->next) {
i->next->prev = i->prev;
r = i->next;
}
if(i->prev) {
i->prev->next = i->next;
r = i->prev;
}
free(i);
return r;
}
void
multiset_rearrange (multiset_t* mset)
{
size_t iter;
list_t* liter;
list_t* ltmp;
cmp_t cmp;
cp_t cp;
set_t* set;
item_t* item;
set = (set_t*)mset;
if(set && set->cmp) {
liter = set->items;
cmp = set->cmp;
cp = set->cp;
init_multiset(mset);
multiset_cmp_function(mset, cmp);
multiset_cp_function(mset, cp);
while(liter) {
ltmp = liter;
liter = list_next(liter);
item = list_get_data(item_t, ltmp);
for(iter = 0; iter < item->size; iter++)
multiset_add_item(mset, item->item);
XFREE(item);
XFREE(ltmp);
}
} else warning ("null pointer");
}
void jabber_mam_process(JabberStream *js, const char* after)
{
if (!js->mam)
return;
if (js->mam->current && js->mam->current->completed) {
free(js->mam->current->start);
free(js->mam->current->end);
free(js->mam->current->with);
memset(js->mam->last_timestamp, 0, 32);
free(js->mam->current);
js->mam->current = NULL;
}
if (!js->mam->current) {
list_t *queue_item = list_get_first(js->mam->queue);
if (queue_item) {
js->mam->queue = list_delete(js->mam->queue, queue_item);
js->mam->current = list_get_data(queue_item);
js->mam->queue = list_get_next(js->mam->queue);
}
}
if (js->mam->current)
jabber_mam_request(js, after);
}
size_t
multiset_search (multiset_t* mset, void* item)
{
size_t ret;
list_t* liter;
set_t* set;
ret = 0;
set = (set_t*)mset;
if(set && set->cmp && item) {
liter = set->items;
while(liter && set->cmp((list_get_data(item_t, liter))->item, item))
liter = list_next(liter);
if(liter)
ret = (list_get_data(item_t, liter))->size;
} else warning ("null pointer");
return ret;
}
bool gtkgui_set_lcd(unsigned int chan, char *testo)
{
struct gchan *c;
c=(struct gchan *)list_get_data(listachan, chan+1, 0);
if(c) {
gtk_entry_set_text(GTK_ENTRY(c->ptime), (gchar *) testo);
return true;
}
return false;
}
const Tuple* list_get_tuple(const List* list, ListElem** idxp)
{
ListData* data;
assert(list_is_valid(list));
assert(list->type == LIST_TUPLE);
assert(idxp != NULL);
data = list_get_data(list, idxp);
return (data == NULL) ? TUPLE_NULL : data->tuple;
}
const Elem* list_get_elem(const List* list, ListElem** idxp)
{
ListData* data;
assert(list_is_valid(list));
assert(list->type == LIST_ELEM);
assert(idxp != NULL);
data = list_get_data(list, idxp);
return (data == NULL) ? ELEM_NULL : data->elem;
}
const Entry* list_get_entry(const List* list, ListElem** idxp)
{
ListData* data;
assert(list_is_valid(list));
assert(list->type == LIST_ENTRY);
assert(idxp != NULL);
data = list_get_data(list, idxp);
return (data == NULL) ? ENTRY_NULL : data->entry;
}
const List* list_get_list(const List* list, ListElem** idxp)
{
ListData* data;
assert(list_is_valid(list));
assert(list->type == LIST_LIST);
assert(idxp != NULL);
data = list_get_data(list, idxp);
return (data == NULL) ? LIST_NULL : data->list;
}
bool gtkgui_set_pos(unsigned int chan, float position)
{
struct gchan *c;
c=(struct gchan *)list_get_data(listachan, chan+1, 0);
if(c) {
gtk_adjustment_set_value(GTK_ADJUSTMENT(c->adjprog), position);
return true;
}
return false;
}
void bomb_display(struct game* game, struct map* map) {
assert(game);
assert(map);
struct list* bList = map_get_bombs(map);
struct bomb* bomb = NULL;
int x;
int y;
if(bList != NULL){ // if there is at least one bomb
// Bomb Display And Event
while(bList != NULL) { // For each bombs
bomb = list_get_data(bList);
if(!(bomb->state)){ // bomb who's waiting
window_display_sprite(
sprite_get_bombs(),
sprite_get_rect_bomb_anim(7, ((bomb->anim)/4)%4),
list_get_x(bList) * SIZE_BLOC, list_get_y(bList) * SIZE_BLOC);
}
else { // bomb who's exploding
//printf("anim: %d, cal: %d\n", bomb->anim, bomb->anim/4);
// Center
window_display_sprite(
sprite_get_bombs(),
sprite_get_rect_bomb_anim(0, bomb->anim / 4),
list_get_x(bList) * SIZE_BLOC, list_get_y(bList) * SIZE_BLOC);
// Event
bomb_event(game, map, bomb, list_get_x(bList), list_get_y(bList));
for(int d = 0; d < 4; d++){ // 0: SOUTH, 1: NORTH, 2: WEST, 3: EAST
for(int r = 1; r <= bomb->range_dir[d]; r++){
/* d |dx |dy */ x = list_get_x(bList) + r * ((d / 2) * ((d * 2) - 5)); // + r * dx
/* 0 | 0 | 1 */ y = list_get_y(bList) + r * ((d - 3) / 2 * ((d * 2) - 1)); // + r * dy
/* 1 | 0 |-1 */ if(list_find(map_get_bombs(map), x, y) == NULL) {
/* 2 |-1 | 0 */ if(r != bomb->range) {
/* 3 | 1 | 0 */ window_display_sprite(sprite_get_bombs(), sprite_get_rect_bomb_anim(d/2 +1, bomb->anim/4), x * SIZE_BLOC, y * SIZE_BLOC);
}
else {
window_display_sprite(sprite_get_bombs(), sprite_get_rect_bomb_anim(d+3, bomb->anim/4), x * SIZE_BLOC, y * SIZE_BLOC);
}
}
// Event
bomb_event(game, map, bomb, x, y);
} // end for (range)
} // end for (direction)
}
bList = list_get_next(bList);
}
}
}
int conexionPersonaje(int iSocketComunicacion, fd_set* socketsOrquestador, char* sPayload) {
tHandshakePers* pHandshakePers;
pHandshakePers = deserializarHandshakePers(sPayload);
free(sPayload);
int iIndiceNivel;
log_info(logger, "Se conectó el personaje %c pidiendo el nivel '%s'", pHandshakePers->simbolo, pHandshakePers->nombreNivel);
pthread_mutex_lock(&mtxlNiveles);
iIndiceNivel = existeNivel(listaNiveles, pHandshakePers->nombreNivel);
if (iIndiceNivel >= 0) {
tNivel *pNivelPedido;
pNivelPedido = list_get_data(listaNiveles, iIndiceNivel);
pthread_mutex_unlock(&mtxlNiveles);
if (pNivelPedido == NULL) {
log_error(logger, "Saco mal el nivel: Puntero en NULL");
sendConnectionFail(iSocketComunicacion, PL_NIVEL_INEXISTENTE, "No se encontro el nivel pedido");
}
avisoConexionANivel(pNivelPedido->socket, sPayload, pHandshakePers->simbolo);
add_new_personaje_in_plataforma(pHandshakePers->simbolo);
agregarPersonaje(pNivelPedido, pHandshakePers->simbolo, iSocketComunicacion);
free(pHandshakePers->nombreNivel);
free(pHandshakePers);
delegarConexion(&pNivelPedido->masterfds, socketsOrquestador, iSocketComunicacion, &pNivelPedido->maxSock);
pthread_cond_signal(&(pNivelPedido->hayPersonajes));
tPaquete pkgHandshake;
pkgHandshake.type = PL_HANDSHAKE;
pkgHandshake.length = 0;
// Le contesto el handshake
enviarPaquete(iSocketComunicacion, &pkgHandshake, logger, "Handshake de la plataforma al personaje");
return EXIT_SUCCESS;
} else {
pthread_mutex_unlock(&mtxlNiveles);
log_error(logger, "El nivel solicitado no se encuentra conectado a la plataforma");
sendConnectionFail(iSocketComunicacion, PL_NIVEL_INEXISTENTE, "No se encontro el nivel pedido");
free(pHandshakePers->nombreNivel);
free(pHandshakePers);
return EXIT_FAILURE;
}
}
bool gtkgui_set_lcd(unsigned int chan, char *testo)
{
struct gchan *c;
c=(struct gchan *)list_get_data(listachan, chan+1, 0);
/* c=gcb_findch(chan+1, NOPOS);*/
if(c) {
// gdk_threads_enter();
gtk_entry_set_text(GTK_ENTRY(c->ptime), (gchar *) testo);
// gdk_threads_leave();
return true;
}
return false;
}
void
multiset_for_each(multiset_t* mset, for_each_t fef)
{
list_t* liter;
set_t* set;
set = (set_t*)mset;
if(set && fef) {
liter = set->items;
while(liter) {
fef((list_get_data(item_t, liter))->item);
liter = list_next(liter);
}
} else warning("null pointer");
}
void gcb_add_file(GtkWidget *w, GtkFileSelection *fw)
{
unsigned int idx = 0;
struct gchan *o;
gchar **cist;
//const gchar *cist;
gint i;
GtkTreeSelection *select;
bool res=false;
cist=NULL;
idx= *(unsigned int *) g_object_get_data(G_OBJECT(GTK_FILE_SELECTION(fw)->ok_button), "chan");
func(_("GTK_GUI::gcb_add_file : idx %u"), idx);
cist = gtk_file_selection_get_selections(GTK_FILE_SELECTION(fw));
//cist = gtk_file_selection_get_filename(GTK_FILE_SELECTION(fw));
o = (struct gchan *) list_get_data(listachan, idx, 0);
/*if(!cist[0]) {
win_warning(_("You have to insert a filename!!"));
return;
}*/
/* muse core'll add file into GtkTreeModel */
for(i = 0; cist[i] != NULL; i++) {
res = mixer->add_to_playlist(idx-1, cist[i]);
//res = mixer->add_to_playlist(idx-1, cist);
if(!res) {
func(_("gcb_add_file:: mixer->add_to_playlist(%u, %s) failed"),
idx-1, cist[i]);
win_error(_("Problem adding file :\\"));
} else {
//func(_("Added %s"), cist[i]);
/* saves last directory visited */
if(pathfile)
g_free(pathfile);
pathfile = g_strdup(cist[i]);
//pathfile = g_strdup(cist);
int i = strlen(pathfile);
while(pathfile[i] != '/') i--;
pathfile[i+1]= '\0';
}
}
g_strfreev(cist);
select = gtk_tree_view_get_selection(GTK_TREE_VIEW(o->tree));
gtk_tree_selection_unselect_all(select);
gtk_widget_destroy((GtkWidget *)fw);
}
bool gtkgui_add_into_pl(unsigned int chan, char *file)
{
struct gchan *c;
char *cist[1];
c=(struct gchan *)list_get_data(listachan, chan+1, 0);
/* o=gcb_findch(chan+1, NOPOS); */
if(!c) return false;
cist[0] = file;
int riga = gtk_clist_append(GTK_CLIST(c->lista), cist);
if(!riga) gtk_clist_select_row(GTK_CLIST(c->lista), 0, 0);
return true;
}
void jabber_mam_clear(mam_t *mam)
{
if (mam)
return;
list_t *queue_item = list_get_first(mam->queue);
while (queue_item) {
mam_item_t *mam_item = list_get_data(queue_item);
free(mam_item->start);
free(mam_item->end);
free(mam_item->with);
free(mam_item);
queue_item = list_get_next(queue_item);
}
}
void
free_multiset (multiset_t* mset)
{
item_t* item;
set_t* set;
list_t* liter;
set = (set_t*)mset;
if(set) {
while(set->items) {
liter = set->items;
set->items = list_next(set->items);
item = list_get_data(item_t, liter);
XFREE(item);
XFREE(liter);
}
XFREE(set);
} else warning("null pointer");
}
void bomb_explo_init(struct map* map, struct list* bList){ // When the bomb explode, used once per bomb
assert(bList);
struct bomb* bomb = list_get_data(bList);
int cellType = 0;
int rt = 0;
int x;
int y;
if(map_get_cell_type(map, list_get_x(bList), list_get_y(bList)) == CELL_BOMB)
map_set_cell_type(map, list_get_x(bList), list_get_y(bList), CELL_EMPTY);
for(int d = 0; d < 4; d++){ // 0: NORTH, 1: SOUTH, 2: WEST, 3: EAST
for(int r = 1; r <= bomb->range; r++){
x = list_get_x(bList) + r * ((d / 2) * ((d * 2) - 5)); // + r * dx
y = list_get_y(bList) + r * ((d - 3) / 2 * ((d * 2) - 1)); // + r * dy
//printf("\nd: %d, x: %d, y: %d, dx: %d, dy: %d", d, x, y, ((d - 3) / 2 * ((d * 2) - 1)), ((d / 2) * ((d * 2) - 5)));
if(0 <= x && x < map_get_width(map) && 0 <= y && y < map_get_height(map)) { // if in map
rt = r;
cellType = map_get_cell_type(map, x, y);
switch(cellType){ // Looking for something stopping the fire
case CELL_GOAL:
case CELL_SCENERY:
case CELL_KEY:
rt--;
/* no break */
case CELL_CASE:
case CELL_BONUS:
case CELL_BOMB:
r = bomb->range + 1;
break;
default:
break;
} // end switch
} // end if in map
} // end range
// Set range_dir
bomb->range_dir[d]= rt;
rt = 0;
}
}
void bomb_update(struct map* map) {
assert(map);
struct list* bList = map_get_bombs(map);
struct bomb* bomb = NULL;
int reload = 0;
while(bList != NULL) {
bomb = list_get_data(bList);
if(!(bomb->state)) { // If the bomb has not exploded yet we display the animation of the bomb...
// Bomb's animation
if(bomb->anim < 4 * DEFAULT_GAME_FPS)
bomb->anim++;
else {
bomb->state = 1;
bomb_explo_init(map, bList);
player_inc_nb_bomb(bomb->player);
bomb->anim = 0;
}
}
else{ // The bomb is exploding
if(bomb->anim >= 1 * DEFAULT_GAME_FPS) {
bomb_free(map, bList);
reload = 1;
}
else {
//if(bomb->anim >= 1 * DEFAULT_GAME_FPS)
bomb->anim++;
}
}
if(reload){
bList = map_get_bombs(map);
reload = 0;
}
else {
bList = list_get_next(bList);
}
} // end while
}
bool gtkgui_sel_playlist(unsigned int chan, int row)
{
struct gchan *c;
c=(struct gchan *)list_get_data(listachan, chan+1, 0);
/* o=gcb_findch(chan+1, NOPOS); */
if(!c) return false;
// gdk_threads_enter();
gtk_signal_handler_block(GTK_OBJECT(c->lista), blockid[chan+1]);
gtk_clist_select_row(GTK_CLIST(c->lista), row-1, 0);
gtk_signal_handler_unblock(GTK_OBJECT(c->lista), blockid[chan+1]);
gtk_entry_set_text(GTK_ENTRY(c->ptime), "00:00");
gtk_adjustment_set_value(GTK_ADJUSTMENT(c->adjprog), 0.0);
if(!c->playmode)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(c->play), FALSE);
// gdk_threads_leave();
return true;
}
void*
multiset_next_next_item (multiset_t* mset)
{
void* ret;
set_t* set;
item_t* item;
ret = NULL;
set = (set_t*)mset;
if(set) {
if(!set->imark) {
set->imark = set->items;
mset->step = 0;
}
if(set->imark) {
item = list_get_data(item_t, set->imark);
ret = item->item;
mset->step = 0;
set->imark = list_next(set->imark);
}
} else warning ("null pointer");
return ret;
}
bool gtkgui_add_into_pl(unsigned int chan, char *file)
{
struct gchan *c;
GtkTreeIter iter;
GtkTreeModel *model;
gchar *fileutf8;
c = (struct gchan *) list_get_data(listachan, chan+1, 0);
if(!c) return false;
fileutf8 = g_filename_to_utf8(file, -1, NULL, NULL, NULL);
func(_("I'm adding %s"), fileutf8);
model = gtk_tree_view_get_model(GTK_TREE_VIEW(c->tree));
gtk_list_store_append(GTK_LIST_STORE(model), &iter);
gtk_list_store_set(GTK_LIST_STORE(model), &iter,
TITLE, fileutf8,
-1);
return true;
}
