Beispiel #1
0
// this function is really ugly
static void generate(zone * z)
{
	static int first = 1;

	int i, x, y, max;
	int rc;
	int ** walls;
	room * rv;
	item * it;
	creature * cr;

	if (first) {
		fill_walls();
		first = 0;
	}

	// generate rooms
	rc = random() % ((z->width * z->height) / ROOM_INFREQ) + ROOM_MIN;
	rv = malloc(sizeof(room) * rc);

	for (i = 0; i < rc; i++) {
		rv[i].w = random() % 12 + 5;
		rv[i].h = random() % 8 + 3;
		rv[i].x = random() % (z->width  - rv[i].w - 1) + 1;
		rv[i].y = random() % (z->height - rv[i].h - 1) + 1;
	}


	// cut out rooms
	walls = malloc(sizeof(int *) * z->width);
	for (x = 0; x < z->width; x++) {
		walls[x] = malloc(sizeof(int) * z->height);

		for (y = 0; y < z->height; y++) {
			for (i = 0; i < rc; i++) {
				if (in_room(rv + i, x, y)) break;
			}
			z->tiles[x][y].ch = '.';
			walls[x][y] = (i == rc);
		}
	}


	// draw walls
	for (x = 0; x < z->width; x++) {
		for (y = 0; y < z->height; y++) {
			if (walls[x][y]) {
				z->tiles[x][y].impassible = 1;
				set_wall_char(walls,z,x,y);
			}
		}
	}

	// place some random junk
	if (world.iform_cnt != 0) {
		max = random() % (z->width * z->height / ITEM_INFREQ) + ITEM_MIN;
		for (i = max; i >= 0; i--) {
			it = item_new(world.iforms[random() % world.iform_cnt]);

			do {
				x = random() % z->width;
				y = random() % z->height;
			} while (z->tiles[x][y].impassible || !inv_try(z->tiles[x][y].inv, it));

			item_tele(it, x, y, z);
			zone_update(z, x, y);
		}
	}

	// place some more random junk
	if (world.cform_cnt != 0) {
		max = random() % (z->width * z->height / CRTR_INFREQ) + CRTR_MIN;
		for (i = max; i >= 0; i--) {
			cr = crtr_new(world.cforms[random() % world.cform_cnt]);

			do {
				x = random() % z->width;
				y = random() % z->height;
			} while (z->tiles[x][y].impassible || z->tiles[x][y].crtr != NULL);

			crtr_tele(cr, x, y, z);
			zone_update(z, x, y);
		}
	}
}
Beispiel #2
0
// this function is really ugly
static void generate(zone * z)
{
	static int first = 1;

	int i, x, y, max, timeout;
	int rc;
	int ** walls;
	room * rv;
	item * it;
	creature * cr;

	if (first) {
		fill_walls();
		first = 0;
	}

	z->name = place_name(world.eth);

	// generate rooms
	rc = random() % ((z->width * z->height) / ROOM_INFREQ) + ROOM_MIN;
	rv = malloc(sizeof(room) * rc);

	for (i = 0; i < rc; i++) {
		rv[i].w = random() % 12 + 5;
		rv[i].h = random() % 8 + 3;
		rv[i].x = random() % (z->width  - rv[i].w - 1) + 1;
		rv[i].y = random() % (z->height - rv[i].h - 1) + 1;
	}


	// cut out rooms
	walls = malloc(sizeof(int *) * z->width);
	for (x = 0; x < z->width; x++) {
		walls[x] = malloc(sizeof(int) * z->height);

		for (y = 0; y < z->height; y++) {
			for (i = 0; i < rc; i++) {
				if (in_room(rv + i, x, y)) break;
			}
			z->tiles[x][y].ch = '.';
			z->tiles[x][y].show_ch = '.';
			z->tiles[x][y].linked = 0;
			walls[x][y] = (i == rc);
		}
	}

	// draw walls
	for (x = 0; x < z->width; x++) {
		for (y = 0; y < z->height; y++) {
			if (walls[x][y]) {
				z->tiles[x][y].impassible = 1;
				set_wall_char(walls,z,x,y);
			}
		}
	}

	// place some random junk
	max = random() % (z->width * z->height / ITEM_INFREQ) + ITEM_MIN;
	for (i = max; i >= 0; i--) {
		it = gen_item(world.gitems, 1);

		timeout = 1000;
		do {
			x = random() % z->width;
			y = random() % z->height;
			timeout--;
		} while ((z->tiles[x][y].impassible || !inv_try(z->tiles[x][y].inv, it)) && timeout);

		if (timeout) {
			item_tele(it, x, y, z);
			zone_update(z, x, y);
		} else {
			item_free(it);
		}
	}

	// place some more random junk
	if (!config.all_alone) {
		max = random() % (z->width * z->height / CRTR_INFREQ) + CRTR_MIN;
		for (i = max; i >= 0; i--) {
			cr = gen_crtr(world.gcrtrs, 1);
			crtr_spawn(cr, z);
			zone_update(z, cr->x, cr->y);
		}
	}

	// place random zone jumpers
	for (i = 0; i < 4; i++) {
		do {
			x = random() % z->width;
			y = random() % z->height;
			timeout--;
		} while (z->tiles[x][y].impassible);

		z->tiles[x][y].linked = 1;
		z->tiles[x][y].link_z = NULL;
		z->tiles[x][y].ch = '@';
		z->tiles[x][y].show_ch = '@';
	}

	// cleanup
	for (x = 0; x < z->width; x++) free(walls[x]);
	free(walls);
	free(rv);
}
Beispiel #3
0
//
// Throws an item from a position along the given direction
// (x, y, z) + (dx, dy) is the starting position.
// (dx, dy) is the direction the item moves in.
// f is the force of the throw, effects duration and damage of the throw
// Returns 1 on success and 0 on failure of placing the item
//
int item_throw(item * it, int x, int y, zone * z, int dx, int dy, int force)
{
	creature * c;
	int ret, dam;
	int anim = (z == PLYR.z) && config.throw_anim_delay;
	int timeout = 100 * force / it->weight;
	chtype tmp = 0;

	x += dx;
	y += dy;

	while (x >= 0 && y >= 0 && x < z->width && y < z->height && !z->tiles[x][y].impassible && timeout) {
		if (x < 0 || x >= z->width) break;
		if (y < 0 || y >= z->height) break;
		if (z->tiles[x][y].impassible) break;

		// handle the animation
		if (anim) {
			if (tmp) {
				z->tiles[x-dx][y-dy].ch = tmp;
				zone_draw_tile(z, x-dx, y-dy);
			}

			tmp = z->tiles[x][y].ch;
			z->tiles[x][y].ch = it->ch;
			zone_draw_tile(z, x, y);
			wrefresh(dispscr);

			usleep(1000 * config.throw_anim_delay);
		}

		// creature collision
		c = z->tiles[x][y].crtr;
		if (c != NULL) {
			if (crtr_dodges(c, force / 10)) {
				memo("The %s artfully dodges the %s!", crtr_name(c), it->name);
			} else {
				dam = (it->spikiness + force) / 4 - 4;
				if (dam < 0) dam = 0;
				c->health -= dam;

				if (c->health <= 0) {
					memo("The %s kills the %s!\n", it->name, crtr_name(c));
					crtr_death(c, "projectile impact");
				} else {
					memo("The %s is hit with the %s for %d damage!", crtr_name(c), it->name, dam);
				}

				goto cleanup;
			}
		}

		x += dx;
		y += dy;
		timeout--;

	}

	x -= dx;
	y -= dy;

cleanup:
	ret = item_tele(it, x, y, z);
	zone_update(z, x, y);
	wrefresh(dispscr);
	return ret;
}
Beispiel #4
0
// this function is really ugly
static void generate(zone * z)
{
	static int first = 1;

	int i, x, y, max, timeout;
	int wall;
	int x1,x2,y1,y2;
	int rc;
	room ** rooms;
	item * it;
	creature * cr;

	if (first) {
		fill_walls();
		first = 0;
	}

	z->name = place_name(world.eth);

	rc = random() % ((z->width * z->height) / ROOM_INFREQ) + ROOM_MIN;
	rooms = malloc(sizeof(room*) * rc);

	//make everything walls!
	for (x = 0; x < z->width; x++) {
	for (y = 0; y < z->height; y++) {
		z->tiles[x][y].impassible = 1;
	}
	}

	//gen rooms and cut out
	for(i=0; i< rc; i++){
		rooms[i]=gen_room(world.grooms,1);
		build_room(z,rooms[i]);
	}

	//make sure rooms are connected!
	//connect each room to one other room

	for(i=0; i< rc; i++){
		max = random() % rc;
		room_spot(z,rooms[i],&x1,&y1);
		room_spot(z,rooms[max],&x2,&y2);
		wall=0;

		if(x1 == -1 || x2 == -1){
			warning("Room generation timed out!");
			break;
		}

		for(;x1 != x2; x1-= sign(x1-x2)){
			if(z->tiles[x1][y1].impassible) wall=1;
			else if (wall) break;

			zone_empty_tile(z,x1,y1);
		}

		for(;y1 != y2; y1-= sign(y1-y2)){
			if(z->tiles[x1][y1].impassible) wall=1;
			else if (wall) break;

			zone_empty_tile(z,x1,y1);
		}
	}

	//do rendering thing
	for (x = 0; x < z->width; x++) {
	for (y = 0; y < z->height; y++) {
		if (z->tiles[x][y].impassible) {
			set_wall_char(z,x,y);
		}
	}
	}

	for(i=0; i< rc; i++)
		free(rooms[i]);

	free(rooms);

	// place some random junk
	max = random() % (z->width * z->height / ITEM_INFREQ) + ITEM_MIN;
	for (i = max; i >= 0; i--) {
		it = gen_item(world.gitems, 1);

		timeout = 1000;
		do {
			x = random() % z->width;
			y = random() % z->height;
			timeout--;
		} while ((z->tiles[x][y].impassible || !inv_try(z->tiles[x][y].inv, it)) && timeout);

		if (timeout) {
			item_tele(it, x, y, z);
			zone_update(z, x, y);
		} else {
			item_free(it);
		}
	}

	// place some more random junk
	if (!config.all_alone) {
		max = random() % (z->width * z->height / CRTR_INFREQ) + CRTR_MIN;
		for (i = max; i >= 0; i--) {
			cr = gen_crtr(world.gcrtrs, 1);
			crtr_spawn(cr, z);
			zone_update(z, cr->x, cr->y);
		}
	}

	// place random zone jumpers
	for (i = 0; i < 4; i++) {
		do {
			x = random() % z->width;
			y = random() % z->height;
			timeout--;
		} while (z->tiles[x][y].impassible);

		z->tiles[x][y].linked = 1;
		z->tiles[x][y].link_z = NULL;
		z->tiles[x][y].ch = '@';
		z->tiles[x][y].show_ch = '@';
	}

	// cleanup
	//for (x = 0; x < z->width; x++) free(walls[x]);
	//free(walls);
	//free(rv);
}