Checar objetos e fora da room

eu tenho uma room dividida em 32x32 e objetos tambem 32x32 q serão criados nesse grid .

Oque ocorre é que um desses objs 32x32 gera outro obj 32x32 (32 pixeis a direita), a origem ta 0,0 , como checar se ja há um obj desses a direita para se houver, não poder criar ?
eu tentei collision_point e place_meeting .

E outra, quero checar tb se a direita dele n é o final da room, pq se for ele n poderá criar.

THX

Tentou instance_position()?

como usaria isto ? *-*

var next_i;
next_i = instance_position(x+32,y,OBJ);

if !instance_exists(next_i) instance_create(x+32,y,OBJ);

Não sei se vai funfar, peguei esse código baseado no help do GM

não funcionou =/ se puder testar ai ou me fazer uma engine seria mto bom

Um objeto que cria outro objeto não é uma boa ideia...
Por mais que um "if" impeça-o de criar infinitos outros objetos, o objeto ficará constantemente fazendo a checagem para saber se pode ou não criar o objeto, e isso, consome memória e atrapalha o desempenho do jogo...

É melhor você criar um único objeto que faça um loop (for ou while, o que você preferir) e crie os objetos. Mas para saber quantos objetos esse objeto deve criar, primeiro você deve fazer um calculo medindo a distancia do ponto que este objeto se encontra até o ponto máximo de criação e dividir por 32, que é a largura do seu objeto.

Por exemplo, para fazer isso do canto esquerdo até o direito da room, ficaria algo mais ou menos assim:

Código:

Qtd = (room_width - x)\32;
for (i = 0; i < Qtd; i+=1){
instance_create(x+32*i,y,objeto);
}

Leve em consideração que o for criará todos os objetos necessários de uma só vez (em um único frame).

Willy eu fiz o seguinte eu coloquei um variavel define que se ela for 0 o código é iniciado e no final do código eu coloquei define = 1 , oq pra mim pararia a execução, mas ela continua acontecendo ? '-'

E n da pra usar for pq a criação do proximo obj depende de ql é esse obj q vai criar entendeu ?

Isso apenas impede que mais objetos sejam criados, mas a checagem da variável permanecerá acontecendo... Geralmente essa simples checagem não consome muita memória, mas se este não for o caso, faça com esse objeto se autodestruir e crie um outro objeto no lugar. Esse novo objeto seria apenas a sprite.

Bom, voltando ao foco da sua pergunta, fiz uma pequena engine que provavelmente vai te ajudar. Ela não consumirá memória pois a criação dos objetos está no create.
Download

[Edit]
Desculpe, cometi um pequeno engano na engine... No create do o_azul, eu coloquei duas vezes "!instance_place(x+32,y,o_vermelho)". Na verdade, era pra ser um o_vermelho e um o_azul. Essa checagem serve pra não criar o_azul em cima de outro o_azul.  

Perfeito willy, vlw msm
mas agr tem um negócio shuahsauhs a room ta 32000x32000 no caso daria 1 milhão de objetos na room. O FPS só fica em 0 perto das 6mil instâncias oq ta mto longe doque eu queria, tem como transformar o obj em um tile ou sei la ? eu fiz oq vc falou de deletar o obj e por outro só com a imagem e eu fiz. Mas ainda só chega 6mil , há algo a se fazer ? o.o

Wow, realmente é uma room grande!
A melhor saída é desativar os objetos que não vemos, ou seja, os objetos que estão fora da view, e para isso, usaremos a função instance_deactivate_region() para desativar e a função instance_activate_region para ativar os objetos que foram desativados.

Faça o seguinte: Crie um objeto e nomeie-o como quiser. Adicione o evento step e coloque o seguinte código:

Código:

//Desativa todas as instâncias que estiverem fora da view.
instance_deactivate_region(view_xview[0],view_yview[0],view_wview[0],view_hview[0],false,true);

//Ativa todas as instâncias que estiverem dentro da view.
instance_activate_region(view_xview[0]-96,view_yview[0]-96,view_wview[0]+96,view_hview[0]+96,true);

Explicando:

Deactive:
Os quatro primeiro argumentos servem para definir uma área, que no caso, é a área da view. O quinto argumento serve para saber se os objetos a serem desativados está dentro (true) ou fora (false) dessa área. O ultimo argumento pergunta se você quer desativar todos os objetos exceto o objeto que está usando esse código.

Activate:
Os argumentos são os mesmos, porém, não existe o sexto argumento. Repare que eu coloquei uma margem extra de 96 pixels para fora da view. Isso serve para evitar que objetos "apareçam" tarde de mais ou cedo de mais na view. Aumente se achar necessário.

Espero ter ajudado... Dúvidas é só falar.

no caso vai dar um cast desgramado pra iniciar o jogo neh ?
Tipo, esperarei os 1 milhao de objs serem criados pra poder mexer pq até a lá o FPS será quase nulo u.u
Mas vlw, ja ta bem legal agr huahsuahs

Só o for resolveria nessa situação por ser significativamente mais rápido, mas como você disse que é inviável, o jeito é arcar com as consequências. XD

Você pode improvisar deixando a tela preta e colocar um "Carregando..." no canto da tela só pra disfarçar.

eu já coloquei o carregando, eu to usando uma room 3200x3200 q da 10000 instancias e ja demora sahushaush mas ta de boa .

Objetos em grid costumam ser melhor gerenciados por arrays, ou globais ou de um objeto-controle. Provavelmente é o que o willy fez, mas eu não vi a engine.

Olha, provavelmente é possível ir criando a grid à medida que a room vai sendo revelada. A primeira ideia realmente é criar tudo de uma vez e viver confortável, mas se isso está gerando problemas, talvez dê pra encontrar uma saída "on the fly" (não consegui traduzir essa expressão, mas como é pra você, nem tentei muito).
Pra achar a saída, temos que conhecer os critérios. O objeto[0, 1] depende do tipo de objeto [0, 0]? Mole, podemos ter essa informação na array. Depende de alguma variável do objeto acima ou abaixo? Podemos criar novas arrays, alimentadas pelos objetos. Os objetos podem mudar ao longo do jogo e você quer que os novos objetos não notem essa mudança? Bom, podemos ter uma array pra segurar a situação inicial, mas já começa a complicar.
Agora, se os objetos estão lá só pra aparecer na tela, a ideia dos tiles pode ser uma boa, viu?

eles estarão lá apenas para aparecer sim
Eu n faço ideia de como fazer isso por array pq além de o proximo obj a ser criado depender do outro, tem um obj q passa uma informação pro próximo a ser criado usando with instance_create. e n sei como transformar esses objs em tile *-*

saim escreveu:Olha, provavelmente é possível ir criando a grid à medida que a room vai sendo revelada.

Use a ideia do saim com a minha e seja feliz!

Faça o seguinte:
1 - No step do objeto, faça como estava fazendo antes, ou seja, checando se já foi criado ou não. Porém, acrescente a condição de que o mesmo está dentro da view (acrescente uma margem também!). Dessa forma, não será criado tudo de uma única vez.
2 - Acrescente o sistema de ativar e desativar instâncias.

Se tudo correr como esperado, os objetos não serão criados de uma só vez - evitando a tela de "carregando" - e mesmo que tenha milhões de instâncias na room, o FPS permanecerá alto pois apenas as instâncias dentro da view estarão ativas.

Ahhh, entendi kkkkkkk como n pensamos nisso cara kkkkkkkk agora tudo ficou claro shauhsaush
vlw saim e vlw willy

Só detalhando um pouco, a idéia das arrays. O que eu sugiro que você faça é criar uma array que sirva como um mapa de objetos. Cada objeto vai ocupar um índice da array. Se os objetos medissem 1x1, a posição na tela seria a mesma posição da array. Você pode ter muitas arrays, uma pra cada informação que julgar importante. Por exemplo, saber se o objeto já foi criado.
Na hora de ativar/desativar a tela, você repopula a array. "Repopula" é uma palavra que eu inventei agora, não sei se existe de verdade. Tipo, no create de um controle, você pode fazer um lance assim:

Código:

// lar e alt são largura e altura da array
// lado é o tamanho dos objetos
lado := 32;
lar := ceil(room_width / lado); alt := ceil(room_height / lado);
var i, j;
for (i :=0; i < lar; i += 1){
   for (j :=0; j < alt; j += 1){
      foi_criado[i, j] := false;
      objeto[i, j] := noone; // só declarando a array, sem ninguém ainda
      }
   }
// pronto, a array "foi_criado" armazena se o objeto já existe ou não.
// é importante saber, também, o tanto da array que a view mostra.
lar_na_view := ceil(view_wview[0] / 32) + 2; // +2 é pra ter um além à esquerda e outro à direita
alt_ne_view := ceil(view_hview[0] / 32) + 2;

Não sei qual condição você usa pra criar os objetos, então não tenho como te mostrar. Vou inventar um jeito de fazer um tabuleiro xadrez, aqui. Tem jeito mais fácil de fazer o que eu vou fazer, mas isso é só pra mostrar o tipo de raciocínio.

Código:

var i, j, primeiro_x, primeiro_y, ind_x, ind_y;
primeiro_x := max(floor(view_xview / 32) - 1, 0); // a posição da view na array
primeiro_y := max(floor(view_yview / 32) - 1, 0); // -1 é pra pegar o da esquerda, max é pra não pegar valor negativo
for (i:= 0; i < lar_na_view; i += 1){
   for (j := 0; j < alt_na_view; j += 1){
      // define o índice das arrays a ser usado
      ind_x := primeiro_x + i;
      ind_y := primeiro_y + j;
      if (foi_criado[ind_x, ind_y] == false){
         roda_script_criar(ind_x, ind_y); // não sei o que colocar aqui
         foi_criado[ind_x, ind_y] := true;
         }
      }
   }

aí, esse script "roda_script_criar" é você quem cria. Vou fazer a cor depender da cor do objeto da coluna anterior e, se for a primeira coluna, depender da linha anterior

Código:

var ind_x, ind_y;
ind_x := argument0; ind_y := argument1; // só pro script entender onde ele está
if (ind_x == 0){ // se é a primeira coluna
   if (ind_y == 0){ // se é a primeira linha
      objeto[ind_x, ind_y] := instance_create(lado * ind_x, lado * ind_y, obj_branco); // o primeiro é branco
      }
      else { //se é a primeira coluna, mas não é a primeira linha
         if (objeto[ind_x, ind_y - 1] . object_index == obj_branco){ // se acima tem um branco
            objeto[ind_x, ind_y] := instance_create(lado * ind_x, lado * ind_y, obj_preto);
            }
            else { // se acima NÃO tem um branco
               objeto[ind_x, ind_y] := instance_create(lado * ind_x, lado * ind_y, obj_branco);
               }
   }
   else { // se não é a primeira coluna (aí não interessa saber a linha)
      if (objeto[ind_x - 1, ind_y] . object_index == obj_branco){ // se à esquerda tem um branco
         objeto[ind_x, ind_y] := instance_create(lado * ind_x, lado * ind_y, obj_preto);
         }
         else { // se à esquerda NÃO tem um branco
            objeto[ind_x, ind_y] := instance_create(lado * ind_x, lado * ind_y, obj_branco);
            }
      }

o script ficou ruim (já vi um bug nele), mas acho que deu pra entender a idéia geral.