@Mikor hal már ki a flash végre?:

@n4buk0d0n0z0r:
Mikor hal már ki a javascript végre?

@TCH:
Mihez képest?

@OrkenWhite:
Az eredeti Amigához képest. Akármelyiket is emulálom, sokszor pöcén lassabb, nemhogy egy 2000-es konzolon...

@OrkenWhite:
Még meg se jelent a játék, és már kiegészítők?! Nevetséges! Miért nem veszik a fáradtságot, hogy belerakják ezeket az alapjátékba?

switch (faszom)
{
	0:
		valami();
	break;
	1:
		meg_valami();
	break;
	2:
		mittudomen();
	break;
}

@saxus:
És egyébként is, jobban szeretem, ha a gép szolgál engem és nem én végzem el a gép munkáját.

#include <stdlib.h>

struct intarray_struct
{
	int *data;
	unsigned long long int count;
};

typedef struct intarray_struct *intarray;

#define new_intarray() (intarray)calloc(sizeof(struct intarray_struct), 1)
#define kill_intarray(ia) { free(ia->data); free(ia); ia = NULL; }

int set_intarray_e(intarray ia, unsigned long long int index, int value)
{
	if (ia == NULL)
	{
		return 1;
	}
	if (index >= ia->count)
	{
		return 2;
	}
	ia->data[index] = value;
	return 0;
}

int get_intarray_e(intarray ia, unsigned long long int index, int *value)
{
	if (ia == NULL)
	{
		return 1;
	}
	if (index >= ia->count)
	{
		return 2;
	}
	*value = ia->data[index];
	return 0;
}

int clear_intarray(intarray ia)
{
	if (ia == NULL)
	{
		return 1;
	}
	if (ia->data != NULL && ia->count > 0)
	{
		free(ia->data);
	}
	ia->data = NULL;
	ia->count = 0;
	return 0;
}

int resize_intarray(intarray ia, unsigned long long int count)
{
	int *new_data;

	if (ia == NULL)
	{
		return 1;
	}
	if (count == 0)
	{
		return clear_intarray(ia);
	}
	new_data = (int *)realloc(ia->data, sizeof(int) * count);
	if (new_data == NULL)
	{
		return 2;
	}
	ia->data = new_data;
	ia->count = count;
	return 0;
}

int append_intarray_e(intarray ia, int value)
{
	int e;

	if (ia == NULL)
	{
		return 1;
	}
	e = resize_intarray(ia, ia->count + 1);
	if (e != 0)
	{
		return e;
	}
	ia->data[ia->count - 1] = value;
	return 0;
}

int insert_intarray_e(intarray ia, unsigned long long int index, int value)
{
	int e;
	unsigned long long int lo, hi;

	if (ia == NULL)
	{
		return 1;
	}
	e = resize_intarray(ia, ia->count + 1);
	if (e != 0)
	{
		return e;
	}
	hi = ia->count - 1;
	lo = hi - 1;
	while (lo >= index)
	{
		ia->data[hi--] = ia->data[lo--];
	}
	ia->data[index] = value;
	return 0;
}

int delete_intarray_block(intarray ia, unsigned long long index, unsigned long long count)
{
	unsigned long long int i, lo, hi, limit;

	if (ia == NULL)
	{
		return 1;
	}
	if (count >= ia->count)
	{
		return clear_intarray(ia);
	}
	if (index + count > ia->count)
	{
		count = ia->count - index;
	}
	hi = index + count;
	limit = ia->count - hi;
	lo = index;
	i = 0;
	while (i++ < limit)
	{
		ia->data[lo++] = ia->data[hi++];
	}
	return resize_intarray(ia, lo);
}