Пример #1
0
void
move_curitem(int direction)
{
        list_item tmp;

        if(curitem < 0 || curitem > last_item())
                return;

	tmp = item_create();
	item_copy(tmp, db_item_get(curitem));

	switch(direction) {
		case MOVE_ITEM_UP:
			if( curitem < 1 )
				goto out_move;
			item_copy(db_item_get(curitem),
					db_item_get(curitem - 1));
			item_copy(db_item_get(curitem-1), tmp);
			scroll_up();
			break;

		case MOVE_ITEM_DOWN:
			if(curitem >= last_item())
				goto out_move;
			item_copy(db_item_get(curitem),
					db_item_get(curitem + 1));
			item_copy(db_item_get(curitem + 1), tmp);
			scroll_down();
			break;
	}

out_move:
	item_free(&tmp);
}
Пример #2
0
int
parse_database(FILE *in)
{
        char *line = NULL;
	char *tmp;
	int sec=0, field;
	list_item item;

	item = item_create();

	for(;;) {
		line = getaline(in);
		if(feof(in)) {
			if(item[field_id(NAME)] && sec) {
				add_item2database(item);
			} else {
				item_empty(item);
			}
			break;
		}

		if(!*line || *line == '\n' || *line == '#') {
			goto next;
		} else if(*line == '[') {
			if(item[field_id(NAME)] && sec ) {
				add_item2database(item);
			} else {
				item_empty(item);
			}
			sec = 1;
			memset(item, 0, ITEM_SIZE);
			if(!(tmp = strchr(line, ']')))
				sec = 0; /*incorrect section lines are skipped*/
		} else if((tmp = strchr(line, '=') ) && sec) {
			*tmp++ = '\0';
			find_field_number(line, &field);
			if(field != -1) {
				item[field] = xstrdup(tmp);
				goto next;
			} else if(!strcasecmp(opt_get_str(STR_PRESERVE_FIELDS),
						"all")){
				declare_unknown_field(line);
				item = xrealloc(item, ITEM_SIZE);
				item[fields_count - 1] = xstrdup(tmp);
				goto next;
			}
		}
next:
		xfree(line);
	}

	xfree(line);
	item_free(&item);
	return 0;
}
Пример #3
0
CItem *CItemCreator::CreateItem()
{
	CItem *item = item_create();
	if (!item)
	{
		RunStateError("创建CItem失败!");
		return nullptr;
	}

	return item;
}
Пример #4
0
int		item_pb(t_list *list, void *data, int size)
{
  t_item	*item;

  item = item_create(data, size);
  if (list == NULL || item == NULL)
    return (-1);
  item->prev = list->tail;
  if (list->tail != NULL)
    list->tail->next = item;
  if (list->head == NULL)
    list->head = item;
  list->tail = item;
  list->len += 1;
  return (1);
}
Пример #5
0
// 获得道具
int item_getitem( int actor_index, int itemkind, int itemnum, char path )
{
	if ( actor_index < 0 || actor_index >= g_maxactornum )
		return -1;
	if ( itemkind <= 0 || itemkind >= g_itemkindnum )
		return -1;
	if ( itemnum <= 0 )
		return -1;

	Item * pitem = NULL;
	int item_offset;
	char type;
	short itemtype;
	ItemOut ItemOut[MAX_ACTOR_ITEMNUM] = { 0 };
	int item_count = 0;

	// 创建道具
	item_count = item_create( actor_index, itemkind, itemnum, ItemOut );
	if ( item_count <= 0 )
		return -1;

	itemtype = item_gettype( itemkind );
	item_offset = ItemOut[0].m_item_offset;

	type = 1;
	for ( int tmpi = 0; tmpi < item_count; tmpi++ )
	{
		item_offset = ItemOut[tmpi].m_item_offset;
		if ( item_offset >= 0 && item_offset < MAX_ACTOR_ITEMNUM )
			pitem = &g_actors[actor_index].item[item_offset];
		else
			continue;

		item_sendget( actor_index, -1, item_offset, ItemOut[tmpi].m_count, path );
		// 记录log
		if ( tmpi == item_count - 1 )
			type = 0;
		wlog( type, LOGOP_ITEMGET, path, itemkind, ItemOut[tmpi].m_count, pitem->m_itemid, g_actors[actor_index].actorid, 0 );
	}
	return 0;
}
Пример #6
0
int
add_item2database(list_item item)
{
	/* 'name' field is mandatory */
	if((item[field_id(NAME)] == NULL) || ! *item[field_id(NAME)]) {
		item_empty(item);
		return 1;
	}

	if(++items > list_capacity)
		adjust_list_capacity();

	validate_item(item);

	selected[LAST_ITEM] = 0;

	database[LAST_ITEM] = item_create();
        item_copy(database[LAST_ITEM], item);

	return 0;
}
Пример #7
0
int
duplicate_item()
{
	list_item item;
	
	if(curitem < 0)
		return 1;

	item = item_create();
	item_duplicate(item, db_item_get(curitem));
	if(add_item2database(item)) {
		item_free(&item);
		return 1;
	}
	item_free(&item);

	curitem = last_item();
	refresh_list();

	return 0;
}
Пример #8
0
/*
** insert data at head of list
** return -1 if error, or elements count
*/
long list_insert(LIST *list, void *data, long len)
{
  long rval = -1L;
  
  if ( list ) {
    pthread_mutex_lock(list->l_lock);
    if ( data && len > 0 ) {
      ITEM *pit = item_create(data, len);
      if ( pit ) {
	pit->i_next = list->l_head;
	if ( ! list->l_tail )	/* single item is pointed to by head and tail */
	  list->l_tail = pit;
	list->l_head = pit;
	list->l_count++;	/* increment the item count */
	rval = list->l_count;
      }
    }
    pthread_mutex_unlock(list->l_lock);
  }

  return rval;
}
Пример #9
0
domain domain_create(int nitem, int nclassmax, int clusterflag, double alpha,
	double alphahyp, int label, int *initclasses) {
  int i;
  domain dmn;
  dmn = (domain) my_malloc(sizeof(struct domain_str));
  dmn->nitem = nitem;
  dmn->nclassmax = nclassmax;
  dmn->clusterflag= clusterflag;
  dmn->alpha = alpha;
  dmn->alphahyp = alphahyp;
  dmn->ninstances = 0;

  dmn->instances= (int **) my_malloc(ps.maxdim*ps.maxrel*sizeof(int *));
  for (i = 0; i < ps.maxdim*ps.maxrel; i++)  {
    dmn->instances[i] = (int *) my_malloc(2*sizeof(int));
  }

  dmn->classorder = frontlist_create(nclassmax);
  dmn->classes = (itemclass *) my_malloc(nclassmax*sizeof(itemclass));
  for (i = 0; i < nclassmax; i++) {
    dmn->classes[i] = itemclass_create(nitem);
  }
  dmn->items= (item *) my_malloc(nitem*sizeof(item));
    fprintf(stderr,"%p TOTAL %d\n",dmn,nitem);
  for (i = 0; i < nitem; i++) {
    fprintf(stderr,"%p Creating %d\n",dmn,i);
    dmn->items[i] = item_create();
  }
  dmn->label = label;
  dmn->init = (int *) my_malloc(nitem*sizeof(int));
  if (initclasses != NULL) {
    for (i = 0; i < nitem; i++) {
      dmn->init[i] = initclasses[i];
    }
  }
  dmn->prior = 0.0;
  return dmn;
}
Пример #10
0
void generateLevel(struct TileElement** tiles, int num_tiles, struct CreatureElement** creatures, int num_creatures, struct ActionElement** actions)
{
	int curr = 0;
	srand(time(NULL));
	fprintf(stderr, "rnd: %i\n", rand());
	fprintf(stderr, "rnd2: %f\n", (float)rand()/(float)RAND_MAX);
	
	/*
	struct Room r1;
	r1.pos.x = 1;
	r1.pos.y = 2;
	r1.dim.x = 5;
	r1.dim.y = 6;
	curr += addRoom(tiles, r1, curr);
	
	
	struct Room r2;
	r2.pos.x = 8;
	r2.pos.y = 3;
	r2.dim.x = 4;
	r2.dim.y = 7;
	
	curr += addRoom(tiles, r2, curr);
	*/
	//struct Room path;
	/*
	while (curr < num_tiles)
	{
		struct Tile t;
		t.pos.x = curr;
		t.pos.y = curr;
		tiles[curr] = t;
		++curr;
	}*/
	
	
	struct CaveRoom cr1;
	struct CaveRoomGenerator caveGen;
	gen_cave_gen(&caveGen, 
		7, 
		8, 
		7, 7, 
		9, 9, 
		4, 4, 
		6, 6, 
		0, M_PI*2);

	//create_cave_room(&cr1, 0, 0, 7, 2.0f, 3, 2, 4, 5);
	gen_cave_room(&cr1, caveGen);
	gen_exits(&cr1);
	struct CaveRoom cr2;
	cave_branch(&cr1, &caveGen, &cr2);
	addCaveRoom(tiles, &cr1, curr);
	//pos_print(cr2.origin);
	addCaveRoom(tiles, &cr2, curr);
	
	
	
	struct Creature *creat = malloc(sizeof(*creat));
	creature_create(creat, TYP_GAS_BALL);
	creat->pos.x = 2;
	creat->pos.y = 4;
	creature_add_sub_type(creat, STYP_EXISTS);
	game_add_creature(creatures, creat);
	
	struct Creature *bj = malloc(sizeof(*bj));
	creature_create(bj, TYP_BLUE_JELLY);
	bj->pos.x = 4;
	bj->pos.y = 4;
	creature_add_sub_type(bj, STYP_EXISTS);
	game_add_creature(creatures, bj);
	
	bj->items = malloc(sizeof(*bj->items));
	bj->items->next = NULL;
	bj->items->elem = malloc(sizeof(*bj->items->elem));
	item_create(bj->items->elem, ITM_BLUE_JELLY);
	
	struct Action* follow_act;
	action_create(&follow_act, ACT_FOLLOW);
	
	struct ActionObject* user;
	action_obj_create(&user, ACT_OBJ_CREATURE);
	user->creature = mainGame->player;
	action_add(follow_act, user, ACT_ROLE_USER);
	
	struct ActionObject* creatActObj;
	action_obj_create(&creatActObj, ACT_OBJ_CREATURE);
	creatActObj->creature = creat;
	action_add(follow_act, creatActObj, ACT_ROLE_TARGET);
	
	struct ActionObject* mag;
	action_obj_create(&mag, ACT_OBJ_FLOAT);
	mag->fvalue = 1.0f;
	action_add(follow_act, mag, ACT_ROLE_MAGNITUDE);
	
	// make sure it's disabled at the start
	//action_add_subtype(follow_act, SACT_DISABLED);
	
	game_add_action(actions, follow_act);
	
	struct TileElement* currTile = *tiles;
	while(currTile != NULL)
	{
		tile_make_walls(*tiles, currTile->elem);
		currTile = currTile->next;
	}
	
};
Пример #11
0
void world_init(void) {
    
    world_jump_vy=2*jump_max_h/jump_semi_t;
    world_g=world_jump_vy/jump_semi_t;

    world_walker_v=c_v_slow;
    
    struct tms paraeltimes;
    srand((unsigned int)times(&paraeltimes));
    
    world.t=0.0;
    
    world.waiting_to_start=True;
    
    world.player.is_player=True;
    world.player.x=0.0;
    world.player.y=0.0;
    world.player.vx=c_v_slow*0; // para que empiece parado hasta el go
    world.player.vy=0.0;
    world.player.sprite_class=sprite_classes[SPRCLS_ID_PLAYER];
    sprite_set_state(&world.player, STID_PLAYER_STOP);
   // world.player.anim_state=&(sprite_classes[SPRCLS_ID_PLAYER]->animstate[0]);
    world.player.anim_lastT=world.t;
    
    
    world.player_vida=1.0;
    world.player_deadline=60.0;
    world.player_checkpoint=7000.0;
    world.player_untouchable_time=0.0;
    
    world_zero_sprites();
    item_zero(&world);

//    world_create_walker(200,0);
//    world_create_walker(400,0);
//    world_create_walker(600,0);
//
//    world_create_walker(700,1);
//    world_create_walker(1000,1);
//
//    
//    world_create_walker(900,2);
//
//    world_create_walker(-800,3);
//    
//    world.time_next_piligrim=random_exp_time(10.0);
//    world.time_next_cansado=random_exp_time(5.0);
//    world.time_next_bici=random_exp_time(10.0);
//    printf("primer generado en t=%f\n",world.time_next_piligrim);
    
    render_clean_bocina();
    
    world.cam_x=-c_cam_offset;
    world.cam_v=0;
    // para que el jugador empiece fuera de la pantalla
    c_cam_init_free=1;
    world.cam_x+=c_cam_offset+300;
    // para que empiece dentro y parado esperando al go
    world.cam_x=-2*c_cam_offset;
    world.player.x+=world_pos0;
    
    world.zone_width=1000;
    world.zone_level_factor[0]=1.0;
    world.zone_level_factor[1]=5;
    world.zone[0].i[0]=-100;
    world.zone[1].i[0]=-100;
    world.zone[2].i[0]=-100;
    
    
    generador_init();

    t_itemPtr tumba_item=item_create(&world, ITEM_CLS_TUMBA);
    tumba_item->x=game_last_dead;
    tumba_item->y=0.0;
    tumba_item->tumba_owner=-1;
    int itumba;
    for (itumba=0; itumba<HIGHSCORE_MAX_TUMBAS; itumba++) {
        if ( highscore_table[itumba].score > HIGHSCORE_MINX_TUMBAS ) {
            t_itemPtr tumba_item=item_create(&world, ITEM_CLS_TUMBA);
            tumba_item->x=100.0*highscore_table[itumba].score+world_pos0;
            tumba_item->y=0.0;
            tumba_item->tumba_owner=itumba;
        }
    }
        
//    t_itemPtr aux_item=item_create(&world, ITEM_CLS_COMIDA_1);
//    aux_item->x=1030.0;
//    aux_item->y=150.0;

    
}
Пример #12
0
void world_update_zone_if_needed(int level, int izone) {
    int zone_seed=generador_zone_seed;
    
    int i_zone_storage=izone%3;
    if (izone<0) i_zone_storage+=3;
    
    if (world.zone[i_zone_storage].i[level]==izone) {
        // no need to update
        return;
    }
    //printf("generated new zone %d level %d\n",izone, level);
    world.zone[i_zone_storage].i[level]=izone;
    
    t_world_zonePtr thezone;
    thezone=&(world.zone[i_zone_storage]);
    if (level==0) {  // genera zonas de nivel 0 o de primer plano
        unsigned int s=izone+zone_seed;
        thezone->prueba_h=(rand_r(&s)%10)*10.0;
        // genera numeros aleatorios y los objetos de la zona
        
        // 4 arboles al azar con posicion uniformemente distribuida en la zona
        int i;
        for (i=0;i<4;i++) {
            thezone->arbol_present[i]=0;
            if (rand_r(&s)%100 <25) {
                thezone->arbol_present[i]=2+(rand_r(&s)%2);
                thezone->arbol_pos[i]=rand_r(&s)%1000;
            }
        }
    
//        int hay_caido=(rand_r(&s)%100<25);  // posible peregrino sentado
        //if (hay_caido) world_create_walker(800,2);
                                  
//        int hay_bici=(rand_r(&s)%100<25);  // posible bici
//        if (hay_bici) world_create_walker(-800*2,3);

        if (izone<0) return;
        
//        for (i=0;i<3;i++) {
//            if (rand_r(&s)%100 <25) {
//                int walker_type=rand_r(&s)%2;
//                float walker_pos=world.zone_width+world.zone_width*(rand_r(&s)%100)*1.0/100.0;
//                world_create_walker(walker_pos, walker_type);
//            }
//        }
        
        int items_seed=generador_items_seed;
        s+=items_seed;
        int hay_comida=(rand_r(&s)%100<105); // posible comida
        if (hay_comida) {
            int comida_tipo=rand_r(&s)%6;
            if (izone%50==49) {
                comida_tipo=ITEM_CLS_POWERUP_LIFE;
            }
            t_itemPtr unitem=item_create(&world, comida_tipo);
            if (unitem) {
//                printf("creada comida tipo %d\n", comida_tipo);
                unitem->x=1000.0-200.0+400.0*(rand_r(&s)%100)/100.0;
                //unitem->y=1.0*(rand_r(&s)%500);
                unitem->y=250.0;
            }
        }
        
        
        
    } else if (level==1) { // zonas de nivel 1 segundo plano
        unsigned int s=izone+zone_seed+1;
        if (rand_r(&s)%100 <80) {  // posible colina 1
            thezone->back_colina_pos[0]=20;
        } else {
            thezone->back_colina_pos[0]=-1;                
        }
        if (rand_r(&s)%100 <80) {  // posible colina 2
            thezone->back_colina_pos[1]=520;
        } else {
            thezone->back_colina_pos[1]=-1;                
        }
    }
        
}