Trabalhando com Arrays e callfunc [Avançado]

[Mooka]

Não é uma dúvida muito frequente mas vale a pena explicar isso, visto que envolve os comandos getd, setd, functions e o for, muito úteis e de pouco conhecimento dos Scripts.

Sabe-se que as Arrays do emulador só vão até 127 vetores, em alguns casos é necessário um limite maior, vou usar este problema como exemplo para explicar os comandos setd, getd e function.

Antes de começar, vale ressaltar algumas caracteríscas das Arrays.

• setarray é o comando para definir uma cadeia de variáveis (vetores).
  

  setarray @exemplo[0], 1, 2, 3, 4, 5; // Define 5 vetores.
  setarray @exemplo[5], 6, 7, 8, 9, 10; // Define 5 vetores a partir do vetor [5], esta array tem seu fim no vetor [9] (valor 10).

  
  

• As Arrays começam no [0], ou seja: Var[4] na equivale ao valor 5. (vulgo exemplo acima)
  
• getarraysize(var) retorna o número de elementos (vetores) da array.
  

  dispbottom getarraysize(@exemplo); //Mostra 10

  
  

• Podemos alterar valores de um vetor através do comando Set.
  

  set @exemplo[5],20;

  
  

• set @exemplo,0; é equivalente a set @exemplo[0],0;. O emulador adota como default o vetor [0].
  

Como ultrapassar o limite de 127 vetores da array?

Na verdade não vamos ultrapassar pois isto é impossível (sem alterar a source), usaremos de outros meios para isto. Um Sistema.

Objetivo: Ao identificar que a array chegou ao seu limite fazer o sistema passar a armazenar os valores em outra array, dando assim continuidade e interligando as arrays.

Para fazer isso é necessário o uso de dois comandos, setd e getd.

Setd e Getd são comandos mais dinâmicos para se trabalhar com variáveis, diferente do set normal que pede o endereço(nome) da variável, o setd pede uma String (texto: "string"). Sendo assim, é possível manipular o nome da variável com outras variáveis. O mesmo vale para getd, porém com a ação inversa, retornar o valor.

Sintaxes:

setd "<nome da variável>",<valor>;
getd("<nome da variável>")

Mas não é só isso, também é necessário algo de extrema importância para dinamizar o sistema: O comando Function.

Callfunc é um comando que chama outro bloco de comandos, ou seja, você pode ter neste outro bloco, códigos que vão agir de diferentes formas de acordo com os argumentos passados no callfunc.

O callfunc vem acompanhado de outros 2 comandos para auxíliar seu funcionamente, return e getarg.

Return faz com que seguimento do código volte para o local de onde foi chamado (o comando callfunc) e siga dali em diante, também pode ser retornado junto a ele valores e strings no caso do callfunc ser chamado dentro de um comando. [Exemplo:if(callfunc("subtrair",4,2)== 2)]

Getarg é o comando para acessar os argumentos passados pelo callfunc, se o valor não existir o emulador mostra um erro no console. Para evitar isso, pode-se usar o argumento opcional dele e definir um valor padrão que será usado caso não tenha sido passado nenhum pelo callfunc.

Sintaxes:

callfunc "<função>"{,<argumento>,...<argumento>}; // Para chamar a função

getarg(<índice>{,<valor padrão="">})

function        script  Exemplo {
       if(getarg(0)==2) mes "Olá"; else mes "Hello";
       return; // Retorna para onde foi chamado (callfunc), do contrário o script se encerra aqui.
}

Agora você já sabe tudo que é necessário para alcançar o objetivo, ultrapassar o limite da Array (ou quase isso).

Algumas notas lógicas:

• é necessário passar para outra Array quando a anterior chegar ao seu limite.
  
• Precisaremos de um contador que possua o valor total de vetores.
  
• Atualizar o contador sempre que o callfunc for usado.
  
• O callfunc deve possuir 3 argumentos obrigatórios e mais outros 2 opcionais para facilitar o desenvolvimento do sistema:
  
  • Nome da variável
    
  • Vetor da variável
    
  • Valor a ser definido
    
  • [Opcional] Um argumento que nos informe se a variável é Integer (Adotemos 0) ou String (Adotemos 1)
    
  • [Opcional] Préfixo da variável (@,$@,#, etc)
    

Criando o código.

Adotemos o nome do contador como <varnome>_size, onde <varnome> será uma instância definida por getarg(0). Também chamarei a função de SetArrayd, por causa do setd e getd.

Levaria muito tempo e texto para eu explicar passo à passo de como chegar ao código final, então estarei mostrando-o logo e explicar o que cada linha representa.

function        script  Exemplo {
       if(getarg(0)==2) mes "Olá"; else mes "Hello";
       return; // Retorna para onde foi chamado (callfunc), do contrário o script se encerra aqui.
}

callfunc("SetArrayd",<varnome>,<vetor>,<valor>{,<tipo{,<préfixo>}});



function        script  SetArrayd       {

       if(getarg(1) < 0) return -1;

// Calculando a array que adicionaremos o Vetor

       if((getarg(1) / 127) != 0) set .@VarIndex, (getarg(1) / 127); 

//Abreviando os comandos

       setd .@VarSize$, (getd(getarg(4,"")+getarg(0)+"_size"); // isto equivale a <varname>_size.
       setd .@VarNome$, (getd(getarg(4,"")+getarg(0)+"_"+.@VarIndex$+(!getarg(3) ? "" : "$")));


// Calculando o tamanho de <varname>_size.

       if(getarg(1) >= getd(.@VarSize$)) setd .@varName$+"_size",getd(.@varName$+"_size")+1;
       if(getarg(2) == 0 && getd(.@VarNome$+"["+getarg(1)+"]") != 0 && (getd(.@VarNome$+"["+getarg(1)+"]")-1) >= 0) setd .@varName$+"_size",getd(.@varName$+"_size")-1;

// Checando se a variável chegou no limite.

       if(getd(.@VarNome$) >= 127)
       {
               setd .@varName$+"_size",0;
               set .@VarIndex,.@VarIndex+1;
               set .@VarNome$, (getd(getarg(4,"")+getarg(0)+"_"+.@VarIndex$+(!getarg(3) ? "" : "$"))); //Atualizando o nome
       }

// Definindo a variável

       setd .@VarNome$,getarg(2); // Eu não estou setando a variável .@VarNome$ aqui e sim <varname> (Variável passada pelo callfunc)

       return; // Volta para o local callfunc

}

callfunc("GetArrayd",<varnome>,<vetor>,<string? (1="sim)">);

function        script  SetArrayd       {
return getd(getarg(0)+(getarg(1)/127)+(getarg(2,0) ? "$" : "")+"["+getarg(1)+"]");
}

Edited February 21, 2012 by Mooka

[rafoka]

Cara, algumas definições estão estranhas.

Vetor normalmente é uma definição para justamente um array e não para um elemento do array, um elemento do array normalmente é chamado de element mesmo ou unidade. Além disso o limite delas é de 128 e não 127. Por isso a frase "Sabe-se que as Arrays do emulador só vão até 127 vetores" corretamente e mais formal poderia ser nessa forma: "Sabe-se que as arrays do emulador possuem o limite de 128 elementos/variáveis (indices variando de 0 até 127)".