static void mv_play(t_lemmin *first_lem, t_best_route *best, t_room **rooms)
{
t_lemmin *lem;
t_room *tmp_room;
(void)best;
lem = first_lem;
while (lem)
{
if (lem->moves && !lem->room->is_end)
{
tmp_room = find_room(get_r_n(lem->route, lem->moves + 1), rooms);
lem->room = tmp_room;
tmp_room->num_of_lem++;
ft_putstr(lem->name);
ft_putstr("-");
ft_putstr(tmp_room->id);
ft_putstr(" ");
tmp_room = find_room(get_r_n(lem->route, lem->moves), rooms);
tmp_room->num_of_lem--;
lem->moves++;
}
lem = lem->next;
}
}
//------ user functions --------
//params: u_id, sp_id, room
int add_user(char* u_id,char* sp_id,char* name)
{
room_node* q = find_room(name);
if (q == NULL){
add_room(name);
q = find_room(name);
}
if (q->num_users > 0 && strcmp(q->users->u_id,u_id) == 0) {
if (strcmp(q->users->sp_ids->sp_id,sp_id) == 0) //duplicate
return 0;
sp_id_node* sp_iter = q->users->sp_ids;
for (; sp_iter->next != NULL; sp_iter = sp_iter->next) {
if (strcmp(sp_iter->next->sp_id,sp_id) == 0)
return 0;
}
sp_id_node* insert = malloc(sizeof(sp_id_node));
strcpy(insert->sp_id,sp_id);
insert->next = NULL;
insert->prev = sp_iter;
sp_iter->next = insert;
q->users->next->num_ids++;
return 1;
}
user_node* u_iter = q->users;
for (; q->users != NULL && u_iter->next != NULL; u_iter = u_iter->next) {
if (strcmp(u_id,u_iter->next->u_id) == 0) {
if (strcmp(u_iter->next->sp_ids->sp_id,sp_id) == 0) //duplicate
return 0;
sp_id_node* sp_iter = u_iter->next->sp_ids;
for (; sp_iter->next != NULL; sp_iter = sp_iter->next) {
if (strcmp(sp_iter->next->sp_id,sp_id) == 0)
return 0;
}
sp_id_node* insert = malloc(sizeof(sp_id_node));
strcpy(insert->sp_id,sp_id);
insert->next = NULL;
insert->prev = sp_iter;
sp_iter->next = insert;
u_iter->next->num_ids++;
return 1;
}
}
user_node* insert = malloc(sizeof(user_node));
strcpy(insert->u_id,u_id);
sp_id_node* sin = malloc(sizeof(sp_id_node));
strcpy(sin->sp_id,sp_id);
insert->sp_ids = sin;
insert->num_ids = 1;
if (q->num_users == 0)
q->users = insert;
else {
insert->next = u_iter->next;
u_iter->next = insert;
insert->prev = u_iter;
}
q->num_users++;
return 1;
}
static void mv_start(t_lemmin *first_lem,t_best_route *best, t_room **rooms)
{
t_lemmin *lem;
t_best_route *routes;
t_room *tmp_room;
routes = best;
lem = first_lem;
while (lem && routes)
{
if (lem->moves == 0)
{
lem->route = routes->route;
tmp_room = find_room(get_r_n(lem->route, lem->moves + 1), rooms);
lem->room = tmp_room;
tmp_room->num_of_lem++;
ft_putstr(lem->name);
ft_putstr("-");
ft_putstr(tmp_room->id);
ft_putstr(" ");
tmp_room = find_room(get_r_n(lem->route, lem->moves), rooms);
tmp_room->num_of_lem--;
lem->moves++;
routes = routes->next;
}
lem = lem->next;
}
}
D_MOBILE *load_player(char *player)
{
D_MOBILE *dMob = NULL;
char sql[MAX_BUFFER];
char pName[MAX_BUFFER];
sqlite3_stmt *rSet = NULL;
int i, size;
memset(sql, '\0', MAX_BUFFER);
pName[0] = toupper(player[0]);
size = strlen(player);
for (i = 1; i < size && i < MAX_BUFFER - 1; i++)
pName[i] = tolower(player[i]);
pName[i] = '\0';
/* prepare sql to query player table */
snprintf(sql, MAX_BUFFER, "select * from players where name = ?");
sqlite3_prepare_v2(db, sql, sizeof(sql), &rSet, NULL);
sqlite3_bind_text(rSet, 1, pName, strlen(pName), 0);
/* execute query and return NULL if player isn't found*/
if (sqlite3_step(rSet) != SQLITE_ROW)
{
sqlite3_reset(rSet);
sqlite3_finalize(rSet);
return NULL;
}
/* create new mobile data */
if (StackSize(dmobile_free) <= 0)
{
if ((dMob = malloc(sizeof(*dMob))) == NULL)
{
bug("Load_player: Cannot allocate memory.");
abort();
}
}
else
{
dMob = (D_MOBILE *) PopStack(dmobile_free);
}
clear_mobile(dMob);
/* load data */
dMob->name = strdup((const char *)sqlite3_column_text(rSet,3));
dMob->password = strdup((const char *)sqlite3_column_text(rSet,4));
dMob->level = sqlite3_column_int(rSet,2);
dMob->room = find_room(sqlite3_column_int(rSet,0));
/* clear result set */
sqlite3_reset(rSet);
sqlite3_finalize(rSet);
if (dMob->room == NULL)
dMob->room = find_room(START_ROOM);
return dMob;
}
void weighting(t_lem *p)
{
p->end = find_room(p->room, FINISH);
ft_weighting(p->end, 0);
p->first = find_room(p->room, START);
if (p->first->weight == -1)
error();
p->first->ant = p->ant;
}
//------ msg functions --------
//params: msg_timestamp, u_id, room, mess
int add_msg(lamport* ts, char* u_id, char* room, char* mess){
room_node* root = find_room(room);
if (root == NULL) {
add_room(room);
root = find_room(room);
}
msg_node* insert = malloc(sizeof(msg_node));
insert->timestamp = ts;
strcpy(insert->mess,mess);
strcpy(insert->u_id,u_id);
insert->num_likes = 0;
//check if first in chatroom
if (root->num_msgs == 0) {
insert->prev = NULL;
insert->next = NULL;
root->msgs = insert;
root->num_msgs++;
return 1;
}
//check if oldest message
if (cmp_timestamp(ts,root->msgs->timestamp) < 0) {
insert->prev = NULL;
insert->next = root->msgs;
insert->next->prev = insert;
root->msgs = insert;
root->num_msgs++;
return 1;
}
//check all other msg for where next->ts > insert
msg_node* iter = root->msgs;
for (; iter->next != NULL; iter = iter->next) {
// next is newer than insert
if (cmp_timestamp(ts,iter->next->timestamp) < 0) {
insert->next = iter->next;
insert->prev = iter;
iter->next = insert;
insert->next->prev = insert;
root->num_msgs++;
return 1;
}
else if (cmp_timestamp(ts,iter->next->timestamp) == 0)
return 0;
}
//insert is newest
insert->prev = iter;
insert->next = NULL;
iter->next = insert;
root->num_msgs++;
return 1;
}
static struct t_rooms *find_neighbours(struct t_rooms *room, struct t_tubes *tubes)
{
if (tubes != NULL)
{
if (!ft_strcmp(tubes->start, room->name))
return (find_room(tubes->end, room));
else if (!ft_strcmp(tubes->end, room->name))
return (find_room(tubes->start, room));
else
return (find_neighbours(room, tubes->next));
}
return (NULL);
}
/*
* If the <room> is in the <room_list>, trim the room's event node list
* to at most <keep> entries. As the list is ordered from newest to
* oldest, the oldest entries are discarded.
*
* Whether the room exists or not, and whether or not the list holds
* anything, the specified "Trim log" message must be printed. Obviously,
* for a non-existent room nothing is actually trimmed (removed).
*
* Note - dynamically allocated space for event nodes removed from
* the list must be freed.
*/
static void trim_list(int room, int keep, char timestamp[]) {
struct room_t *curr_room = find_room(room);
if(curr_room == NULL)
return;
struct evnode_t *event = curr_room->evl_head;
int index = 1;
while(event != NULL && index < keep){
event = event->next;
index++;
}
index = 0;
if(event != NULL){
struct evnode_t *temp = event->next;
struct evnode_t *next = NULL;
event->next = NULL;
while(temp != NULL){
next = temp->next;
free(temp);
temp = next;
index++;
}
if(keep == 0){
free(curr_room->evl_head);
curr_room->evl_head = NULL;
index++;
}
}
printf("Trim log @ %s: room %d log trimmed to length %d (%d entries removed)\n", timestamp, room, keep, index);
return;
}
// params: room_name
int add_room(char* name){
if (find_room(name) != NULL)
return 0;
room_node* insert = malloc(sizeof(room_node));
strcpy(insert->name,name);
insert->num_msgs = 0;
insert->num_users = 0;
//deal with empty room
if (num_rooms == 0)
{
head = insert;
insert->next = insert;
insert->prev = insert;
}
else {
insert->next = head;
insert->prev = NULL;
head->prev = insert;
head = insert;
}
num_rooms++;
return 1;
}
void on_build() {
object start_room, door;
// int ix, iy;
ROOM_MAP( 3, 3, 1,
"bbb"
"aaa"
"aaa")
ROOM_KEY( "a", "start", "The cottage's front room", "This small front room is cramped but cozy." )
ROOM_KEY( "b", "backroom", "The back room", "A small space at the back of the cottage." )
start_room = find_room("start", this_object());
door = clone_object("/world/exit/door");
door->move( environment() );
door->set_host( this_object() );
door->set_coord( MAKE_C(2,2,0) );
door->set_dir( "cottage" );
door->set_link( "start" );
door->query_backlink()->set_coord( MAKE_C(8,7,0) );
door = clone_object("/world/exit/door");
door->move( start_room );
door->set_coord( MAKE_C(8,0,0) );
door->set_dir( "north" );
door->set_link( "backroom" );
door->query_backlink()->set_coord( MAKE_C(8,4,0) );
}
void spawn_kid() {
object kid = clone_object( "/monsters/human" );
kid->move( find_room("start", this_object()) );
kid->set_home( this_object() );
kid->validate_position();
kid->use_ai_module( "farmer_kid" );
command( "walk random", kid );
}
//params: room_name
void print_room(char* name){
room_node* target = find_room(name);
if (target == NULL)
return;
printf("=== %s ===\n",name);
print_users(target->users);
print_msgs(target->msgs);
}
void S_alloc_init() {
ISPC s; IGEN g; UINT i;
if (S_boot_time) {
/* reset the allocation tables */
for (s = 0; s <= max_real_space; s++) {
for (g = 0; g <= static_generation; g++) {
S_G.base_loc[s][g] = FIX(0);
S_G.first_loc[s][g] = FIX(0);
S_G.next_loc[s][g] = FIX(0);
S_G.bytes_left[s][g] = 0;
S_G.bytes_of_space[s][g] = 0;
}
}
/* initialize the dirty-segment lists. */
for (i = 0; i < DIRTY_SEGMENT_LISTS; i += 1) {
S_G.dirty_segments[i] = NULL;
}
S_G.collect_trip_bytes = default_collect_trip_bytes;
/* set to final value in prim.c when known */
S_protect(&S_G.nonprocedure_code);
S_G.nonprocedure_code = FIX(0);
S_protect(&S_G.null_vector);
find_room(space_new, 0, type_typed_object, size_vector(0), S_G.null_vector);
VECTTYPE(S_G.null_vector) = (0 << vector_length_offset) | type_vector;
S_protect(&S_G.null_fxvector);
find_room(space_new, 0, type_typed_object, size_fxvector(0), S_G.null_fxvector);
FXVECTOR_TYPE(S_G.null_fxvector) = (0 << fxvector_length_offset) | type_fxvector;
S_protect(&S_G.null_bytevector);
find_room(space_new, 0, type_typed_object, size_bytevector(0), S_G.null_bytevector);
BYTEVECTOR_TYPE(S_G.null_bytevector) = (0 << bytevector_length_offset) | type_bytevector;
S_protect(&S_G.null_string);
find_room(space_new, 0, type_typed_object, size_string(0), S_G.null_string);
STRTYPE(S_G.null_string) = (0 << string_length_offset) | type_string;
}
}
static struct t_rooms *find_room(char *tube, struct t_rooms *room)
{
if (room != NULL)
{
if (!ft_strcmp(tube, room->name))
return (room);
else
return (find_room(tube, room->next));
}
return (NULL);
}
/*
* Create a new room_t node for <room>, initialize its fields, and append
* the node to the end of the <room_list>.
* Returns a pointer to the new room's structure.
*/
static struct room_t *add_new_room(int room) {
struct room_t *new_room = malloc(sizeof(struct room_t)); // ptr. to new room structure
if(room != 1){
struct room_t *curr_room = find_room(room-1);
curr_room->next_room = new_room;
}else
room_list = new_room;
new_room->room = room;
new_room->ecount = 0;
new_room->evl_head = NULL;
return new_room;
}
msg_node* find_msg(char* room, lamport* ts) {
room_node* root = find_room(room);
if (root == NULL)
return 0;
for (msg_node* iter = root->msgs;iter != NULL; iter = iter->next) {
if (cmp_timestamp(iter->timestamp,ts) == 0)
return iter;
}
printf("no msg found\n");
return NULL;
}
void on_build() {
object start_room, spawn;
ROOM_MAP( 3, 4, 1,
"ccc"
"ccc"
"aab"
"aab")
ROOM_KEY( "a", "start", "The Main Room", "This is the farmhouse's cozy living area." )
ROOM_KEY( "b", "pantry", "The Pantry", "A small side room where food is stored." )
ROOM_KEY( "c", "garden", "The Garden", "Behind the farmhouse is a small vegetable garden." )
start_room = find_room("start", this_object());
object silo = clone_object( "/scn/furni/veg_silo" );
silo->move( find_room("garden", this_object()) );
silo->set_coord( MAKE_C(1,1,0) );
make_outside_exit( start_room, MAKE_C(2,1,0) );
link_rooms( "start", "pantry", MAKE_C(11,3,0), "east" );
link_rooms( "pantry", "garden", MAKE_C(3,0,0), "north" );
object ob;
ob = clone_object( "/scn/furni/larder" );
ob->move( find_room("pantry", this_object()) );
ob->set_x(2);
ob->set_y(6);
set_larder( ob );
spawn = clone_object( "/obj/work_spot" );
spawn->move( start_room );
spawn->set_work_name( "farmer" );
spawn->set_work_ai( "farmer" );
spawn->set_home( this_object() );
spawn->set_num_positions( 1 );
spawn->set_coord( MAKE_C(5,3,0) );
}
static void oblist_insert(ptr sym, iptr idx, IGEN g) {
bucket *b, *oldb, **pb;
find_room(g == 0 ? space_new : space_data, g, typemod, sizeof(bucket), b);
b->sym = sym;
if (g == 0) {
b->next = S_G.oblist[idx];
S_G.oblist[idx] = b;
} else {
for (pb = &S_G.oblist[idx]; (oldb = *pb) != NULL && SegmentGeneration(addr_get_segment(oldb)) < g; pb = &oldb->next);
b->next = oldb;
*pb = b;
}
if (g != static_generation) {
bucket_list *bl;
find_room(g == 0 ? space_new : space_data, g, typemod, sizeof(bucket_list), bl);
bl->car = b;
bl->cdr = S_G.buckets_of_generation[g];
S_G.buckets_of_generation[g] = bl;
}
S_G.oblist_count += 1;
}
// Executes getting a room.
void get_room(struct hotel *h) {
int room_no;
// Finds a room number that is available.
room_no = find_room(h);
// Full hotel case.
if (room_no == FULL_HOTEL)
printf("Sorry, we are full.\n");
// Adjust necessary quantities to fill the chosen room.
else {
printf("You will stay in room %d.\n", room_no);
h->available--;
h->rooms[room_no] = 0;
}
}
/*
* Given a reading, process the included event for the room in the reading.
* T_PRINT and T_TRIM readings are really commands; once executed they are
* discarded.
* For all other readings check to see whether an alert should be printed,
* then add the event to as the newest event in the room's event list.
*/
static void process_a_reading(struct reading_t reading) {
struct room_t *room = find_room(reading.room_id);
if(room == NULL){
room = add_new_room(reading.room_id);
}
if(reading.event.event_id == 9 && room != NULL){
printf("*****\nHome Security System: Room %d @ %s\n", reading.room_id, reading.event.time_stamp);
printf("Triggered by sensor %d\n%d total room events\n", reading.event.sensor, room->ecount);
struct evnode_t *node_event = room->evl_head;
while(node_event != NULL){
struct event_t event = node_event->event;
printf("Sensor %d @ %s", event.sensor, event.time_stamp);
if(event.event_id == 1)
printf(" temperature reading %d degrees\n", event.event_info);
else if(event.event_id == 2)
printf(" carbon monoxide reading %d PPB\n", event.event_info);
else if(event.event_id == 3)
printf(" intruder alert\n");
node_event = node_event->next;
}
}else if(reading.event.event_id == 8){
trim_list(reading.room_id, reading.event.event_info, reading.event.time_stamp);
}else{
if(reading.event.event_id == 1){
if(reading.event.event_info < 50 || reading.event.event_info > 110)
printf("Temperature alert @ %s: room %d / sensor %d / %d degrees.\n", reading.event.time_stamp, reading.room_id, reading.event.sensor, reading.event.event_info);
}else if(reading.event.event_id == 2){
if(reading.event.event_info > 3000)
printf("Carbon monoxide alert @ %s: room %d / sensor %d / %d PPB.\n", reading.event.time_stamp, reading.room_id, reading.event.sensor, reading.event.event_info);
}else if(reading.event.event_id == 3)
printf("Intruder alert @ %s: room %d / sensor %d.\n", reading.event.time_stamp, reading.room_id, reading.event.sensor);
struct evnode_t *node_event = room->evl_head;
if(node_event == NULL)
room->evl_head = make_event_node(reading.event);
else{
struct evnode_t *new_node = make_event_node(reading.event);
new_node->next = room->evl_head;
room->evl_head = new_node;
}
room->ecount++;
}
return ;
}
void travel_rooms(t_map *map, t_room *current, int value, t_path *path)
{
t_room *access;
t_access *tmp;
tmp = current->access;
if (current == map->end)
get_path(path, value);
while (tmp != NULL && current != map->end)
{
access = find_room(map, tmp->name);
if (access->val == -1 || access->val > value)
{
access->val = value;
add_access(tmp->name, &path->access);
travel_rooms(map, access, (value + 1), path);
remove_last_access(&path->access);
}
tmp = tmp->next;
}
}
//params: room_name
int rm_room(char* name){
room_node* target = find_room(name);
if (target == NULL)
return 0;
while (target->users != NULL) { //free all users
while (target->users->sp_ids != NULL) { //free all ^ sp_ids
sp_id_node* sprm = target->users->sp_ids;
target->users->sp_ids = target->users->sp_ids->next;
free(sprm);
}
user_node* urm = target->users;
target->users = target->users->next;
free(urm);
}
while (target->msgs != NULL) { //free all msgs
while( target->msgs->likes != NULL) { //free all ^ likes
like_node* lrm = target->msgs->likes;
target->msgs->likes = target->msgs->likes->next;
free(lrm);
}
msg_node* mrm = target->msgs;
target->msgs = target->msgs->next;
free(mrm);
}
//room is empty
target->next->prev = target->prev;
target->prev->next = target->next;
free(target);
num_rooms--;
//deal with head
if (num_rooms == 0)
head = NULL;
return 1;
}
/** Converts a reference into an object pointer. You should only
* pass in one parameter; the second \a rcheck parameter is used
* internally.
*
* \return The object referenced by \a str, or 0 on failure.
*/
varargs object find_thing(string str, status rcheck) {
object ob;
string a, b;
if(!str) return 0;
if( this_player() ) {
ob = present(str, this_player());
if(environment(this_player())) { /* Believe it or not, this was necessary. */
if(!ob) ob = present(str, environment(this_player()));
if(!ob && (environment(this_player())->id(str) == environment(this_player()) || str == "env"))
ob = environment(this_player());
}
}
if(!ob) {
ob = find_player(str);
}
if(!ob) {
ob = find_living(str);
}
if(!ob) {
ob = find_object(str);
}
if(!ob) {
ob = find_objectref(str);
}
if(!ob && sscanf(str, "%s %s",a,b)!=2 && file_exists(str+".c") ) {
call_other(str, "this_function_does_not_exist\n");
ob = find_object(str);
}
if(!ob && str == "me") ob = this_player();
if(!ob) ob = find_room( str, this_player() );
if(!ob) ob = single_present( str, this_player() );
if(!ob) ob = single_present( str, environment(this_player()) );
if(!rcheck && !ob && this_player() )
ob = find_thing(this_player()->make_path_absolute(str), 1);
return ob;
}
int
main(void) {
struct room *start_room; /* store start room */
struct room *goal_room; /* store goal room */
int numRooms;
int numDoors;
char input_name[21];
int input_doughnuts;
int intput_milkshakes;
char start[21];
char goal[21];
/*scan number of rooms from input and check if valid */
scanf("\n%d", &numRooms);
if(numRooms<=0){
printf("\nerror");
return -1;
}
base = (struct list *)malloc(sizeof(struct list));
createRooms(numRooms);
/*
//loop that creates new room
for(int i=1; i<= numRooms;i++){
scanf("\n%20s %d %d, &input_name, &input_doughnuts);
}
*/
/*scan number of doors from input and check if valid */
scanf("\n%d", &numDoors);
if(numDoors<=0){
printf("\nerror");
return -1;
}
createDoors(numDoors);
/* scan START and GOAL rooms */
scanf("\n%s %s",&start, &goal);
start_room = find_room(start, base);
goal_room = find_room(goal, base);
if(start_room == NULL || goal_room == NULL){
printf("\nerror");
return -1;
}
pointer = start_room;
while(scanf("\n%c", &move)!=EOF){
command();
if(pointer == NULL){
return -1;
}
else if(pointer == goal_room){
printf("\nwon");
return 0;
}
else{
printf("\n %s %d %d %d %d", pointer->name, pointer->num_doughnuts, pointer->num_milkshakes, player_doughnuts, player_milkshakes);
}
}
delete_rooms(base);
return 0;
}
main () {
FILE *fin = fopen ("castle.in", "r");
FILE *fout = fopen ("castle.out", "w");
int i, j;
unsigned int type;
fscanf (fin, "%d %d", &M, &N);
for (i = 0; i < N; i++) {
for (j = 0; j < M; j++) {
fscanf (fin, "%u", &type);
module[i][j] = ( unsigned char ) type;
room[i][j] = nil;
//printf ("%d ", (unsigned char) type);
}
}
for (i = 0; i < 2500; i++)
size[i] = 0;
max_size = 0;
find_room();
fprintf(fout, "%d\n", room_num+1);
for (i = 0; i <= room_num; i++)
if (size[i] > max_size)
max_size = size[i];
fprintf(fout, "%d\n", max_size);
int new_size;
for (i = 0; i < N; i++) {
for (j = 0; j < M; j++) {
if (north(module[i][j]) && i > 0
&& room[i][j] != room[i-1][j]) {
new_size = size[room[i][j]] + size[room[i-1][j]];
if (new_size > new_room_size) {
x = i;
y = j;
direction = 'N';
new_room_size = new_size;
}
else if (new_size == new_room_size) {
if (j<y || (j==y && i>x) ) {
x = i;
y = j;
direction = 'N';
}
}
} else if (east(module[i][j]) && j < M-1
&& room[i][j] != room[i][j+1]) {
new_size = size[room[i][j]] + size[room[i][j+1]];
if (new_size > new_room_size) {
x = i;
y = j;
direction = 'E';
new_room_size = new_size;
}
else if (new_size == new_room_size) {
if (j<y || (j==y && i>x) ) {
x = i;
y = j;
direction = 'E';
}
}
}
}
}
fprintf(fout, "%d\n", new_room_size);
fprintf(fout, "%d %d %c\n", x+1, y+1, direction);
exit (0);
}
object get_work_spot() {
return present( "work_spot", find_room("start", this_object()) );
}
object get_silo() {
return present( "veg_silo", find_room("garden", this_object()) );
}
