Jump to content
BrainDen.com - Brain Teasers
  • 0
Sign in to follow this  
unreality

Question

VNA 2.0

VNA 2.0 is a game of epic cybernetic warfare - it's easy to learn, but from its simple rules comes a lot of thrilling complexity and hardcore battling. In this game of wits and passionate skill, your job is to design a killer program that can destroy its foes in a virtual environment where only one program can emerge victorious. During the actual battle, you play no part (it's run by my emulator) - it's up to your program! You can only wait for the results as two programs duel it out for control of the VNA...

***

Introduction

***

This is an improvement over an earlier game I made (here on Brainden), called VNA. It's a game that involves a cyber-environment called the VNA (which stands for Virtual Node Array), which is just a list of 200 lines of code. The code is written in VNAC (VNA Code), which I've devised based off of an ancient game known as CoreWars, and tweaked to be better and easier to learn & optimize. For VNA 2.0, I've made some changes to allow accessibility and easy learning for people who have never done an ounce of programming in their life.

In the VNA, each of the 200 lines is called a 'node' (thus the name 'Virtual Node Array'), although I use 'line' and 'node' interchangeably, and each node contains exactly one command and then three parameters (a,b,c) that the command uses as input. The parameters are separated by semicolons.

Most commands do not use all three parameters, so the extra parameters can have any value, it doesn't matter (the default is 0). Some programs may use excess values to store data.

The most basic type of command is BLANK 0;0;0, and the VNA begins with all 200 lines filled with these BLANK commands.

Then two players enter the VNA. Each player submits a program with the aim of destroying the enemy program. The two programs get entered into the VNA at random starting points, overwriting the BLANKs that they are copied over. Each program can be a maximum of 40 nodes long, thus the closest two programs can be is 40 nodes away.

[Note: the programs retain their order. You could have a 20-line program that gets copied onto line, say, 57. Thus your program will replace lines 57 through 76. If the opponent's program was 10 lines and got placed on line 112, their program would occupy lines 112 through 121]

After the programs have been copied into the VNA, the battle begins!

The game progresses in rounds. Each player has a 'pointer', which starts out at the first line of code of the player's program, wherever that may be in the VNA. In each round, player A's pointer runs one line of code (one 'node'), and then player B's pointer runs one node. After a pointer runs a node, it moves itself forward 1 node in preparation for next round [but each round, each pointer only runs ONE node, no exceptions].

[For example, take the previous Note - your program got placed at line 57 and occupied lines 57 through 76. Thus your pointer begins at line 57. Your opponent's program started at line 112, so your opponent's pointer begins at line 112. On the first round, if you go first, your pointer runs line 57. Then your opponent's pointer runs line 112. On the second round, your pointer would run line 58, and your opponent's would run line 113. On the third round, you would run line 59 and your opponent would run line 114. etc. Pointers will always increment by 1 after they are finished executing a command, unless otherwise specified!]

A pointer is destroyed when it executes a BOMB command, and the other player wins!

***

Nodes & Commands

***

So how does VNA Code work? It is very easy to learn! Each node has a simple format:

CMND a;b;c

a command name followed by a space followed by the parameters, which are separated with semicolons.

Each command does a specific action, using the parameters as its input. Here is a list of commands:


COPY a,b copies line a into line b (overriding the current line b)
JUMP a jumps the pointer to line a
BOMB destroys the pointer that ran this node
EDITA a,b a is the line number, b is the new a-value for that node
EDITB a,b a is the line nummber, b is the new b-value for that node
EDITC a,b a is the line number, b is the new c-value for that node
EDITX a,b,c a is the line number, b is the new value, c is 0/1/2 to denote a/b/c to change
BLANK what the original VNA is filled with. You can use BLANK commands too, it's basically a "do-nothing" command
EDITI a,b,c a = line number, b is how much is added to the current value, and c is 0/1/2 to denote a/b/c to change. 'I' stands for increment
SHIFT a,b,c copies line a into line b, then jumps pointer to line c
PCOPY a,b copies only the command part of line a into the command part of line b (stands for "partial copy")
SWAP a,b switches line a & line b (happens immediately)
[/codebox]

Before I go on, let me clarify EDITX and EDITI. The a & b parameters of EDITX are the same as the a & b parameters of EDITA or EDITB or EDITC. That is, the 'a' parameter designates the line number to edit, and the 'b' parameter represents the new value. However EDITX also utilizes the 'c' parameter. The c parameter can be either 0 or 1 or 2. Zero means that it is editing the line's a-param (as per EDITA). 1 means that it's editing the b-param (as per EDITB), and 2 means the c-param (as per EDITC). You wouldn't use EDITX if you knew you would always be editing a specific parameter... you would only use EDITX if the actual parameter you were editing was going to change too.

EDITI is the same thing as EDITX, except that the 'b' parameter is different: instead of representing the NEW value, it represents what is going to be added to the current value [just a shortcut I made because a common use of EDIT is to increment a parameter]

So how do you represent a line number?

The current line is always seen as 'line 0', the next line is 'line 1', the line after that is 'line 2', etc. The line BEFORE the current line is referred to as '-1', the line behind that being '-2', etc. Because of this, there is no absolute definition of line number, and the VNA wraps around as if it were an infinite loop, so line 200 or 400 or -600 is the same thing as line 0 (which is the current line).

For example, say your program is this:

COPY 0;1

when the pointer runs this node, it copies the current line (0) into the next line (1), and looks like this:

COPY 0;1

COPY 0;1

remember that the pointer increments itself each round, so next round it will run the SECOND node, which is also "COPY 0;1", and thus this program is basically an infinitely-repeating program that cannot die and cannot kill anything. After five iterations:

COPY 0;1

COPY 0;1

COPY 0;1

COPY 0;1

COPY 0;1

...etc

[[i]Note: technically, it should be COPY 0;1;0, because even though the c-parameter is not used, it still should be shown[/i]]

***

Parameters & Functions

***

So what can you use for parameters? You already know that you can put numbers in, but usually you want to have a function: a function is something, like add(5,2), that takes in input and produces an output. For example, add(5,2) will add 5 and 2 (5 & 2 are the input) and output the number 7. Functions will always churn out a number as output, and for input, they will accept either numbers or more functions. For example:

add(5,add(3,2))

will add 5 to the addition of 3 and 2, thus the output of that whole thing will be 5+(3+2) or 5+5 = 10

There is no 'official' limit to the number of functions you can have nested within other functions, but at a certain point it may clog up my VNA emulator, and usually there's no need for such uber-nesting :D

So what are the functions? [btw, a fancy name for "output" is "return". For example, add(7,2) returns 9]

[codebox]
a(n) returns the a value of the node at line n
b(n) returns the b value of the node at line n
c(n) returns the c value of the node at line n
add(m,n) returns m+n
sub(m,n) returns m-n
mul(m,n) returns m*n
div(m,n) returns m/n
mod(m,n) returns the remainder of m/n
pow(m,n) returns m^n
log(m,n) returns log (base m) of n
abs(n) returns the absolute value of n
int(n) returns the integer part of n
com(m,n,o,p,q) compares m & n. If they are equal, returns o. If m>n, returns p. If n>m, returns q
equ(m,n,o,p) compares m & n. If they are equal, returns o. Otherwise, returns p
geq(m,n,o,p) compares m & n. If m>n or m=n, return o. Otherwise, p
leq(m,n,o,p) compares m & n. If m<n or m=n, return o. Otherwise, p
nzero(n) if all three parameters of line n are 0, returns 0. Otherwise, returns 1
rand(m,n) returns a random integer from m to n, including m&n. 'n' must be greater than 'm'

As you can see, functions are pretty useful for evaluating data and deciding what to do.

***

That's It!

***

That's all you need to know! Simple, right? You may not think so yet, but it actually is. With the above stuff, you can make some awesome programs. Take this, for example:

COPY 3;40;0

EDITI -1;3;1

JUMP -2;0;0

BOMB 0;0;0

Believe it or not, this simple thing is actually a powerful program. Let's analyze what it does, line by line:

COPY 3;40;0

Okay, 'COPY a,b' copies line a into line b, overriding the current line b.

a=3

b=40

So line 3 is the line three lines forward from 'COPY'. This is the 'BOMB' line! The 40 means it copies the BOMB line into a node 40 nodes forward from the current line. Note that 40 is the minimum distance the two programs can be apart from each other, and thus the first possible space that the opponent's program could be on.

After running the COPY line, the new VNA state would be this:

COPY 3;40;0

EDITI -1;3;1

JUMP -2;0;0

BOMB 0;0;0

...

... (36ish BLANK commands would be here, I just don't have the space ;D)

...

BOMB 0;0;0

Simple so far! Next, the EDITI command. It edits line -1, which would be the COPY line, and it edits the b-parameter of the COPY line because the c-parameter of the EDITI line is 1, which corresponds with 'b'. So 3 means that the b-parameter is incremented by 3. Thus, the new copy line looks like this:

COPY 3;43;0

in other words, the EDITI command added 3 to the COPY line's b-parameter, turning 40 into 43

The next line is JUMP -2, which sends the pointer back 2 lines, to the COPY line. That means the next line that the pointer will run is the COPY line... the COPY line which was modified. Now the COPY line will copy the BOMB 43 spaces forward, instead of 40 like last time. Each iteration of the program will churn out another BOMB another 3 spaces forward!

As you can see, the BOMB command is part in the program but is never actually run by the program (unless it gets corrupted by the enemy prpogram), just copied across the VNA in an attempt to destroy the opponent

This type of program is called a "Bomber", and is one of the simplest possible forms of Bombers. Other Bombers may have defense mechanisms built in (to stop if it gets close to bombing itself), or better methods for efficiency, etc

So I'm going to start out VNA 2.0 with an "Opening Day Tournament", in which I need 8 battle programs submitted to me to compete in a bracketed tournament format.

If you have any questions about VNA or VNA Code, feel free to PM me!

I call this one 'the Hopper':

COPY 0;add(a(0),c(0));170

EDITI -1;1;0

JUMP com(a(-2),3,168,168,-2);0;0

It works by copying all three lines of itself 170 spaces forward, then when that is complete, jumping itself to the new copy 170 nodes forward and doing it all over again. The Hopper is very versatile and extremely hard to kill. After just 9 rounds it has sent itself to the next location. However the Hopper has its setbacks, and the major one is that it relies on the opponent bombing themselves... the only way that a Hopper can actively kill the enemy is if it (by luck) overwrites key parts of the enemy's program that causes it to completely mess up and possibly hit a BOMB

This is an even simpler form of the Hopper:

SHIFT 0;170;170

It does what the Hopper does with one third the nodes and one ninth of the total rounds it takes! This Hyper-Hopper is extremely hard to kill (a BOMB has to nail right on top of its new location right before it runs it and before it goes elsewhere), but of course it has no ability to kill the opponent, and could only win if the opponent tears themselves apart.

This one is a bit more complex, but more efficient than a simple bomber. It searches for nodes that have nonzero parameters (and thus probably at or near the enemy's program) and then bombs the area. Meanwhile it takes advantage of the new SHIFT command I added to splatter bombs around at the same time as jumping with JUMP

SHIFT 3;40;equ(nzero(b(0)),0,1,4)

EDITI -1;5;1

JUMP -2;0;0

BOMB 0;0;0

EDITI -4;1;1

COPY -2;b(-5);0

JUMP -2;0;0

This program can be improved upon, of course. It has no defense mechanisms that check to see if it's getting close to bombing itself and jump it to a next step which does something different. It also becomes an inefficient 1-node-at-a-time bomber in the last three lines. You can help yourself learn about VNA by adding onto this program and making it better

Spoiler for my best on the above:

Much more efficient, 5 lines not 7 and runs way less of them, going through iterations faster and with more accuracy. Also reduces function lag by evaluating nzero and taking out the equ around nzero (see later when I explain nzero). Basically the big thing in the c-parameter of the SHIFT command evaluates the line denoted by its own b-parameter, checks if all of its parameters are zero. If so, back one. If not, up 2

The Hunter

EDITI 1;5;1

SHIFT 1;40;equ(a(b(0))+b(b(0))+c(b(0)),0,equ(a(b(0)),b(b(0)),equ(c(b(0)),0,-1,2),2),2)

BOMB 0;0;0

EDITI -2;1;1

SHIFT -2;sub(b(-3),3);-1

I call this one 'the Liberator'. It's a devastatingly simple and powerful program that takes advantage of the new SHIFT command and random function:

SHIFT 1;rand(40,160);0

BOMB 0;0;0

The rest I've made for VNA 2.0 so far are well-thought out warrior programs that I would use in a battle and not post here :D

If you understand how it all works, and can decipher programs... but have no idea where to start in making your own, then...

Make sure you have a clear goal on what you want your program to do (this is probably the most important step). Once you have a definite idea on how you want it to work, start to think about what commands you could use to make that happen in the best way...

If you want to know about things you cannot do that cause infinite loops,

COMMANDNAME b(0);a(0);7

Look at this. It's a-param references it's b-param, which references it's a-param!! I call this a 'paradox node'

COMMANDNAME a(1);2;25

COMMANDNAME a(-1);36;0

Same thing. Or it could be a-to-b like this:

COMMANDNAME b(1);2;25

COMMANDNAME 3;a(-1);0

or you could have three nodes that work this way, or four, or five! :o The possibilities are endless! The paradox nodes don't have to be next to each other either, of course

~~

The second kind is this:

COMMANDNAME a(0);8;15

You can NEVER have a(0) in the 'a' parameter, b(0) in the 'b' parameter, or c(0) in the 'c' parameter! (Or anything that equates to 0)

Note that nzero(n) = equ(a(n)+b(n)+c(n),0,equ(a(n),b(n),equ(c(n),0,AZ,NZ),NZ),NZ)

Where AZ is the result if line n has all-zero parameters, and NZ is the result if line n has at least one nonzero parameter. I didn't actually program nzero as a function in my emulator, I just added that to help you out - if I see a use of nzero, I'll replace it with the above longer version and use 0 for AZ and 1 for NZ... but the longer version is better for you to use raw because you can make the AZ and NZ anything you want that suits the specific purpose

The modulus is your friend

mod(a,b) = a % b, or "a modulo b" or "the remainder of a/b"

The function mod(x,3) will always produce a number that is either 0, 1 or 2, regardless of the value of x. A multiple of three (such as 33) will produce 0. One over a multiple of three (such as 34) will produce 1. Two over a multiple three (such as 35) will produce 2. For example:

mod(17,3) = 2

This is extremely useful in the 'c' parameter for the EDITX or EDITI commands, where a 0/1/2 value is required to specify a/b/c to edit. Using the mod function in combination with other values will allow you to manipulate that in a more complex/efficient program that uses a single EDITX or EDITI to do all of its editing

com is even MORE your friend!

The function I use most is probably com, though in VNA 2.0 with the addition of com's sister functions (equ, geq and leq) you can make your coms look simpler. Com just has more options, but when you know how you want to compare two things, using one of the other three will make your program less cluttered by removing the fifth input value (otherwise no actual advantage).

The command I almost always pair 'com' with is JUMP (or also the c-value of SHIFT) to tell it where to jump to in the program. Thus my JUMP commands act as switching stations that take in info, analyze with 'com' (or its sister functions) and then jump to the desired location

Efficiency is key

When you can use one line to do multiple things, do it! Each round, only one node is ran by your pointer, so you want to be as efficient as possible and make your actions take up the least amount of time to complete. For example, the SHIFT command I added in 2.0 allows for simultaneous copying and then jumping, with one node. So if you ever have a situation where you need to copy and then jump, SHIFT is the command for you.

Another tip for efficiency is placing any BOMB command your program might have at the end (or in middle if you're guaranteed to not run into it) of the code, and then reference it from earlier.

Integers and decimals

int(n) gives the integer part of n, for example int(5.78) = 5, though if you wanted just the .78 part, just do sub(n,int(n))

Plan for eventualities!

Make sure you have a backup plan if your program's initial goal fails! If you are a Bomber, when you jump back to re-bomb (if yours works like that), use a com with the JUMP to make sure that the bombs aren't getting too close to home. Creating a program that is capable of doing multiple tasks and planning for various types of enemy programs is a good idea :D Especially in the Tournament Game I'm going to start, where your program must be able to vanquish different kinds of foes

Editing input values

You may have noticed there are no commands for editing input values of functions... that's because it's just not feasible to do without unnecessary complications and complexities.

Instead, there is an efficient, elegant and much easier solution... if you have an input value of a function (no matter how nested it is within other functions, doesn't matter) that you know you want to change, just use in place of it one of these functions: a(n), b(n) or c(n), pointing to an unused parameter of a line. For example, if the previous line is a JUMP command, which doesn't use its b or c parameters, you could use b(-1) or c(-1) to reference one of those unused parameters of the JUMP command, which is where you would store the value which you could then easily change with an edit command.

I also do this when I want to increment, say two different values, by the same amount. I only use 1 round to increment ONE of those values, and have the other value piggyback off of the first and reference it. For example, if two values start at 0 and 7, and every xth round I want to increment them both by 1, I just increment the first one, and have the 7 instead be add(7,v) where v is the reference to the first value (such as a(3) or something similar). This saves a lot of efficiency!! :D

The random function...

rand(m,n) is special in that given the same two input values, the output can (and usually will) differ. Every time rand is evaluated by the VNA, it will return a different value. So when is it evaluated?

* when the node which it is a part of is ran by any pointer

* when a(n), b(n) or c(n) is used to reference the parameter [a, b or c] in which the 'rand' is used

* when EDITI is used to increment the parameter that the 'rand' is part of. EDITI just uses a shortcut of add(x,i) where x is the current value and i is the amount to increment by. Thus in this case, when an operation is performed on rand (such as adding to it, subtracting, etc), it fixes the value, because a(n) or b(n) or c(n) evaluate the current value of the whole parameter (including a random output if a 'rand' is there), and thus if you add something to that, it creates a fixed number, and if you plug that fixed number back into the parameter using EDIT, it is just a number now

** the same is true of all functions. For example, you could have a nested function system that continually evaluates the line 80 in front and adds all three of its parameters together [something like add(a(80),add(b(80),c(80))) ...], but when you use a(n), b(n) or c(n) on the parameter that contains that function, it evaluates it for the CURRENT case, into a fixed value - so if you plug that fixed value back into the parameter (after, say, incrementing it or something) it is no longer a function but a fixed number

So keep that in mind when using rand :D

So if you're interested, feel free to PM me about the game and submit your program today ;D I'm hoping to get 8 people for the Opening Day Tournament :P

Share this post


Link to post
Share on other sites

Recommended Posts

  • 0

1) unreality

2) Frost

3) dms172

Just a shoutout: you don't need to have a finished program to sign up :D The tournament will start when everyone is done making and perfecting their programs ;D Sign up ASAP so we can get a bracket and stuff ready

Share this post


Link to post
Share on other sites
  • 0

I doubt i will be able to create a decent program that can get me past round 1... but i will try... But as for a name... The Red Sea

1) unreality

2) Frost

3) dms172

4) Mekal

Share this post


Link to post
Share on other sites
  • 0
Guest
halfway there :D I sent a PM earlier today to taliesin, fool, vimil, BL and octopuppy, maybe they'll show up ;D

Im still pondering on it..

Share this post


Link to post
Share on other sites
  • 0
Guest

I'm keen in principle, but have little time this weekend - and haven't even had the chance to read the instructions yet. If I am not required to do much until Monday then I'd be in.

Share this post


Link to post
Share on other sites
  • 0
There's no stressed-out time limits in this game :D It's not Mafia, hehe. Take your time ;D

Or is it... :unsure:

I think YOU are the last mafiso...

Share this post


Link to post
Share on other sites
  • 0

In testing, I'm having some second thoughts about the rand() function. It's okay to have the programs placed at random spots in the VNA, as that's the whole point - the programs are at unknown locations relative to each other, so you can't just bomb your opponent from the beginning

But the rand() function is different. Not being able to reconstruct the same game twice is one minor reason not to have it, but also it adds more randomness to a game which is based on survival & battle strategy. Any program that uses COPY/SHIFT to launch BOMBs around the VNA using the rand() function is just putting its eggs in the 'luck' basket. For this reason I'm going to take away the rand() function... which means I have to rethink one of my best programs, but that's a good thing ;D This game isn't a game of chance, it's a game where the best program wins :D

btw: for all games in VNA 2.0, luck will never be a factor. Which means that a battle between two programs will actually consist of multiple games, all at new random starting locations, in case there was one lucky scenario based on starting loc. A program must win at least 7 games AND at least 2 more games than the opponent for it to win the battle

Edited by unreality

Share this post


Link to post
Share on other sites
  • 0
Guest
In testing, I'm having some second thoughts about the rand() function. It's okay to have the programs placed at random spots in the VNA, as that's the whole point - the programs are at unknown locations relative to each other, so you can't just bomb your opponent from the beginning

But the rand() function is different. Not being able to reconstruct the same game twice is one minor reason not to have it, but also it adds more randomness to a game which is based on survival & battle strategy. Any program that uses COPY/SHIFT to launch BOMBs around the VNA using the rand() function is just putting its eggs in the 'luck' basket. For this reason I'm going to take away the rand() function... which means I have to rethink one of my best programs, but that's a good thing ;D This game isn't a game of chance, it's a game where the best program wins :D

Yeah, when I was making my program I was kinda thinking about that, it would be really easy to just have a one line bomber that randomly bombs anywhere but the line it's on. :P

Share this post


Link to post
Share on other sites
  • 0

I have just made a truly amazing program... I call it 'the Awesome' :D

btw, we still need 2 or 3 more people:

1) unreality

2) Frost

3) dms172

4) Mekal

5) FOTH

6)

7)

8) possibly unreality #2

PM everyone you know :P

Share this post


Link to post
Share on other sites
  • 0

I am not quite clear on couple points.

Do you know where your program is going to be in the queue? Or is all addressing relative? How do you handle situation when program points past the end or before the beginning of the queue? Does opponent's program start in the node immediately past where your program ends?

Is battle between 2 programs at a time, or all 8 of them occupy the queue at the same time? What happens when your program runs to the end without hitting a bomb?

Share this post


Link to post
Share on other sites
  • 0
Guest
I am not quite clear on couple points.

Do you know where your program is going to be in the queue? Or is all addressing relative? How do you handle situation when program points past the end or before the beginning of the queue? Does opponent's program start in the node immediately past where your program ends?

Is battle between 2 programs at a time, or all 8 of them occupy the queue at the same time? What happens when your program runs to the end without hitting a bomb?

Based off of what the original post says:

The program is placed randomly in the array.

All addressing is relative(the line you are on is always 0).

The array is in a loop, so it goes back to the beginning.

The opponent's program is randomly placed as well, at least 40 nodes away from yours.

The battles are between two programs at a time. Your program doesn't run to the end. It will continue past your section into the blank nodes after it(which is why you jump back to some point to prevent this).

Hope that helped. :D

I'm correct on all of this, right unreality?

Share this post


Link to post
Share on other sites
  • 0

Frost is correct :D The OP has it all: there is no absolute addressing; rather, all nodes are relative to the current line (which is '0', the next line is 1, then 2, etc, and the line before you is -1, the line before that is -2, etc). The VNA loops around, so that line 205 is the same thing as line 5

the two programs start at random points, but their opening lines are at least 40 nodes away from each other (and thus at most 160 nodes away, meaning the other program is 40-160 away from your first line). Your instruction pointer begins at the first line of your program and executes one node per round, advancing to the next round unless otherwise told by JUMP or SHIFT. If your program hits a BOMB, it dies. There is no distinction between commands made by you or commands made by your opponent or the original BLANK commands: once the programs are put in the VNA they are all the same.

The battles are between 2 programs at a time in a bracket tournament formation to decide the winner. A "battle" consists of multiple games, the first program to win at least 7 games and at least 2 more games than the opponent wins the battle (to make sure that random starting position wasn't a factor in deciding the best program)

Remember that I removed the rand() function ;D

does that answer all of your questions?

Share this post


Link to post
Share on other sites
  • 0

I'm almost done perfecting 'the Awesome' (I might change the name hehe) ;D

btw this is the roster:

1) unreality

2) Frost

3) dms172

4) Mekal

5) FOTH

6) Prime?

7)

8) possibly unreality #2

I know that Taliesin is busy, but BL is checking it out ;D

Share this post


Link to post
Share on other sites
  • 0

we could do something like this to get to four people if we have too

1 vs 2

1 vs 3

2 vs 3

and whoever lost twice or by won 1 game by the least would be out

Share this post


Link to post
Share on other sites
  • 0

Haha, I made a program that finds the enemy in 1 round and then bombs them to shreds... but as I suspected, my emulator wasn't exactly capable of running it ;D


Snare, by Unreality

EDITB 2;megastructure;0
EDITI 1;2;1
COPY 2;0;0
SHIFT 1;b(-1);-2
BOMB 0;0;0


megastructure:

equ(a(40),0,equ(a(41),0,equ(a(42),0,equ(a(43),0,equ(a(44),0,equ(a(45),0,equ(a(46
),0,equ(a(47),0,equ(a(48),0,equ(a(49),0,equ(a(50),0,equ(a(51),0,equ(a(52),0,equ(
a
(53),0,equ(a(54),0,equ(a(55),0,equ(a(56),0,equ(a(57),0,equ(a(58),0,equ(a(59),0,e
q
u(a(60),0,equ(a(61),0,equ(a(62),0,equ(a(63),0,equ(a(64),0,equ(a(65),0,equ(a(66),
0
,equ(a(67),0,equ(a(68),0,equ(a(69),0,equ(a(70),0,equ(a(71),0,equ(a(72),0,equ(a(7
3
),0,equ(a(74),0,equ(a(75),0,equ(a(76),0,equ(a(77),0,equ(a(78),0,equ(a(79),0,equ(
a
(80),0,equ(a(81),0,equ(a(82),0,equ(a(83),0,equ(a(84),0,equ(a(85),0,equ(a(86),0,e
q
u(a(87),0,equ(a(88),0,equ(a(89),0,equ(a(90),0,equ(a(91),0,equ(a(92),0,equ(a(93),
0
,equ(a(94),0,equ(a(95),0,equ(a(96),0,equ(a(97),0,equ(a(98),0,equ(a(99),0,equ(a(1
0
0),0,equ(a(101),0,equ(a(102),0,equ(a(103),0,equ(a(104),0,equ(a(105),0,equ(a(106)
,
0,equ(a(107),0,equ(a(108),0,equ(a(109),0,equ(a(110),0,equ(a(111),0,equ(a(112),0,
e
qu(a(113),0,equ(a(114),0,equ(a(115),0,equ(a(116),0,equ(a(117),0,equ(a(118),0,equ
(
a(119),0,equ(a(120),0,equ(a(121),0,equ(a(122),0,equ(a(123),0,equ(a(124),0,equ(a(
1
25),0,equ(a(126),0,equ(a(127),0,equ(a(128),0,equ(a(129),0,equ(a(130),0,equ(a(131
)
,0,equ(a(132),0,equ(a(133),0,equ(a(134),0,equ(a(135),0,equ(a(136),0,equ(a(137),0
,
equ(a(138),0,equ(a(139),0,equ(a(140),0,equ(a(141),0,equ(a(142),0,equ(a(143),0,eq
u
(a(144),0,equ(a(145),0,equ(a(146),0,equ(a(147),0,equ(a(148),0,equ(a(149),0,equ(a
(
150),0,equ(a(151),0,equ(a(152),0,equ(a(153),0,equ(a(154),0,equ(a(155),0,equ(a(15
6
),0,equ(a(157),0,equ(a(158),0,equ(a(159),0,equ(a(160),0,80,156),155),154),153),1
5
2),151),150),149),148),147),146),145),144),143),142),141),140),139),138),137),13
6
),135),134),133),132),131),130),129),128),127),126),125),124),123),122),121),120
)
,119),118),117),116),115),114),113),112),111),110),109),108),107),106),105),104)
,
103),102),101),100),99),98),97),96),95),94),93),92),91),90),89),88),87),86),85),
8
4),83),82),81),80),79),78),77),76),75),74),73),72),71),70),69),68),67),66),65),6
4
),63),62),61),60),59),58),57),56),55),54),53),52),51),50),49),48),47),46),45),44
)
,43),42),41),40),39),38),37),36)
[/codebox]

hehe - I didn't even use the full thing. This just checks for a-params, I could've made a better (and about 4 times longer :lol: ) version that checks all three parameters...

anywaaay, we still need another person or two :D PM everyone you know ;D

Edited by unreality

Share this post


Link to post
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Guest
Answer this question...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

Loading...
Sign in to follow this  

  • Recently Browsing   0 members

    No registered users viewing this page.

×
×
  • Create New...