IceMetalPunk

global.minfloor=0; /* The lowest floor created. Negative numbers indicate subterranean floors, while 0 is the ground floor. */
global.maxfloor=0; /* The highest floor created. */
global.floors=ds_map_create(); /* The map containing the lists of rooms in each floor. */
global.buildup=1; /* Whether we can build upwards or not (create a room on floor maxfloor+1). Becomes 0 when all rooms on the highest floor have no space for stairs. */
global.builddown=1; /* Whether we can build downwards or not (create a room on floor minfloor-1). Becomes 0 when all rooms on the lowest floor have no space for stairs. */

var rm, lower, upper, checkcon, stairs, p, check, checkflr, flrlist, valid, connections;
lower=argument0;
upper=argument1;
rm=argument2;

stairs=ds_map_create();
connections=ds_list_create();
ds_map_add(rm, "type", TY_STAIRS);
ds_map_add(rm, "floor", lower);
ds_map_add(rm, "connections", connections);

if (lower==ds_map_find_value(rm, "floor")) {
  ds_list_add(connections, rm);
  checkflr=upper;
}
else { checkflr=lower; }

flrlist=ds_map_find_value(global.floors, checkflr);
valid=ds_list_create();

/*str="Floor list contains: {";
for (p=0; p<ds_list_size(flrlist); p+=1) {
  str+=string(ds_list_find_value(flrlist, p));
  if (p<ds_list_size(flrlist)-1) { str+=", "; }
}
show_message(str+"}");

if (!ds_map_exists(global.floors, checkflr)) {
  show_message("Tried to check floor "+string(checkflr)+", but it doesn't exist!# #(Passed {"+string(lower)+", "+string(upper)+"})");
}*/

for (p=0; p<ds_list_size(flrlist); p+=1) {
  check=ds_list_find_value(flrlist, p);
  if (ds_map_find_value(check, "type")!=TY_ROOM) { continue; } // Can't connect stairs to stairs
  checkcon=ds_map_find_value(check, "connections");
  if (ds_list_find_index(checkcon, -1)<0) { continue; } // Can't connect to filled rooms
  ds_list_add(valid, check);
}

/* If all rooms on the floor are filled, return false and destroy stairs */
if (ds_list_size(valid)<=0) {
  ds_list_destroy(valid);
  ds_list_destroy(connections);
  ds_map_destroy(stairs);
  return false;
}

/* Otherwise, pick a random valid room and connect away! */
ds_list_shuffle(valid);
check=ds_list_find_value(valid, 0);
ds_list_destroy(valid);
checkcon=ds_map_find_value(check, "connections");
p=ds_list_find_index(checkcon, -1);
ds_list_replace(checkcon, p, stairs);
ds_list_add(connections, check);

if (upper==ds_map_find_value(rm, "floor")) {
  ds_list_add(connections, rm);
}

ds_list_add(flrlist, stairs);
//show_message("Added stairs to floorlist, ID = "+string(stairs));

return true;

var rm, flr, check, dir, connections, checkcon, dir2, p, valid, invalid;
rm=argument0;
dir=argument1;
dir2 = (dir + 2) mod 4;

connections=ds_map_find_value(rm, "connections");
if (ds_list_find_value(connections, dir)>=0) { return false; }

flr=ds_map_find_value(rm, "floor");
flr=ds_map_find_value(global.floors, flr);

valid=ds_list_create();
invalid=ds_map_find_value(rm, "invalid");

/* Find all valid rooms */
for (p=0; p<ds_list_size(flr); p+=1) {
  check=ds_list_find_value(flr, p);
  if (check==rm) { continue; } // Can't connect a room to itself
  if (ds_map_find_value(check, "type")==TY_STAIRS) { continue; } // Stair connections are handled separately
  if (ds_list_find_index(invalid, check)>=0) { continue; } // Can't connect to invalid rooms
  checkcon=ds_map_find_value(check, "connections");
  if (ds_list_find_value(checkcon, dir2)>=0) { continue; } // Can't connect to a room w/ the position filled
  ds_list_add(valid, check);
}

/* If no valid rooms exist, return false */
if (ds_list_size(valid)<=0) {
  ds_list_destroy(valid);
  return false;
}

/* Choose a random valid room */
ds_list_shuffle(valid);
check=ds_list_find_value(valid, 0);
ds_list_destroy(valid);

/* Add the old room's connections to the invalid list of the new room */
checkcon=ds_map_find_value(check, "invalid");
Concat(invalid, checkcon);
checkcon=ds_map_find_value(check, "connections");
Concat(invalid, checkcon);

/* Connect the rooms */
ds_list_replace(checkcon, dir2, rm);
ds_list_replace(connections, dir, check);

return true;

var l1, l2, val, p;
l1=argument0;
l2=argument1;

for (p=0; p<ds_list_size(l2); p+=1) {
  val=ds_list_find_value(l2, p);
  if (ds_list_find_index(l1, val)<0) {
    ds_list_add(l1, val);
  }
}

/* Format:

  global.floors {key, val} = {floor #, ds_list of rooms on the floor}
  room {key, val} = {
    "type" : const TY_ROOM|TY_STAIRS,
    "floor" : real floor_its_on (-1 for stairs)
    "connections" : ds_list{N, S, E, W}|{UPPER, LOWER} rooms_its_connected_to,
    "invalid" : ds_list rooms_it_cannot_connect_to
  }
  
  When adding a room:
  
  1) Connect to random valid room on same floor if one exists
     *Valid means not in "invalid" list and at least one opening in "connections" list
     *Also, valid connections are NS and EW.
  2) If no such room exists, create a staircase on floor +/- 1 and connect to that
     *Staircases can only connect 2 rooms on floors w/ dz=1 (their connections list is 2-element upper/lower rooms)
  3) Once connected, invalid+=connected_rooms_invalid + connected_rooms_connections
  4) Repeat #1-3 n times where 1<=n<=4 (at least 1 connection, randomly up to 4 connections)
*/
var flr, flrlist, rm, connections, invalid, p;
if (ds_map_empty(global.floors)) {
  rm=ds_map_create();
  flr=0;
  connections=ds_list_create();
  repeat (4) { ds_list_add(connections, -1); }
  invalid=ds_list_create();
  ds_map_add(rm, "type", TY_ROOM);
  ds_map_add(rm, "floor", flr);
  ds_map_add(rm, "connections", connections);
  ds_map_add(rm, "invalid", invalid);
  
  flrlist=ds_list_create();
  ds_list_add(flrlist, rm);
  ds_map_add(global.floors, flr, flrlist);
//  show_message("Added first room to floor list, ID = "+string(rm));

}
else {
  flr=irandom_range(global.minfloor-global.builddown, global.maxfloor+global.buildup);
  if (!ds_map_exists(global.floors, flr)) {
    flrlist=ds_list_create();
    ds_map_add(global.floors, flr, flrlist);
  }
  else {
    flrlist=ds_map_find_value(global.floors, flr);
  }
  
  rm=ds_map_create();
  ds_map_add(rm, "type", TY_ROOM);
  ds_map_add(rm, "floor", flr);
  
  connections=ds_list_create();
  repeat(4) { ds_list_add(connections, -1); }
  invalid=ds_list_create();
  
  ds_map_add(rm, "connections", connections);
  ds_map_add(rm, "invalid", invalid);
  
  if (flr>global.maxfloor) {
    if (!AddStairs(global.maxfloor, flr, rm)) {
      ds_list_destroy(invalid);
      ds_list_destroy(connections);
      ds_map_destroy(rm);
      global.buildup=0;
      return false;
    }
  }
  else if (flr<global.minfloor) {
    if (!AddStairs(flr, global.minfloor, rm)) {
      ds_list_destroy(invalid);
      ds_list_destroy(connections);
      ds_map_destroy(rm);
      global.builddown=0;
      return false;
    }
  }
  
  for (p=0; p<4; p+=1) {
    if (irandom(100)<25) {
      Connect(rm, p);
    }
  }
  
  global.minfloor=min(flr, global.minfloor);
  global.maxfloor=max(flr, global.maxfloor);
  ds_list_add(flrlist, rm);
//  show_message("Added new room to floor list, ID = "+string(rm));
}
return true;

var stack, node, cons, n, s, e, w, visited, type, xx, yy, flr;
flr=argument0;
if (!ds_map_exists(global.floors, flr)) { return false; }
flr=ds_map_find_value(global.floors, flr);
if (ds_list_size(flr)<=0) { return false; }
node=ds_list_find_value(flr, 0);

stack=ds_stack_create();
visited=ds_map_create();
ds_stack_push(stack, 0);
ds_stack_push(stack, 0);
ds_stack_push(stack, node);

while (!ds_stack_empty(stack)) {
  node=ds_stack_pop(stack);
  yy=ds_stack_pop(stack);
  xx=ds_stack_pop(stack);
  
  if (ds_map_exists(visited, node)) { continue; }
  
  ds_map_add(visited, node, 0);
  
  cons=ds_map_find_value(node, "connections");
  type=ds_map_find_value(node, "type");
  flr=ds_map_find_value(node, "floor");
  with (instance_create(xx, yy, roomObj)) {
    mytype=type;
    connections=cons;
    myfloor=flr;
  }
  if (type!=TY_ROOM) { continue; }
  
  n=ds_list_find_value(cons, 0);
  e=ds_list_find_value(cons, 1);
  s=ds_list_find_value(cons, 2);
  w=ds_list_find_value(cons, 3);
  
  if (n>=0) {
    ds_stack_push(stack, xx);
    ds_stack_push(stack, yy-32);
    ds_stack_push(stack, n);
  }
  if (s>=0) {
    ds_stack_push(stack, xx);
    ds_stack_push(stack, yy+32);
    ds_stack_push(stack, s);
  }
  if (e>=0) {
    ds_stack_push(stack, xx+32);
    ds_stack_push(stack, yy);
    ds_stack_push(stack, e);
  }
  if (w>=0) {
    ds_stack_push(stack, xx-32);
    ds_stack_push(stack, yy);
    ds_stack_push(stack, w);
  }
  
}
ds_stack_destroy(stack);
ds_map_destroy(visited);

/* Since the rooms may have been off-screen, move them so the top-left is at (0,0) */
n=room_height*10;
w=room_height*10;
with (roomObj) {
  if (x<w) { w=x; }
  if (y<n) { n=y; }
}
with (roomObj) {
  x-=w;
  y-=n;
}