{I}*{I-1}+A→A
You still have the unfixed code in your file. Could you fix it to {I}*{I+1}+A→A and try again?
Edit: Just tried it; it still says "2"... I'll keep looking.
Edit 2: There was a problem with my code. L*2+(GDB2→I)→E should be L-1*2+(GDB2→I)→E. Trying that now.

Is L set to 1?
If so, that should work...

Hm... that code is almost good. I think it would be better to use a While loop, though.
Also, there is no "order of operations" and your data for each map is now two bytes.
0->A
L*2+(GDB2->I)->E
.E is the end of the size data which we're scanning
Repeat I=E
  {I}*{I-1}+A->A
  .No order of operations, so we have to make the multiplication come first.
  I+2->I
  .Add 2
End
Copy(A+GDB1,L1,{E-1}*{E-2})
.I would work too instead of E

GDB2 wouldn't be the size of each map but rather the sum of the sizes of all the maps before it.
So instead of Data(56,42 ...)->GDB2 you would have Data(0,56,98 ...)->GDB2. 98 is 56+42, of course.
To map L indexed from 1 you would then use
Copy(GDB1+{L+GDB2-1},L1,{L+GDB2}-{L+GDB2-1})Note that you'd have to add to the end of GDB2 an extra entry that is the sum of the sizes of all the maps.
You could use your method too, but L should be L-1 in both places where it appears. It will also be somewhat slower
0->A
For(I,1,L
  A+{I+GDB2-1}->A
End
Copy(A+GDB1,L1,{L+GDB2-1})This is the fixed version of yours.

What do you mean by "How to access at the different case of L1. Like GDB?"
Edit: You can use TI-Graph Link, you just need to know to use conj( instead of Copy(, expr( instead of Exch(, and so on.

AFAIK tiDE is will be a z80 assembly IDE. I'm not sure there are any computer-based Axe compilers yet. (Informal feature request)

Okay. My suggestion was that, instead of, say, L1+5 you use M+5, where M is the pointer to the map created by the code I gave above.
To load the maps into L1, you can use Copy(. For example, to copy X bytes from GDB1 to L1, you can use Copy(GDB1,L1,X).
A more complete line of code was that which was given above:
Copy(L-1*56+GDB1,L1,56This code assumes you store 56-byte maps in the way I suggested in my previous post.

In some ways it is; both have their difficulties.
TI-BASIC is not processor-dependent, so it's easier there, but you have to implement all the math routines and a parser. Using xLib, Celtic III, or DCSB libs would be difficult.
ASM requires an emulator, but you don't necessarily need a ROM; for a lot of games you can probably get away with a few variable-related bcall and other common bcall clones and the standard shell routines.
Just my view on this. I might be wrong

I don't speak French, but using Google Translate I can tell that you seem to be misunderstanding how "->GDB1" works.
(DJ or another French speaker, please translate my response.)
GDB1 etc. are not dynamic like in BASIC. Instead, when you use "->" with them, the data you store to them is placed in the compiled program. To use it like you would in BASIC, you have to use L₁ or another place to store your data. However, this does bring up another problem; you still have to store the original data somewhere. You can use one GDB for each map, and you can add another digit to each. (You can use GDB10, GDB56, and so on, and maybe even another, like GDB623. However, I'm not sure about two extra digits.)
Another solution exists, though. If each set of data is the same size, rather than using GDB01 to access the first, GDB02 for the second, and so on, you can use GDB1 for the first, GDB1+56 for the second, GDB1+112 for the third, and so on, storing them like in the code box below. (assuming each set map is 56 bytes) (If you are using it with L like you were above, you could actually just use L-1*56+GDB1 to access the L'th set of data, indexed from 1.)
Data(...)->GDB1
.Data for map 1
Data(...)
.Data for map 2
Data(...)
.Data for map 3
.And so onThinking over it, I've realized that, if you're using maps, they are static and their content does not change. This means that you won't have to use L₁ for that purpose. Rather, you can have a line like
L-1*56+GDB1->MM now contains the address of the map data, and you can index from there. If, however, you would rather use L₁ (perhaps for convenience?) you would have to copy the data to L₁ like so: (You can use any free RAM area, not just L₁)
Copy(L-1*56+GDB1,L1,56Feel free to ask more if you are still confused; I doubt I've clarified everything.