next »

[MattFitz]

No problem! Feel free to share any methods you come up with - I'll be making the jump to Studio soon, lol.

[sedna16]

I managed to create a simple random dungeon creator on studio.

I'll be posting a tutorial soon, either here or on my blog.

Algo: same hall length, same room size

geen dot - starting point
red dot - end point

Screenshot

[sedna16]

I know theres a more easy way to generate dungeons, but this is the first generator that I've made.

Here it is -

obj_generator ->

//Initial Coords
x = 0;
y = 0;

grid_size = 16;  // must be even number
map_size = 400;  // must be even number

//center of the map
x = (map_size*grid_size) div 2;
y = (map_size*grid_size) div 2;

//make sure you are on aligned on grid
move_snap(grid_size,grid_size);


randomize(); // gamemaker isnt really random as you would think, so you need this

starting_room = choose(1,2,3);
scr_rooms(starting_room,grid_size);
instance_create(x,y,obj_start);
instance_create(0,0,obj_hud);
instance_create(x,y,obj_player);

// Random Number of Rooms
randomize();
room_num = choose((map_size/2)-20,(map_size/2));

//Start Creating Dungeon
//repeat(room_num)
for(room_i = 0; room_i <= room_num; room_i +=1)
{
    scr_hall();
    scr_hall();
   
    randomize();
    create_room = choose(1,2,3,4);
    if(room_i = room_num)
    {
        instance_create(x,y,obj_center);
        scr_rooms(4,grid_size);
    }
    else
    {
        instance_create(x,y,obj_center);
        scr_rooms(create_room,grid_size);
    }
}



view_follow[0] = obj_start;

scr_floor() ->

x_coord = argument0;
y_coord = argument1;

if(!position_meeting(x_coord,y_coord,obj_floor))
{
    instance_create(x_coord,y_coord,obj_floor);
}

scr_walls() ->

//  XXX
//  XoX
//  XXX


if(!instance_position(x-16,y-16,obj_wall) and !instance_position(x-16,y-16,obj_floor))
{
    instance_create(x-16,y-16,obj_wall);
}

if(!instance_position(x,y-16,obj_wall) and !instance_position(x,y-16,obj_floor))
{
    instance_create(x,y-16,obj_wall);
}

if(!instance_position(x+16,y-16,obj_wall) and !instance_position(x+16,y-16,obj_floor))
{
    instance_create(x+16,y-16,obj_wall);
}

if(!instance_position(x+16,y,obj_wall) and !instance_position(x+16,y,obj_floor))
{
    instance_create(x+16,y,obj_wall);
}

if(!instance_position(x+16,y+16,obj_wall) and !instance_position(x+16,y+16,obj_floor))
{
    instance_create(x+16,y+16,obj_wall);
}

if(!instance_position(x,y+16,obj_wall) and !instance_position(x,y+16,obj_floor))
{
    instance_create(x,y+16,obj_wall);
}

if(!instance_position(x-16,y+16,obj_wall) and !instance_position(x-16,y+16,obj_floor))
{
    instance_create(x-16,y+16,obj_wall);
}

if(!instance_position(x-16,y,obj_wall) and !instance_position(x-16,y,obj_floor))
{
    instance_create(x-16,y,obj_wall);
}

scr_rooms() ->

room_type = argument0;
grid_size = argument1;


if(room_type = 1)
{
    //3x3
    x_start = x-grid_size;
    y_start = y-grid_size;
   
    for(a=0; a<=2; a+=1)
    {
        for(b=0; b<=2; b+=1)
        {
            if(!position_meeting(x_start+(grid_size*a),y_start+(grid_size*b),obj_floor))
            {
                //instance_create(x_start+(grid_size*a),y_start+(grid_size*b),obj_floor);
                scr_floor(x_start+(grid_size*a),y_start+(grid_size*b));
               
            }
        }
    }
}
else if(room_type = 2)
{
    //3x4
    x_start = x-grid_size;
    y_start = y-grid_size;
   
    for(a=0; a<=2; a+=1)
    {
        for(b=0; b<=3; b+=1)
        {
            if(!position_meeting(x_start+(grid_size*a),y_start+(grid_size*b),obj_floor))
            {
                //instance_create(x_start+(grid_size*a),y_start+(grid_size*b),obj_floor);
                scr_floor(x_start+(grid_size*a),y_start+(grid_size*b));
               
            }
        }
    }
    randomize();
    new_coord = choose(1,2);
    y = y+(grid_size*new_coord);
}
else if(room_type = 3)
{
    //4x3
    x_start = x-grid_size;
    y_start = y-grid_size;
   
    for(a=0; a<=3; a+=1)
    {
        for(b=0; b<=2; b+=1)
        {
            if(!position_meeting(x_start+(grid_size*a),y_start+(grid_size*b),obj_floor))
            {
                //instance_create(x_start+(grid_size*a),y_start+(grid_size*b),obj_floor);
                scr_floor(x_start+(grid_size*a),y_start+(grid_size*b));
               
            }
        }
    }
    randomize();
    new_coord = choose(1,2);
    x = x+(grid_size*new_coord);
}
else if(room_type = 4)
{
    //5x5
    x_start = x-grid_size;
    y_start = y-grid_size;
   
    for(a=0; a<=4; a+=1)
    {
        for(b=0; b<=4; b+=1)
        {
            if(!position_meeting(x_start+(grid_size*a),y_start+(grid_size*b),obj_floor))
            {
                //instance_create(x_start+(grid_size*a),y_start+(grid_size*b),obj_floor);
                scr_floor(x_start+(grid_size*a),y_start+(grid_size*b));
               
            }
        }
    }
    randomize();
    new_dir = choose(0,1,2,3);
    switch(new_dir)
    {
        case 0:
        x = x+(grid_size*2)
        break;
       
        case 1:
        y = y+(grid_size*2)
        break;
       
        case 2:
        x = x-(grid_size*2)
        break;
       
        case 3:
        y = y-(grid_size*2)
        break;
    }
}

scr_hall() ->

randomize();
    choose_dir = choose(0,1,2,3);
    randomize();
    choose_dis = choose(4,7,7);
    switch(choose_dir)
    {
        case 0:
        repeat(choose_dis)
        {
            x = x+grid_size;
            scr_floor(x,y);
        }
        break;
       
        case 1:
        repeat(choose_dis)
        {
            y = y+grid_size;
            scr_floor(x,y);
        }
        break;
       
        case 2:
        repeat(choose_dis)
        {
            x = x-grid_size;
            scr_floor(x,y);
        }
        break;
       
        case 3:
        repeat(choose_dis)
        {
            y = y-grid_size;
            scr_floor(x,y);
        }
        break;
    }

[Gradius]

I know theres a more easy way to generate dungeons, but this is the first generator that I've made.

Here it is -
*snip*

A bit of directional math could shorten those scripts quite a bit (making them quicker to look through)...

Code:

scr_walls() becomes:
var xx, yy;
for(i=0; i=<8; i++)
{
        //Rounded up so it either returns 0 or 1, for those square corners
xx=ceil(lengthdir_x(1,i))*16;
yy=ceil(lengthdir_y(1,i))*16;
if(!instance_position(x-xx,y-yy,obj_wall) && !instance_position(x-xx,y-yy,obj_floor))
{
instance_create(x-xx,y-yy,obj_wall);
}
]

scr_hall() becomes

Code:

dir=round(random(4));
choose_dis=choose(4,7,7)
x=x+lengthdir_x(choose_dis*grid_size,dir);
y=y+lengthdir_y(choose_dis*grid_size,dir);
scr_floor(x,y);

[Reggie02]

Hey guys
I'm new to game maker and i'm working on an engine for a platformer. So far, I have variable jumping and movement. I wanted to implement ledge grabbing next but I just can't find any sort of help/tutorial explaining this so I was wondering if I could get help over here. My collision checking for my blocks in done like so (if anyone finds this relevant:
//When colliding with the object stop moving
move_contact_solid(direction,0)
if place_meeting(x,y+1,obj_block) then vspeed=0
if place_meeting(x,y-1,obj_block) then vspeed=0
if place_meeting(x+1,y,obj_block) then hspeed=0
if place_meeting(x-1,y,obj_block) then hspeed=0

Thanks in advance
btw I posted this in another thread but got no reply