[Dúvida] Sistema de movimento de peças no xadrez

Código:

with (obj_Pieces)
    {
    if !place_snapped(32, 32)
       {
       move_snap(32, 32);
       }
    }

if (casa . coluna - bispo . coluna == casa . linha - bispo . linha){...

saim escreveu:
Se conseguir fazer as condições do cavalo, me conte como.
Sério.

• (x,y) = posição atual • (u,v) = nova posição ƒ 1: (x+2,y+1) ƒ 2: (x+1,y+2) ƒ 3: (x-1,y+2) ƒ 4: (x-2,y+1) ƒ 5: (x-2,y-1) ƒ 6: (x-1,y-2) ƒ 7: (x+1,y-2) ƒ 8: (x+2,y-1)

• Diminui em um o índice horizontal;
  
• Diminui em um o índice vertical;
  
• Verifica se um dos dois ficou menor que zero (está fora do campo):
  
• - Se sim, termina o loop;
  
• Verifica se há alguma peça na casa representada pelos novos índices (isto obrigatoriamente após verificar se não está fora do campo; caso contrário, você tentaria acessar a array com índices fora dos limites);
  
• - Se sim, verifica que peça é, faz o que for devido e termina o loop;
  
• Fim da iteração, isto é, se chegar aqui, valida a casa e vai para a próxima iteração.
  

Código:

mx = ...; // posição atual da peça
my = ...; // posição atual da peça

mx2 = ...; // nova posição da peça
my2 = ...; // nova posição da peça

ps = ...; // tipo da peça
cs = ...; // cor da peça

if ps != -1 {
    if mouse_check_button_released(mb_left) {

        mx2 = floor(mouse_x/t_w);
        my2 = floor(mouse_y/t_w);
       
        // Processar regras de movimento
        switch (ps) {
            case p_peao:
                if cs = t_preto {
                    if mx2 = mx && my2 = my+1 && ds_grid_get(tab,mx,my+1) = -1 {
                        ds_grid_set(tab,mx,my,-1);
                        ds_grid_set(cor,mx,my,-1);
                       
                        ds_grid_set(tab,mx2,my2,ps);
                        ds_grid_set(cor,mx2,my2,cs);
                    }
                } else {
                    if mx2 = mx && my2 = my-1 && ds_grid_get(tab,mx,my-1) = -1 {
                        ds_grid_set(tab,mx,my,-1);
                        ds_grid_set(cor,mx,my,-1);
                       
                        ds_grid_set(tab,mx2,my2,ps);
                        ds_grid_set(cor,mx2,my2,cs);
                    }
                }
            break;
            
            case p_torre:
                if mx = mx2 || my = my2 {
                    // Como cada peça tem uma id a partir de 0,
                    // se retornar -1, não há outras peças no caminho.
                    // Aqui eu uso sign(m2-m) para a própria peça não ser considerada

                    var v;
                    v = (ds_grid_get_max(tab,mx+sign(mx2-mx),my+sign(my2-my),mx2,my2));
                    
                    if v = -1 {
                        ds_grid_set(tab,mx,my,-1);
                        ds_grid_set(cor,mx,my,-1);
                        
                        ds_grid_set(tab,mx2,my2,ps);
                        ds_grid_set(cor,mx2,my2,cs);
                    }
                }
            break;

            case p_bispo:
                // Um movimento na diagonal é um quadrado, ou seja,
                // altura e largura são iguais entre x1,y1 x2,y2.
                // Por isso se mx2-mx e my2-my são iguais, eu tenho um movimento
                // perfeito na diagonal.

                var w,h;
                w = mx2-mx;
                h = my2-my;
                
                // Usando abs e sign na fórmula eu deixo a checagem dinâmica
                // e funcionará não importando a direção da diagonal
                if (abs(w) = abs(h)) {
                    var n,v;
                    v = -1;
                    
                    // Imitar efeito de ds_grid_get_max na diagonal
                    for (n = 1; n < abs(w)+1; n += 1) {
                        v = max(v,ds_grid_get(tab,mx+n*sign(w),my+n*sign(h)));
                    }
                    
                    if v = -1 {
                        ds_grid_set(tab,mx,my,-1);
                        ds_grid_set(cor,mx,my,-1);
                        
                        ds_grid_set(tab,mx2,my2,ps);
                        ds_grid_set(cor,mx2,my2,cs);
                    }
                }
            break;

            // ...

        }
   
    }
}

invalida_tudo:

valida_peao:

valida_torre:

valida_cavalo:

valida_bispo:

valida_rainha:

valida_rei:

shatterhand2 escreveu:Eu não tenho certeza de como o GM trata cada um, mas tenho a impressão que criar um array com 2 dimensões é mais rápido que criar um grid ,não?

Ou talvez seja a mesma coisa.